摘要
在上一篇文章中，我们聊了聊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.解析target
cc.parsedTarget = grpcutil.ParseTarget(cc.target, cc.dopts.copts.Dialer != nil)
// 3.根据解析的target找到合适的resolverBuilder
resolverBuilder := cc.getResolver(cc.parsedTarget.Scheme)
// 4.创建Resolver
rWrapper, 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 {
// 先查看是否在配置中存在resolver
for _, 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，那么使用配置中的balancer
if cc.sc != nil && cc.sc.lbConfig != nil {
newBalancerName = cc.sc.lbConfig.name
}
// 否则的话，遍历解析结果中的地址，来判断应该使用哪种balancer
else {
var isGRPCLB bool
for _, a := range addrs {
if a.Type == resolver.GRPCLB {
isGRPCLB = true
break
}
}
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.balancerWrapper
uccsErr := 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。
我们画张图来展示这个过程：
写在最后
首先，谢谢你能看到这里。
这是一篇纯源码解读的文章，作为上一篇纯理论文章的补充。建议两篇文章配合一起食用：）
如果在这个过程中，你有任何的疑问，都可以留言给我，或者在公众号“红鸡菌”中找到我。
在下一篇文章中，我将向你介绍Balancer中的具体细节，也就是gRPC的底层连接管理。同样的，我应该也会用一篇文章来介绍应该怎么设计，然后再用一篇文章来介绍具体的实现，我们下篇文章再见。
再次感谢你的阅读！