GRPC源码实例解析（一）——UnaryRPC Server 篇

本文以官方提供的入门的demo helloworld（https://github.com/grpc/grpc-go/tree/master/examples/helloworld/helloworld）为例，通过源码讲解实际的grpc调用执行的流程(UnaryRPC)，为了方便理解只列出核心代码。该篇主要关注Server端源代码流程。

RegisterGreeterServer实际将helloworld.proto 中定义的Greeter_Service进行注册，所谓的服务注册。

service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

var Greeter_ServiceDesc = grpc.ServiceDesc{
    ServiceName: "helloworld.Greeter",
    HandlerType: (*GreeterServer)(nil),
    Methods: []grpc.MethodDesc{
        {
            MethodName: "SayHello",
            Handler:    _Greeter_SayHello_Handler,
        },
    },
    Streams:  []grpc.StreamDesc{},
    Metadata: "examples/helloworld/helloworld/helloworld.proto",
}

func RegisterGreeterServer(s grpc.ServiceRegistrar, srv GreeterServer) {
    s.RegisterService(&Greeter_ServiceDesc, srv)
}

func (s *Server) register(sd *ServiceDesc, ss interface{}) {
    info := &serviceInfo{
        serviceImpl: ss,
        methods:     make(map[string]*MethodDesc),
        streams:     make(map[string]*StreamDesc),
        mdata:       sd.Metadata,
    }
    for i := range sd.Methods {
        d := &sd.Methods[i]
        info.methods[d.MethodName] = d
    }
    s.services[sd.ServiceName] = info
}

Serve方法通过lis net.Listener监听连接，每次起一新的goroutine来处理 新的Conn，每一个新的连接都是在独立的线程中进行处理并发执行。

func (s *Server) Serve(lis net.Listener) error {
    for {
        rawConn, err := lis.Accept()
        go func() {
            s.handleRawConn(lis.Addr().String(), rawConn)
        }()
    }
}

建立一个HTTP2的Transport，用其进行Transport层的rpc调用执行

func (s *Server) handleRawConn(lisAddr string, rawConn net.Conn) {
    st := s.newHTTP2Transport(conn, authInfo)
    go func() {
        s.serveStreams(st)
    }()
}

func (s *Server) serveStreams(st transport.ServerTransport) {
    s.handleStream(st, stream, s.traceInfo(st, stream))
}

通过stream.Method()得到需要调用FullMethod(/helloworld.Greeter/SayHello）从注册的services列表中找到对应serviceInfo对象，进而找到MethodDesc，然后执行processUnaryRPC

func (s *Server) handleStream(t transport.ServerTransport, stream *transport.Stream, trInfo *traceInfo) {
    srv, knownService := s.services[service]
    if knownService {
        if md, ok := srv.methods[method]; ok {
            s.processUnaryRPC(t, stream, srv, md, trInfo)
            return
        }
    }

}

func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.Stream, info *serviceInfo, md *MethodDesc, trInfo *traceInfo) (err error) {
    // 实际执行定义的rpc方法google.golang.org/grpc/examples/helloworld/helloworld._Greeter_SayHello_Handler（如下）
    reply, appErr := md.Handler(info.serviceImpl, ctx, df, s.opts.unaryInt)
    //将rpc方法的值返回给客户端
    s.sendResponse(t, stream, reply, cp, opts, comp)
}

google.golang.org/grpc/examples/helloworld/helloworld._Greeter_SayHello_Handler

func _Greeter_SayHello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
    in := new(HelloRequest)
    if err := dec(in); err != nil {
        return nil, err
    }
    if interceptor == nil {
        return srv.(GreeterServer).SayHello(ctx, in)
    }
    info := &grpc.UnaryServerInfo{
        Server:     srv,
        FullMethod: "/helloworld.Greeter/SayHello",
    }
    handler := func(ctx context.Context, req interface{}) (interface{}, error) {
        return srv.(GreeterServer).SayHello(ctx, req.(*HelloRequest))
    }
    return interceptor(ctx, in, info, handler)
}

GRPC源码实例解析（二）
https://www.jianshu.com/p/944e3eb59dd8