//这就是transport对象
   type serverHandlerTransport struct {
   //....
   }
   //下面这个这个方法就是传输层回调上层-路由层的方法。func(*Stream) 就是回调的函数指针
   func (ht *serverHandlerTransport) HandleStreams(startStream 	func(*Stream), traceCtx func(context.Context, string) context.Context) {
   // With this transport type there will be exactly 1 stream: this HTTP request.
   }
   

//服务描述有由protobuf通过service描述生成方法桩代码
//ServiceDesc信息就是来自桩代码 
func (s *Server) register(sd *ServiceDesc, ss interface{}) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.printf("RegisterService(%q)", sd.ServiceName)
	if s.serve {
		logger.Fatalf("grpc: Server.RegisterService after Server.Serve for %q", sd.ServiceName)
	}
	//
	if _, ok := s.services[sd.ServiceName]; ok {
		logger.Fatalf("grpc: Server.RegisterService found duplicate service registration for %q", sd.ServiceName)
	}
	//服务信息
	info := &serviceInfo{
		serviceImpl: ss,
		//一元方法描述map
		methods:     make(map[string]*MethodDesc),
		//流式方法描述map
		streams:     make(map[string]*StreamDesc),
		mdata:       sd.Metadata,
	}
	//填入一元方法描述
	for i := range sd.Methods {
		d := &sd.Methods[i]
		info.methods[d.MethodName] = d
	}
	//填入流式方法描述
	for i := range sd.Streams {
		d := &sd.Streams[i]
		info.streams[d.StreamName] = d
	}
	s.services[sd.ServiceName] = info
}

func (s *Server) serveStreams(st transport.ServerTransport) {
	defer st.Close()
	var wg sync.WaitGroup

	var roundRobinCounter uint32
	//st 为servertransport对象，stream 则为transport层给上层回调函数的传参代表一次请求
	st.HandleStreams(func(stream *transport.Stream) {
		wg.Add(1)
		//如果设置了工作池，则消息通过chan传递出去；
		if s.opts.numServerWorkers > 0 {
			data := &serverWorkerData{st: st, wg: &wg, stream: stream}
			select {
			case s.serverWorkerChannels[atomic.AddUint32(&roundRobinCounter, 1)%s.opts.numServerWorkers] <- data:
			default:
				// If all stream workers are busy, fallback to the default code path.  
				go func() {
					s.handleStream(st, stream, s.traceInfo(st, stream))
					wg.Done()
				}()
			}
		} else {
		//默认情况下直接go出协程处理
			go func() {
				defer wg.Done()
				s.handleStream(st, stream, s.traceInfo(st, stream))
			}()
		}
	}, func(ctx context.Context, method string) context.Context {
		if !EnableTracing {
			return ctx
		}
		tr := trace.New("grpc.Recv."+methodFamily(method), method)
		return trace.NewContext(ctx, tr)
	})
	wg.Wait()
}

func (s *Server) handleStream(t transport.ServerTransport, stream *transport.Stream, trInfo *traceInfo) {
	//.... 省略
	service := sm[:pos]
	method := sm[pos+1:]

	srv, knownService := s.services[service]
	if knownService {
		if md, ok := srv.methods[method]; ok {
			//一元请求消息
			//1. 解压缩
			//2. decode
			//3. 通过下面的语句调用service层注册的service方法。
			//reply, appErr := md.Handler(info.serviceImpl, ctx, df, s.opts.unaryInt)
			s.processUnaryRPC(t, stream, srv, md, trInfo)
			return
		}
		if sd, ok := srv.streams[method]; ok {
		//流式消息
			s.processStreamingRPC(t, stream, srv, sd, trInfo)
			return
		}
	}
	//....省略
}