这次分享一下当grpc服务器在启动时都做了什么事情?
可以自己先思考一下，假设让我们自己去开发一个简单版本的grpc服务器端启动时都会做什么事情呢?
a.一些初始化工作
b.监听某个端口
c.注册服务端提供的服务
。。。。。
好了，接下来看一下grpc-go框架服务器端启动时的流程图：

grpc服务器端启动时都做了哪些事情

在下面的章节中只是介绍了常用的初始化组件，有些功能需要手动显示的调用，或者import导入才能初始化或者注册，比方说grpc-go/encoding/gzip/gzip.go文件中的gzip压缩器需要手动导入，因此就不再一一介绍了。
一个链接请求，对应一个http2Server对象，一个帧接收器，一个帧发送器;

1、注册、初始化工作

下面几个小节，仅仅列出了grpc-go源码中哪些文件实现了注册、初始化等工作。
至于详细原理介绍，会再后面的章节中分享。

1.1、注册服务

通过下面的形式，可以将提供的服务注册到grpc服务器端，以供客户端调用；
这里我们以源码中自带的heloworld为例，将SayHello服务注册到grpc服务器端：

注册服务

1.2、解析器初始化

在grpc框架里内置了几种解析器，也可以自定义解析器；
像passthrough、dns解析器在grpc服务器启动时会自己注册；
像manual、xds解析器，需要在代码里显示注册才生效；

1.2.1、passthrough解析器(默认使用，启动时自己注册)

.../internal/resolver/passthrough/passthrough.go文件中

func init() {
   resolver.Register(&passthroughBuilder{})
}

1.2.2、dns解析器(启动时自己注册)

.../internal/resolver/dns/dns_resolver.go文件中

func init() {
   resolver.Register(NewBuilder())
}

1.2.3、Manual解析器(需要手动显示的注册)

.../resolver/manual/manual.go文件中

func GenerateAndRegisterManualResolver() (*Resolver, func()) {
   scheme := strconv.FormatInt(time.Now().UnixNano(), 36)
   r := NewBuilderWithScheme(scheme)
   resolver.Register(r)
   return r, func() { resolver.UnregisterForTesting(scheme) }
}

如果想要使用manual解析器的话，需要手动显示的注册一下，如下参考例子:
.../examples/features/health/client/main.go文件

1．func main() {
2．   flag.Parse()

3．   r, cleanup := manual.GenerateAndRegisterManualResolver()
4．   defer cleanup()
5．   r.InitialState(resolver.State{
6．      Addresses: []resolver.Address{
7．         {Addr: "localhost:50051"},
8．         {Addr: "localhost:50052"},
9．      },
10．   })

11．   address := fmt.Sprintf("%s:///unused", r.Scheme())
// -------省略不相关代码------

核心代码说明：
1.第3行，手动注册指定解析器
.../examples/features/debugging/client/main.go文件:

1．func main() {
2．   /***** Set up the server serving channelz service. *****/
3．   lis, err := net.Listen("tcp", ":50052")
4．   if err != nil {
5．      log.Fatalf("failed to listen: %v", err)
6．   }
7．   defer lis.Close()
8．   s := grpc.NewServer()
9．   service.RegisterChannelzServiceToServer(s)
10．   go s.Serve(lis)
11．   defer s.Stop()

12．   /***** Initialize manual resolver and Dial *****/
13．   r, rcleanup := manual.GenerateAndRegisterManualResolver()
14．   defer rcleanup()
15．   // Set up a connection to the server.
16．   conn, err := grpc.Dial(r.Scheme()+":///test.server", grpc.WithInsecure(), grpc.WithBalancerName("round_robin"))
17．   if err != nil {
18．      log.Fatalf("did not connect: %v", err)
19．   }
20．   defer conn.Close()
21．// ------省略不相关代码------

主要代码说明：
1.第13行，手动注册指定解析器

1.2.4、xds 解析器(需要手动显示的注册)

xds解析器，一般情况下，grpc服务器启动时并没有注册xds解析器，需要手动的注册。
.../xds/internal/resolver/xds_resolver.go文件中初始化：

func init() {
   resolver.Register(&xdsResolverBuilder{})
}

如何注册xds解析器呢？
在.../xds/xds.go文件中:

1．package xds

2．import (
3．   _ "google.golang.org/grpc/xds/internal/balancer" // Register the balancers.
4．   _ "google.golang.org/grpc/xds/internal/resolver" // Register the xds_resolver
5．)

主要流程说明：
1.第4行，注册xds解析器
根据go语言的特性，如果某个包没有使用的话，是不会导入的；因此，如果我们想使用xds解析器的话，需要手动的显示导入，如下所示:
随便找一个grpc服务器端启动的例子：

import (
   "context"
   "fmt"
   "github.com/CodisLabs/codis/pkg/utils/log"
   "google.golang.org/grpc"
   "google.golang.org/grpc/codes"
   "google.golang.org/grpc/metadata"
   "google.golang.org/grpc/status"
   "net"
   pb "servergrpc/model/sgrpc/model2"
   "time"
   _ "google.golang.org/grpc/balancer/grpclb"
   //_ "google.golang.org/grpc/balancer/rls/internal"
   _ "google.golang.org/grpc/xds"
)

代码说明：
1.第14行，将xds包导入到grpc服务器里，也就是将xds作为插件注册到了grpc服务器里

1.2.5、自定义解析器

在../examples/features/name_resolving/client/main.go文件进行初始化:

func init() {
   // Register the example ResolverBuilder. This is usually done in a package's
   // init() function.
   resolver.Register(&exampleResolverBuilder{})
}

grpc-go源码自带的测试用例中还有其他自定义解析器，这里就不一一列举了。

1.3、平衡构建器的注册

平衡构建器的注册是通过../balancer/balancer.go文件中的Register函数来实现的。

func Register(b Builder) {
   m[strings.ToLower(b.Name())] = b
}

注册时，需要传入一个构建器Builder，类型是接口：

1．// Builder creates a balancer.
2．type Builder interface {
3．   // Build creates a new balancer with the ClientConn.
4．   // 在 balancer_conn_wrappers.go文件中的newCCBalancerWrapper方法里，调用此方法了
5．   Build(cc ClientConn, opts BuildOptions) Balancer

6．   // Name returns the name of balancers built by this builder.
7．   // It will be used to pick balancers (for example in service config).
8．   Name() string
9．}

主要代码说明：
1.第5行：为客户端连接器ClientConn创建一个平衡器
2.第8行：返还的是平衡器的名称；注册或者根据名称获取指定平衡器时使用的。
下面图片展示了当前grpc-go框架中内置的平衡构建器：

内置平衡构建器展示

注意：
平衡构建器是用来创建平衡器的。
平衡器的创建是在客户端跟服务器端进行链接过程中创建的。

1.3.1、baseBuilder平衡构建器

在grpc-go/balancer/base/balancer.go文件中定义了baseBuilder平衡构建器。

1．type baseBuilder struct {
2．   name          string
3．   pickerBuilder PickerBuilder
4．   config        Config
}

主要代码说明：
1.第2行：用来设置构建器的名称
2.第3行：这是一个picker构建器
看一下PickerBuilder源码：
在grpc-go/balancer/base/base.go文件中:

1．// PickerBuilder creates balancer.Picker.
2．type PickerBuilder interface {
3．   // Build returns a picker that will be used by gRPC to pick a SubConn.
4．   Build(info PickerBuildInfo) balancer.Picker
}

主要代码说明：
1.第4行：创建一个balancer.Picker构建器；
这个Picker到底是用来做什么呢？
比方说，在某个场景下存在多个服务器端提供服务，客户端同时与这些服务器端建立起了链接，当客户端需要调用服务器端的服务时，需要从这些链接中根据平衡器策略选择一个链接进行服务调用。（简单的说，就是picker需要从众多链接中选择一个进行帧的接收）
下面图片显示了grpc-go框架中内置实现的PickerBuilder：

PickerBuilder平衡构建器

1.3.2、pickFirst平衡构建器注册

在grpc-go/pickfirst.go文件中注册了pickFirst构建器：

func init() {
   balancer.Register(newPickfirstBuilder())
}

其中，传入的构建器newPickerfirstBuilder()，代码如下:

// PickFirstBalancerName is the name of the pick_first balancer.
const PickFirstBalancerName = "pick_first"

// 初始化Pickerfirst 构建器
func newPickfirstBuilder() balancer.Builder {
   return &pickfirstBuilder{}
}

type pickfirstBuilder struct{}

1.3.3、round_robin平衡器注册

在grpc-go/balancer/roundrobin/roundrobin.go文件中：

1．// Name is the name of round_robin balancer.
2．const Name = "round_robin"

3．// newBuilder creates a new roundrobin balancer builder.
4．func newBuilder() balancer.Builder {
5．   return base.NewBalancerBuilder(Name, &rrPickerBuilder{}, base.Config{HealthCheck: true})
6．}

7．func init() {
8．   balancer.Register(newBuilder())
9．}

10．type rrPickerBuilder struct{}

主要代码说明：
1.第2行：设置平衡器的名称
2.第4-6行：创建round_robin平衡构建器函数，内部调用的是base.NewBalancerBuilder函数
3.第7-9行：将round_robin平衡器构建器注册到grpc服务器里
4.第10行：定义一个rrPickerBuilder结构体；很明显，前缀rr是round_robin的首字母缩写；在grpc-go框架中，有很多类似的情况。

接下来，看一下base.NewBalancerBuilder函数内部：

1．func NewBalancerBuilder(name string, pb PickerBuilder, config Config) balancer.Builder {
2．      return &baseBuilder{
3．      name:          name,
4．      pickerBuilder: pb,
5．      config:        config,
6．   }
7．}

主要代码说明：
1.第2-6行：round_robin构建器内部调用的是baseBuilder构建器。
在实现平衡器的过程中最主要的就是要实现PickerBuilder，如何众多链接中选择一个链接进行客户端跟服务器端的数据交换，也就是设置选择链接的策略。不同的平衡器选择策略不同，如随机选择，始终选择第一个pickerFirst，或者根据链接的权重进行选择，或者轮询选择策略round_robin。

1.3.4、grpclb平衡器注册

在grpc-go/balancer/grpclb/grpclb.go文件中，进行了初始化:

1．func init() {
2．   balancer.Register(newLBBuilder())
3．   dns.EnableSRVLookups = true
4．}

5．// newLBBuilder creates a builder for grpclb.
6．func newLBBuilder() balancer.Builder {
7．      return newLBBuilderWithFallbackTimeout(defaultFallbackTimeout)
8．}
9．func newLBBuilderWithFallbackTimeout(fallbackTimeout time.Duration) balancer.Builder {
10．   return &lbBuilder{
11．      fallbackTimeout: fallbackTimeout,
12．   }
13．}

14．type lbBuilder struct {
15．   fallbackTimeout time.Duration
16．}

主要代码说明：
1.第1-4行：注册lb构建器
2.第6-8行：创建lb构建器函数，内部调用的是newLBBuilderWithFallbackTimeout函数
需要说明的是，grpclb构建器在grpc启动时默认并没有启动，如果想要启动的话，需要显示的导入，如下所示：
在/grpc-go/examples/features/load_balancing/server/main.go测试用例中：

1．package main

2．import (
3．   "context"
4．   "fmt"
5．   "github.com/CodisLabs/codis/pkg/utils/log"
6．   "net"
7．   "sync"

8．   "google.golang.org/grpc"

9．   _ "google.golang.org/grpc/balancer/grpclb"
10．   pb "servergrpc/examples/features/proto/echo"
11．)

主要代码说明：
1.第9行：将grpclb构建器显示的导入到服务器中

1.4、编解码器初始化

grpc-go框架中使用protoc作为默认的编解码器。
在grpc-go/encoding/proto/proto.go文件中：

1．// Name is the name registered for the proto compressor.
2．const Name = "proto"

3．func init() {
4．   encoding.RegisterCodec(codec{})
5．}

6．// codec is a Codec implementation with protobuf. It is the default codec for gRPC.
7．type codec struct{}

主要代码说明：
1.第3-5行：注册编解码器codec
看一下，encoding.RegisterCodec函数内部:

1．func RegisterCodec(codec Codec) {
2．   if codec == nil {
3．      panic("cannot register a nil Codec")
4．   }
5．   if codec.Name() == "" {
6．      panic("cannot register Codec with empty string result for Name()")
7．   }
8．   contentSubtype := strings.ToLower(codec.Name())
9．   registeredCodecs[contentSubtype] = codec
10．}

主要代码说明：
1.第2-7行：主要做一些校验工作。
2.第9行：将protoc注册到registeredCodecs容器里
注意：
此函数并非线程安全的，在启动时如果存在多个相同名称的编码器注册的话，会以最后一个注册的编码器有效。

1.5、拦截器初始化

拦截器的初始化主要分为两大步骤：

1.5.1、自定义拦截器

例如：在grpc-go/examples/features/interceptor/server/main.go文件中：

1．func unaryInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
2．   // authentication (token verification)
3．   md, ok := metadata.FromIncomingContext(ctx)
4．   if !ok {
5．      return nil, errMissingMetadata
6．   }
7．   if !valid(md["authorization"]) {
8．      return nil, errInvalidToken
9．   }
10．   m, err := handler(ctx, req)
11．   if err != nil {
12．      logger("RPC failed with error %v", err)
13．   }
14．   return m, err
15．}

主要代码说明：
1.第2-9行：在调用真正处理函数之前，要做的事情；比方说，打印日志之类的工作。
2.第10行：调用真正处理的函数，也就是客户端要调用的服务。在后面分析拦截器的原理时再详细的说明。

1.5.2、将拦截器注册到服务器端

1．func main() {
2．   flag.Parse()

3．   lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
4．   if err != nil {
5．      log.Fatalf("failed to listen: %v", err)
6．   }

7．   s := grpc.NewServer(grpc.Creds(creds), grpc.UnaryInterceptor(unaryInterceptor), grpc.StreamInterceptor(streamInterceptor))

8．   // Register EchoServer on the server.
9．   pb.RegisterEchoServer(s, &server{})

10．   if err := s.Serve(lis); err != nil {
11．      log.Fatalf("failed to serve: %v", err)
12．   }
13．}

主要代码说明：
1.第7行：就是将拦截器注册到gprc服务器端
这里仅仅说明一下，grpc-go是如何注册拦截器的，后面的章节将详细的分享拦截器的原理。

2、服务器监听工作

2.1、grpc服务器是如何监听客户端的请求呢？

例如，在grpc-go/examples/helloworld/greeter_server/main.go文件中:

1．func main() {
2．   lis, err := net.Listen("tcp", port)
3．   if err != nil {
4．      log.Fatalf("failed to listen: %v", err)
5．   }
6．   s := grpc.NewServer()
7．   pb.RegisterGreeterServer(s, &server{})
8．   if err := s.Serve(lis); err != nil {
9．      log.Fatalf("failed to serve: %v", err)
10．   }
11．}

主要代码说明：
1.第2行：创建一个监听目标，只监听tcp协议的请求，端口号是port
2.第6行：创建grpc服务器
3.第7行：将服务注册到grpc服务器里
4.第8行：启动grpc服务器对监听目标开始监听
进入方法Serve里：
在grpc-go/server.go文件里：(只显示了核心代码):

1．func (s *Server) Serve(lis net.Listener) error {
2．   s.serve = true
3．   // 1、将监听 进行存储，true表示处于监听状态
4．   ls := &listenSocket{Listener: lis}
5．   for {
6．      rawConn, err := lis.Accept()
7．    
8．      go func() {
9．         s.handleRawConn(rawConn)
10．      }()
11．   }
12．}

在源码文件中，找到for循环即可。
主要代码说明：
1.第2行：表示grpc服务器端处于运行状态
2.第6行：阻塞方式监听客户端的请求，如果没有请求时会一直阻塞此处。
3.第8-10行：针对新的链接，grpc服务器开启一个协程处理客户端的链接。一个请求链接对应一个协程；

后面的章节再详细的介绍接收到客户端的请求后，grpc服务器端做了哪些事情。

本篇文章主要是分析了grpc服务器端启动后，都做了哪些事情；这样的话，以后用到哪个组件时，就知道在什么地方进行的初始化，赋值等操作了。
其实很多框架都是类似的情形，如创建各种组件，初始化，注册，监听端口等；