參考：golang grpc 快速開始
以 windows 平臺為例：

• 下載 安裝 go —— 略

• 下載 protoc
  參考：https://grpc.io/docs/protoc-installation/
  win平臺直接到 github 下載 zip 防盜本地目錄解壓即可
  下載 地址 https://github.com/protocolbuffers/protobuf/releases
  把 解壓后的 bin 目錄加到環境變量，以便控制臺找到 protoc 命令
  

  把這個bin 目錄加到環境變量

• 安裝 protoc-gen-go 和 protoc-gen-go-grpc 包

go get google.golang.org/protobuf/cmd/protoc-gen-go 
 go get  google.golang.org/grpc/cmd/protoc-gen-go-grpc

因為我當前 的 gopath 就是f:/go 所以 直接把get 包安裝到了 bin 目錄

gopath/bin 要加入到環境變量

然后就可以試一下 grpc 了

• 直接用 官方的例子

git clone -b v1.35.0 https://github.com/grpc/grpc-go

cd grpc-go/examples/helloworld
go run greeter_server/main.go
go run greeter_client/main.go
# greeter_client控制臺輸出：
> Greeting: Hello world

• 修改 rpc 服務的函數
  在 helloworld/helloworld.proto 添加SayHelloAgain()具有相同請
  求和響應類型的新方法，改成如下文件

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
  // Sends another greeting
  rpc SayHelloAgain (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

• 重新編譯更新的 .proto 文件

protoc --go_out=. --go_opt=paths=source_relative \
    --go-grpc_out=. --go-grpc_opt=paths=source_relative \
    helloworld/helloworld.proto

image.png

重新生成 了 helloworld/helloworld.pb.go和helloworld/helloworld_grpc.pb.go文件
我們 上面新添加了 一個 rpc 函數 ： SayHelloAgain

• 修改 greeter_server/main.go
  添加下面的代碼

func (s *server) SayHelloAgain(ctx context.Context, in 
*pb.HelloRequest) (*pb.HelloReply, error) {
        return &pb.HelloReply{Message: "Hello again " + in.GetName()}, nil
}

• 修改 greeter_client/main.go

main 函數末尾添加 ：

r, err = c.SayHelloAgain(ctx, &pb.HelloRequest{Name: name})
if err != nil {
        log.Fatalf("could not greet: %v", err)
}
log.Printf("Greeting: %s", r.GetMessage())

• 分別運行 greeter_server/main.go 和 greeter_client/main.go

更全面的官方教程在此, 包含普通，客戶端流，服務端流，雙向流

簡單介紹一下四種模式下的基本用法(既然看了，還是要記錄一下的)

服務端：

• 普通的調用

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
        }
    }
    // No feature was found, return an unnamed feature
    return &pb.Feature{Location: point}, nil
}

• 服務端流 ( stream.Send 不斷發響應)

// 服務端流 
func (s *routeGuideServer) ListFeatures(rect *pb.Rectangle, 
stream pb.RouteGuide_ListFeaturesServer) error {
    for _, feature := range s.savedFeatures {
        if inRange(feature.Location, rect) {
            if err := stream.Send(feature); err != nil {
                return err
            }
        }
    }
    return nil
}

• 客戶端流 ( stream.Recv() 不斷取值， 遇到 io.EOF 的錯誤，就調用 stream.SendAndClose 返回值，并通知客戶端函數執行完畢)

func (s *routeGuideServer) RecordRoute(stream pb.RouteGuide_RecordRouteServer) error {
    var pointCount, featureCount, distance int32
    var lastPoint *pb.Point
    startTime := time.Now()
    for {
        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) // 計算兩個 point之間的距離
        }
        lastPoint = point
    }
}

• 雙向流 ( stream 入參既可以Recv 也可以 Send ，每一個 recv 都會循環發送 send ,這樣就模擬了雙向的效果)

// 為了模擬流發送，他在每一個請求收到后，循環發送所有的對應
// 的值， 并且枷鎖，防止并發共享一個屬性導致出現問題
func (s *routeGuideServer) RouteChat(stream pb.RouteGuide_RouteChatServer) error {
    for {
        in, err := stream.Recv()
        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)
        // Note: this copy prevents blocking other clients while serving this one.
        // We don't need to do a deep copy, because elements in the slice are
        // insert-only and never modified.
        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
            }
        }
    }
}

客戶端
其實和服務端基本邏輯一致

• 調用服務流：

func printFeatures(client pb.RouteGuideClient, rect *pb.Rectangle) {
    log.Printf("Looking for features within %v", rect)
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    stream, err := client.ListFeatures(ctx, rect)
    if err != nil {
        log.Fatalf("%v.ListFeatures(_) = _, %v", client, err)
    }
    for {
        feature, err := stream.Recv()
        if err == io.EOF {
            break
        }
        if err != nil {
            log.Fatalf("%v.ListFeatures(_) = _, %v", client, err)
        }
        log.Printf("Feature: name: %q, point:(%v, %v)", feature.GetName(),
            feature.GetLocation().GetLatitude(), feature.GetLocation().GetLongitude())
    }
}

就是一個簡單的 for {stream.Recv()}

下面看一個簡單的，grpc 里究竟怎么實現 rpc 協議的：

func (c *routeGuideClient) GetFeature(ctx context.Context, in *Point, opts ...grpc.CallOption) (*Feature, error) {
    out := new(Feature)
    err := c.cc.Invoke(ctx, "/routeguide.RouteGuide/GetFeature", in, out, opts...)
    if err != nil {
        return nil, err
    }
    return out, nil
}

Invoke 所在接口：

type ClientConnInterface interface {
    // Invoke performs a unary RPC and returns after the response is received
    // into reply.
    Invoke(ctx context.Context, method string, args interface{}, reply interface{}, opts ...CallOption) error
    // NewStream begins a streaming RPC.
    NewStream(ctx context.Context, desc *StreamDesc, method string, opts ...CallOption) (ClientStream, error)
}

這里就類似 rpc 的風格了。(呀復習一下， go rpc 的基本寫法了)

type HelloService struct {}

func (p *HelloService) Hello(request string, reply *string) error {
    *reply = "hello:" + request
    return nil
}
其中Hello方法必須滿足Go語言的RPC規則：方法只能有兩個可序
列化的參數，其中第二個參數是指針類型，并且返回一個error類
型，同時必須是公開的方法。

grpc 官方文檔: 生成代碼結構的講解

具體講講生成的 代碼（有一些名稱是固定的格式）

服務端：

對于 service Bar{ rpc Foo( client_data) returns (server_data) ; } 為例子 ( 流的話加上關鍵字 stream 修飾參數即可 )
注冊函數 RegisterBarServer 格式為 Register<service name>Server (當然你也可以自己寫注冊的函數)

func RegisterBarServer(s *grpc.Server, srv BarServer)

普通一元函數 ( 以 Foo 為例子)

Foo(context.Context, *MsgA) (*MsgB, error)
// MsgA 接受的消息， MsgB 發送的消息

服務端流：

Foo(*MsgA, <ServiceName>_FooServer) error

// MsgA   接收到的消息
//  <ServiceName>_FooServer  流接口類型   
// <Services name>_<rpc_func_name>Server

<ServiceName>_FooServer 接口定義如下 （ 所以可以使用 Send 方法了）：

type <ServiceName>_FooServer interface {
    Send(*MsgB) error
    grpc.ServerStream
}

客戶端流

Foo(<ServiceName>_FooServer) error

type <ServiceName>_FooServer interface {
    SendAndClose(*MsgA) error
    Recv() (*MsgB, error)
    grpc.ServerStream
}

// 一直 Recv ，最后結束的時候發送一次消息 調用 SendAndClose  結束本次響應

// 流消息結束， Recv返回(nil, io.EOF)  

雙流

Foo(<ServiceName>_FooServer) error

type <ServiceName>_FooServer interface {
    Send(*MsgA) error
    Recv() (*MsgB, error)
    grpc.ServerStream
}


//同時首發數據  Send  和 Recv

客戶端接口

• 一元方法：

(ctx context.Context, in *MsgA, opts ...grpc.CallOption) (*MsgB, error)

• 服務流

Foo(ctx context.Context, in *MsgA, opts ...grpc.CallOption) (<ServiceName>_FooClient, error)
// <ServiceName>_FooClient  代表 服務端的 流對象 

type <ServiceName>_FooClient interface {
    Recv() (*MsgB, error)
    grpc.ClientStream
}

• 客戶端流

Foo(ctx context.Context, opts ...grpc.CallOption) (<ServiceName>_FooClient, error)

// <ServiceName>_FooClient代表客戶機到服務器stream的MsgA
type <ServiceName>_FooClient interface {
    Send(*MsgA) error
    CloseAndRecv() (*MsgB, error)
    grpc.ClientStream
}

• 雙向流

type <ServiceName>_FooClient interface {
    Send(*MsgA) error
    Recv() (*MsgB, error)
    grpc.ClientStream
}

暫時完畢。。

只有 客戶端流，才有 CloseAndRecv (客戶端) 和 SendAndClose （ 服務端只有這個，沒有 send）函數，其他的沒有這兩個函數