Fabric的节点通过grpc向内部或外部提供接口，在学习源码之前，需要对grpc的基本使用有所了解，并了解如何在grpc中配置tls。因此，本节整理了go语言中grpc四种类型的服务模式

示例来源：http://doc.oschina.net/grpc?t=60133
具体代码可见：https://github.com/ssj234/fabric/tree/master/grpc-go

2.定义服务

2.1 定义服务

RouteGuide服务有四个方法，代表了四种模式，

service RouteGuide {
    // 根据点获取Feature
    rpc GetFeature(Point) returns (Feature){}
    // 矩形内包含多个点，获取矩形内点对于的Feature，返回是一个流类型
    rpc ListFeatures(Rectangle) returns (stream Feature){}
    // 输入是一个流，服务器可以不断的获取客户端发生的点，最后返回RouteSummary
    rpc RecordRoute(stream Point) returns (RouteSummary){}
   // 输入和输出都是流式的，可以不断的获取输入并返回
    rpc RouteChat(stream RouteNote) returns (stream RouteNote){}
}

2.2生成代码

使用protoc3可以生成go语言代码

protoc --go_out=plugins=grpc:. grpc_guide.proto

2.3 非stream服务

服务器端程序在使用grpc时，首先需要定义一个结构体，并为其实现服务

type routeGuideServer struct {
    savedFeatures []*pb.Feature // 初始化后就是只读的了
    mu         sync.Mutex // 多线程，保护routeNotes
    routeNotes map[string][]*pb.RouteNote // 保存了名称与RouteNote
}

服务端程序
对于非stream服务，我们需要实现rpc GetFeature(Point) returns (Feature){}，逻辑是通过客户端发生的Point，在savedFeatures中查找这个点所在的feature，如果没有有将传入的Point包装为Feature并返回。

// 通过Point查找Feature，Feature有个变量叫做location
func (s *routeGuideServer) GetFeature(ctx context.Context, point *pb.Point) (*pb.Feature, error) {
    for _,feature := range s.savedFeatures{
        if proto.Equal(feature.Location,point){
            return feature,nil
        }
    }
    // 没有的话就创建一个，设置location为point
    return &pb.Feature{Location:point},nil
}

客户端程序

客户端程序与上一章节中一样，建立连接后获取client并调用即可

var opts []grpc.DialOption
    opts = append(opts, grpc.WithInsecure())
    conn, err := grpc.Dial("127.0.0.1:9999", opts...)
    if err != nil {
        log.Fatalf("fail to dial: %v", err)
    }
    defer conn.Close()
    client := pb.NewRouteGuideClient(conn) // 使用pb生成client

    // 调用GetFeature
    feature, err := client.GetFeature(context.Background(), &pb.Point{Latitude:409146138, Longitude:-746188906})
    if err != nil {
        log.Fatalf("%v.GetFeatures(_) = _, %v: ", client, err)
    }
    log.Println(feature)

2.3 服务端stream服务

服务端程序
服务端steam服务是服务器收到客户端的请求后不断的返回数据，rpc ListFeatures(Rectangle) returns (stream Feature){} 这个服务用来返回矩形内的Feature

func (s *routeGuideServer) ListFeatures(rect *pb.Rectangle, stream pb.RouteGuide_ListFeaturesServer) error {
     // 遍历savedFeatures，查看是否在rect里面
    for _, feature := range s.savedFeatures {
        if inRange(feature.Location, rect) {
            if err := stream.Send(feature);err != nil{
                return err
            }
        }
    }
    return nil
}

客户端程序

point1 := &pb.Point{Longitude:-743977337,Latitude:407033786}
    point2 := &pb.Point{Longitude:-740477477,Latitude:414653148}
    rectangle := &pb.Rectangle{Lo:point1,Hi:point2}
    stream, err := client.ListFeatures(context.Background(),rectangle)
    for {
        feature, err := stream.Recv()
        if err == io.EOF {
            break
        }
        if err != nil {
            log.Fatalf("%v.ListFeatures(_) = _, %v", client, err)
        }
        log.Println(feature)
    }

2.4 客户端stream服务

rpc RecordRoute(stream Point) returns (RouteSummary){}，这个服务不断的接收客户端请求，最后收到EOF后返回RouteSummary

服务端程序

func (s *routeGuideServer) RecordRoute(stream pb.RouteGuide_RecordRouteServer) error {
    var pointCount, featureCount, distance int32
    var lastPoint *pb.Point // 最后一个点
    startTime := time.Now() // 开始时间
    for{  // 不断的收到客户端轻轻，直到EOF
        point,err := stream.Recv()
        if err == io.EOF{
            endTime := time.Now()
            return stream.SendAndClose(&pb.RouteSummary{
                PointCount:pointCount,
                FeatureCount:featureCount,
                Distance:distance,
                ElapsedTime:int32(endTime.Sub(startTime).Seconds()),
            })
        }
        if err != nil{
            return  err
        }
        pointCount++
        for _,feature := range s.savedFeatures{
            if proto.Equal(feature.Location,point){
                featureCount++
            }
        }

        if lastPoint != nil{
            distance += calcDistance(lastPoint,point)
        }
        lastPoint = point
    }

}

客户端程序

// 构造一些point
    r := rand.New(rand.NewSource(time.Now().UnixNano()))
    pointCount := int(r.Int31n(100)) + 2 // Traverse at least two points
    var points []*pb.Point
    for i := 0; i < pointCount; i++ {
        points = append(points, randomPoint(r))
    }
    // 调用服务
    stream, err := client.RecordRoute(context.Background())
    for _, point := range points {
        if err := stream.Send(point); err != nil {
            log.Fatalf("%v.Send(%v) = %v", stream, point, err)
        }
    }
    // 结束调用
    reply, err := stream.CloseAndRecv()
    log.Printf("Route summary: %v", reply)

2.5 双向stream服务

服务端程序

func (s *routeGuideServer) RouteChat(stream pb.RouteGuide_RouteChatServer) error {

    for{
        in,err := stream.Recv() // RouteNote error
        if err == io.EOF{
            return nil
        }
        if err != nil{
            return  err
        }

        key := serialize(in.Location)
        s.mu.Lock()
        s.routeNotes[key] = append(s.routeNotes[key],in)
        rn := make([]*pb.RouteNote, len(s.routeNotes[key]))
        copy(rn,s.routeNotes[key])
        s.mu.Unlock()

        for _, note := range rn { // 不断的发出
            if err := stream.Send(note); err != nil {
                return err
            }
        }

    }
}

客户端程序

stream, err := client.RouteChat(context.Background())
    // 由于在发送RouteNode的同时，还要接收RouteNode，因此使用go
    waitc := make(chan struct{})
    go func() {
        for {
            in, err := stream.Recv()
            if err == io.EOF {
                close(waitc) // 关闭chan
                return
            }
            log.Printf("Got message %s at point(%d, %d)", in.Message, in.Location.Latitude, in.Location.Longitude)
        }
    }()

    for _, note := range getNodes() {
        if err := stream.Send(note); err != nil {
            log.Fatalf("Failed to send a note: %v", err.Error())
        }
    }
    stream.CloseSend()
    <-waitc // 等待chan关闭