gRPC-go源码（2）：ClientConn

摘要

在上一篇文章中，我们聊了聊gRPC是怎么管理一条从Client到Server的连接的。

我们聊到了gRPC拥有Resolver，用来解析地址；拥有Balancer，用来做负载均衡。

在这一篇文章中，我们将从代码的角度来分析gRPC是怎么设计Resolver和Balancer的，并会从头到尾的梳理一遍连接是怎么建立的。

1 DialContext

DialContext是客户端建立连接的入口函数，我们看看在这个函数里面做了哪些事情：

func DialContext(ctx context.Context, target string, opts ...DialOption) (conn *ClientConn, err error) {// 1.创建ClientConn结构体cc := &ClientConn{target:            target,...}// 2.解析targetcc.parsedTarget = grpcutil.ParseTarget(cc.target, cc.dopts.copts.Dialer != nil)// 3.根据解析的target找到合适的resolverBuilderresolverBuilder := cc.getResolver(cc.parsedTarget.Scheme)// 4.创建ResolverrWrapper, err := newCCResolverWrapper(cc, resolverBuilder)// 5.完事return cc, nil
}

显而易见，在省略了亿点点细节之后，我们发现建立连接的过程其实也很简单，我们梳理一遍：

因为gRPC没有提供服务注册，服务发现的功能，所以需要开发者自己编写服务发现的逻辑：也就是Resolver——解析器。

在得到了解析的结果，也就是一连串的IP地址之后，需要对其中的IP进行选择，也就是Balancer。

其余的就是一些错误处理、兜底策略等等，这些内容不在这一篇文章中讲解。

2 Resolver的获取

我们从Resolver开始讲起。

cc.parsedTarget = grpcutil.ParseTarget(cc.target, cc.dopts.copts.Dialer != nil)

关于ParseTarget的逻辑我们用简单一句话来概括：获取开发者传入的target参数的地址类型，在后续查找适合这种类型地址的Resolver。

然后我们来看查找Resolver的这部分操作，这部分代码比较简单，我在代码中加了一些注释：

resolverBuilder := cc.getResolver(cc.parsedTarget.Scheme)func (cc *ClientConn) getResolver(scheme string) resolver.Builder {// 先查看是否在配置中存在resolverfor _, rb := range cc.dopts.resolvers {if scheme == rb.Scheme() {return rb}}// 如果配置中没有相应的resolver，再从注册的resolver中寻找return resolver.Get(scheme)
}// 可以看出，ResolverBuilder是从m这个map里面找到的
func Get(scheme string) Builder {if b, ok := m[scheme]; ok {return b}return nil
}

看到这里我们可以推测：对于每个ResolverBuilder，是需要提前注册的。

我们找到Resolver的代码中，果然发现他在init()的时候注册了自己。

func init() {resolver.Register(&passthroughBuilder{})
}// 注册Resolver，即是把自己加入map中
func Register(b Builder) {m[b.Scheme()] = b
}

至此，我们已经研究完了Resolver的注册和获取。

3 ResolverWrapper的创建

回到ClientConn的创建过程中，在获取到了ResolverBuilder之后，进行下一步的操作：

rWrapper, err := newCCResolverWrapper(cc, resolverBuilder)

gRPC为了实现插件式的Resolver，因此采用了装饰器模式，创建了一个ResolverWrapper。

我们看看在创建ResolverWrapper的细节：

func newCCResolverWrapper(cc *ClientConn, rb resolver.Builder) (*ccResolverWrapper, error) {ccr := &ccResolverWrapper{cc:   cc,done: grpcsync.NewEvent(),}// 根据传入的Builder，创建resolver，并放入wrapper中ccr.resolver, err = rb.Build(cc.parsedTarget, ccr, rbo)return ccr, nil
}

好，到了这里我们可以暂停一下。

我们停下来思考一下我们需要实现的功能：为了解耦Resolver和Balancer，我们希望能够有一个中间的部分，接收到Resolver解析到的地址，然后对它们进行负载均衡。因此，在接下来的代码阅读过程中，我们可以带着这个问题：Resolver和Balancer的通信过程是什么样的？

再看上面的代码，ClientConn的创建已经结束了。那么我们可以推测，剩下的逻辑就在rb.Build(cc.parsedTarget, ccr, rbo)这一行代码里面。

4 Resolver的创建

其实，Build并不是一个确定的方法，他是一个接口。

type Builder interface {Build(target Target, cc ClientConn, opts BuildOptions) (Resolver, error)
}

在创建Resolver的时候，我们需要在Build方法里面初始化Resolver的各种状态。并且，因为Build方法中有一个target的参数，我们会在创建Resolver的时候，需要对这个target进行解析。

也就是说，创建Resolver的时候，会进行第一次的域名解析。并且，这个解析过程，是由开发者自己设计的。

到了这里我们会自然而然的接着考虑，解析之后的结果应该保存为什么样的数据结构，又应该怎么去将这个结果传递下去呢？

我们拿最简单的passthroughResolver来举例：

func (*passthroughBuilder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (resolver.Resolver, error) {r := &passthroughResolver{target: target,cc:     cc,}// 创建Resolver的时候，进行第一次的解析r.start()return r, nil
}// 对于passthroughResolver来说，正如他的名字，直接将参数作为结果返回
func (r *passthroughResolver) start() {r.cc.UpdateState(resolver.State{Addresses: []resolver.Address{{Addr: r.target.Endpoint}}})
}

我们可以看到，对于一个Resolver，需要将解析出的地址，传入resolver.State中，然后调用r.cc.UpdateState方法。

那么这个r.cc.UpdateState又是什么呢？

他就是我们上面提到的ccResolverWrapper。

这个时候逻辑就很清晰了，gRPC的ClientConn通过调用ccResolverWrapper来进行域名解析，而具体的解析过程则由开发者自己决定。在解析完毕后，将解析的结果返回给ccResolverWrapper。

5 Balancer的选择

我们因此也可以进行推测：在ccResolverWrapper中，会将解析出的结果以某种形式传递给Balancer。

我们接着往下看：

func (ccr *ccResolverWrapper) UpdateState(s resolver.State) {...// 将Resolver解析的最新状态保存下来ccr.curState = s// 对状态进行更新ccr.poll(ccr.cc.updateResolverState(ccr.curState, nil))
}

关于poll方法这里就不提了，重点我们看ccr.cc.updateResolverState(ccr.curState, nil)这部分。

这里的ccr.cc中的cc，就是我们创建的ClientConn对象。

也就是说，此时Resolver解析的结果，最终又回到了ClientConn中。

注意，对于updateResolverState方法，在源码中逻辑比较深，主要是为了处理各种情况。在这里我直接把核心的那部分贴出来，所以这部分的代码你可以理解为是伪代码实现，和原本的代码是有出入的。如果你希望看到具体的实现，你可以去阅读gRPC的源码。

func (cc *ClientConn) updateResolverState(s resolver.State, err error) error {var newBalancerName string// 假设已经配置好了balancer，那么使用配置中的balancerif cc.sc != nil && cc.sc.lbConfig != nil {newBalancerName = cc.sc.lbConfig.name} // 否则的话，遍历解析结果中的地址，来判断应该使用哪种balancerelse {var isGRPCLB boolfor _, a := range addrs {if a.Type == resolver.GRPCLB {isGRPCLB = truebreak}}if isGRPCLB {newBalancerName = grpclbName} else if cc.sc != nil && cc.sc.LB != nil {newBalancerName = *cc.sc.LB} else {newBalancerName = PickFirstBalancerName}}// 具体的balancer逻辑cc.switchBalancer(newBalancerName)// 使用balancerWrapper更新Client的状态bw := cc.balancerWrapperuccsErr := bw.updateClientConnState(&balancer.ClientConnState{ResolverState: s, BalancerConfig: balCfg})return ret
}

我们再来看看switchBalancer到底做了什么：

func (cc *ClientConn) switchBalancer(name string) {...builder := balancer.Get(name)cc.curBalancerName = builder.Name()cc.balancerWrapper = newCCBalancerWrapper(cc, builder, cc.balancerBuildOpts)
}

是不是有一种似曾相识的感觉？

没错，这部分的代码，跟ResolverWrapper的创建过程很接近。都是获取到对应的Builder Name，然后通过name来获取对应的Builder，然后创建wrapper。

func newCCBalancerWrapper(cc *ClientConn, b balancer.Builder, bopts balancer.BuildOptions)   *ccBalancerWrapper {ccb := &ccBalancerWrapper{cc:       cc,scBuffer: buffer.NewUnbounded(),done:     grpcsync.NewEvent(),subConns: make(map[*acBalancerWrapper]struct{}),}go ccb.watcher()ccb.balancer = b.Build(ccb, bopts)return ccb
}

这里的ccb.watcher我们先不管他，这个是跟连接的状态有关的内容，我们将在下一篇文章在进行分析。

同样的，Build具体的Balancer的过程，也是由开发者自己决定的。

在Balancer的创建过程中，涉及到了连接的管理。我们同样的把这部分内容放在下一篇中。在这篇文章中我们的主线任务还是Resolver和Balancer的交互是怎么样的。

在创建完相应的BalancerWrapper之后，就来到了bw.updateClientConnState这行了。

注意，这里的bw就是我们上面创建的balancer。也就是说这里又来到了真正的Balancer逻辑。

但是这其中的代码我们在这篇文章中先不进行介绍，gRPC对于真正的HTTP/2连接的管理逻辑也比较的复杂，我们下篇文章见。

6 小结

到这里我们来总结一下：创建ClientConn的时候创建ResolverWrapper，由ClientConn通知ResolverWrapper进行域名解析。

此时，ResolverWrapper会将这个请求交给真正的Resolver，由真正的Resolver来处理域名解析。

解析完毕后，Resolver会将结果保存在ResolverWrapper中，ResolverWrapper再将这个结果返回给ClientConn。

当ClientConn发现解析的结果发生了改变，那么他就会去通知BalancerWrapper，重新进行负载均衡。此时BalancerWrapper又会去让真正的Balancer做这件事，最终将结果返回给ClientConn。

我们画张图来展示这个过程：