本文以官方提供的入門的demo helloworld（https://github.com/grpc/grpc-go/tree/master/examples/helloworld/helloworld）為例宋距，通過源碼講解實際的grpc調(diào)用執(zhí)行的流程(UnaryRPC)轴踱，為了方便理解只列出核心代碼。該篇主要關(guān)注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監(jiān)聽連接壶唤，每次起一新的goroutine來處理 新的Conn雳灵，每一個新的連接都是在獨立的線程中進行處理并發(fā)執(zhí)行。

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調(diào)用執(zhí)行

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()得到需要調(diào)用FullMethod(/helloworld.Greeter/SayHello）從注冊的services列表中找到對應serviceInfo對象悯辙，進而找到MethodDesc，然后執(zhí)行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) {
    // 實際執(zhí)行定義的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源碼實例解析（二）
http://www.reibang.com/p/944e3eb59dd8