示例代码如下：

func TestDiscovery(t *testing.T) {
    client, err := clientv3.New(clientv3.Config{
        Endpoints: []string{
            "127.0.0.1:2379",
        },
    })
    if err != nil {
        panic(err)
    }
    dis := etcd.New(client)
    endpoint := "discovery:///system_services"
    conn, err := grpc.DialInsecure(context.Background(), grpc.WithDiscovery(dis), grpc.WithEndpoint(endpoint))
    if err != nil {
        panic(err)
    }
    user := v1.NewUserInfoClient(conn)
    reply, _ := user.Detail(context.Background(), &v1.DetailRequest{
        Id: 2,
    })

    t.Logf("%v", reply)
    //panic("boom")

}

这是一个kratos通过etcd调用服务的流程，让我们通过分析kratos的流程来学习一下grpc的使用

endpoint := "discovery:///system_services"
conn, err := grpc.DialInsecure(context.Background(), grpc.WithDiscovery(dis), grpc.WithEndpoint(endpoint))

最开始我们定义了一个endpoint，通过跟踪，发现这个endpoint被直接传给了go标准包grpc中的DialContext

    //github.com/go-kratos/kratos/v2/transport/grpc/client.go:147
    //...
    if insecure {
        grpcOpts = append(grpcOpts, grpc.WithTransportCredentials(grpcinsecure.NewCredentials()))
    }
    if options.tlsConf != nil {
        grpcOpts = append(grpcOpts, grpc.WithTransportCredentials(credentials.NewTLS(options.tlsConf)))
    }
    if len(options.grpcOpts) > 0 {
        grpcOpts = append(grpcOpts, options.grpcOpts...)
    }
    return grpc.DialContext(ctx, options.endpoint, grpcOpts...)

那么这个endpoint里的discovery是什么意思呢?grpc是如何知道我们要调用etcd作为discovery，又是如何获取到服务的链接的呢?

我们继续追踪代码：

//github.com/go-kratos/kratos/v2/transport/grpc/client.go:139
//...
if options.discovery != nil {
        grpcOpts = append(grpcOpts,
            grpc.WithResolvers(
                discovery.NewBuilder(
                    options.discovery,
                    discovery.WithInsecure(insecure),
                )))
    }

发现kratos将discovery包装成一个resolver.Builder传给了grpc.WithResolvers

resolver.Builder由grpc标准包定义：

type Builder interface {
    // Build creates a new resolver for the given target.
    //
    // gRPC dial calls Build synchronously, and fails if the returned error is
    // not nil.
    Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)
    // Scheme returns the scheme supported by this resolver.
    // Scheme is defined at https://github.com/grpc/grpc/blob/master/doc/naming.md.
    Scheme() string
}

规定了两个方法，grpc通过第一个Build方法来构建Resolver对象

// Resolver watches for the updates on the specified target.
// Updates include address updates and service config updates.
type Resolver interface {
    // ResolveNow will be called by gRPC to try to resolve the target name
    // again. It's just a hint, resolver can ignore this if it's not necessary.
    //
    // It could be called multiple times concurrently.
    ResolveNow(ResolveNowOptions)
    // Close closes the resolver.
    Close()
}

第二个Schema返回schema的名称，grpc通过这个方法来获取Resolver对象

用实际代码来说明：

//google.golang.org/grpc/clientconn.go:1574
func (cc *ClientConn) parseTargetAndFindResolver() (resolver.Builder, error) {
    channelz.Infof(logger, cc.channelzID, "original dial target is: %q", cc.target)

    var rb resolver.Builder
    parsedTarget, err := parseTarget(cc.target)
    if err != nil {
        channelz.Infof(logger, cc.channelzID, "dial target %q parse failed: %v", cc.target, err)
    } else {
        channelz.Infof(logger, cc.channelzID, "parsed dial target is: %+v", parsedTarget)
        rb = cc.getResolver(parsedTarget.Scheme)
        if rb != nil {
            cc.parsedTarget = parsedTarget
            return rb, nil
        }
    }
//...

这里parseTarget方法解析了我们之前传入的target，规则为[scheme]://[authority]/endpoint

// parseTarget uses RFC 3986 semantics to parse the given target into a
// resolver.Target struct containing scheme, authority and endpoint. Query
// params are stripped from the endpoint.
func parseTarget(target string) (resolver.Target, error) {
    u, err := url.Parse(target)
    if err != nil {
        return resolver.Target{}, err
    }
    // For targets of the form "[scheme]://[authority]/endpoint, the endpoint
    // value returned from url.Parse() contains a leading "/". Although this is
    // in accordance with RFC 3986, we do not want to break existing resolver
    // implementations which expect the endpoint without the leading "/". So, we
    // end up stripping the leading "/" here. But this will result in an
    // incorrect parsing for something like "unix:///path/to/socket". Since we
    // own the "unix" resolver, we can workaround in the unix resolver by using
    // the `URL` field instead of the `Endpoint` field.
    endpoint := u.Path
    if endpoint == "" {
        endpoint = u.Opaque
    }
    endpoint = strings.TrimPrefix(endpoint, "/")
    return resolver.Target{
        Scheme:    u.Scheme,
        Authority: u.Host,
        Endpoint:  endpoint,
        URL:       *u,
    }, nil
}

其中Schema部分放入resolver.Target的Schema里，endpoint部分放入resovler.Target的endpoint中

这里Host部分放入了Authority，官方的说明是:
authority indicates the DNS server to use, although this is only supported by some implementations. (In C-core, the default DNS resolver does not support this, but the c-ares based resolver supports specifying this in the form "IP:port".)
大意是说，只有在某些实现中才会支持，但至少etcd中我们是用不到的

接着通过getResolver方法获取了Schema对应的resolver.Builder

func (cc *ClientConn) getResolver(scheme string) resolver.Builder {
    for _, rb := range cc.dopts.resolvers {
        if scheme == rb.Scheme() {
            return rb
        }
    }
    return resolver.Get(scheme)
}

清楚了grpc如何获取对应的discovery，下面就是grpc如何获取服务的链接了

我们回过头来看kratos中builder.go，这个方法是kratos对resolver.Builder的
实现

//github.com/go-kratos/kratos/v2/transport/grpc/resolver/discovery/builder.go:61
func (b *builder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (resolver.Resolver, error) {
    var (
        err error
        w   registry.Watcher
    )
    done := make(chan struct{}, 1)
    ctx, cancel := context.WithCancel(context.Background())
    go func() {
        w, err = b.discoverer.Watch(ctx, strings.TrimPrefix(target.URL.Path, "/"))
        close(done)
    }()
    select {
    case <-done:
    case <-time.After(b.timeout):
        err = errors.New("discovery create watcher overtime")
    }
    if err != nil {
        cancel()
        return nil, err
    }
    r := &discoveryResolver{
        w:                w,
        cc:               cc,
        ctx:              ctx,
        cancel:           cancel,
        insecure:         b.insecure,
        debugLogDisabled: b.debugLogDisabled,
    }
    go r.watch()
    return r, nil
}

kratos先是调用了etcd的watch方法来对服务状态进行监视，详见：Go操作etcd - 知乎 (zhihu.com)

接着创建了一个协程来调用resolver的watch方法

func (r *discoveryResolver) watch() {
    for {
        select {
        case <-r.ctx.Done():
            return
        default:
        }
        ins, err := r.w.Next()
        if err != nil {
            if errors.Is(err, context.Canceled) {
                return
            }
            log.Errorf("[resolver] Failed to watch discovery endpoint: %v", err)
            time.Sleep(time.Second)
            continue
        }
        r.update(ins)
    }
}

这个方法里kratos自己定义了一个Watcher对象用来监控etcd状态的改变，Next主要用来在每次服务状态改变时获取服务的新实例，在服务状态未改变时会阻塞协程，就不展开了

重点在于update方法

func (r *discoveryResolver) update(ins []*registry.ServiceInstance) {
    addrs := make([]resolver.Address, 0)
    endpoints := make(map[string]struct{})
    for _, in := range ins {
        endpoint, err := endpoint.ParseEndpoint(in.Endpoints, endpoint.Scheme("grpc", !r.insecure))
        if err != nil {
            log.Errorf("[resolver] Failed to parse discovery endpoint: %v", err)
            continue
        }
        if endpoint == "" {
            continue
        }
        // filter redundant endpoints
        if _, ok := endpoints[endpoint]; ok {
            continue
        }
        endpoints[endpoint] = struct{}{}
        addr := resolver.Address{
            ServerName: in.Name,
            Attributes: parseAttributes(in.Metadata),
            Addr:       endpoint,
        }
        addr.Attributes = addr.Attributes.WithValue("rawServiceInstance", in)
        addrs = append(addrs, addr)
    }
    if len(addrs) == 0 {
        log.Warnf("[resolver] Zero endpoint found,refused to write, instances: %v", ins)
        return
    }
    err := r.cc.UpdateState(resolver.State{Addresses: addrs})
    if err != nil {
        log.Errorf("[resolver] failed to update state: %s", err)
    }

    if !r.debugLogDisabled {
        b, _ := json.Marshal(ins)
        log.Infof("[resolver] update instances: %s", b)
    }
}

update方法在服务改变时调用了r.cc.UpdateState，而r.cc是一个resolver.ClientConn对象，接受一个resolver.State对象作为参数

我们可以看到，kratos就是在这里把每次改变服务地址写入进去的。

至此我们已经搞清了所有的疑问，在grpc中如何使用服务发现的方法也已经明晰

首先我们要自己实现一个resolver.Builder与resolver.Resolver,通过WithResovers，resolverBuilder用来生成resolver.Resolver

然后将resolver.Builder通过grpc.WithResolvers传入grpc.DialContext

在resolver.Builder的Build方法中，我们需要调用etcd的watch方法来监视服务状态的改变，并且在服务改变后需要调用resolver.ClientConn的UpdateState方法来改变服务的地址