gRPC构建微服务

1、编写proto文件

// 版本号
syntax = "proto3";

// 指定包名
package proto;

// 定义结构体
message UserRequest {
    // 定义用户名
    string name = 1;
}

// 响应结构体
message UserResponse {
    int32 id = 1;
    string name = 2;
    int32 age = 3;
    // repeated修饰符是可变数组，go转切片
    repeated string hobby = 4;
}

// service定义方法
service UserInfoService {
    rpc GetUserInfo (UserRequest) returns (UserResponse) {
    }
}

2、生成.go文件

goland中打开命令行，输入命令生成接口文件：

旧版命令：protoc -I . --go_out=plugins=grpc:. ./user.proto，仅生成一个*.pb.go文件

新版命令：protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative ./user.proto，会生成两个文件 *.pb.go 和 *_grpc.pb.go

注意：最新版本的grpc需要在Server的结构中需要带上pb.UnimplementedGreeterServer否则会报错

3、编写服务端

package main

// 1.需要监听
// 2.需要实例化gRPC服务端
// 3.在gRPC商注册微服务
// 4.启动服务端
import (
   "context"
   "fmt"
   pb "/gRPC/proto"  //注意这个路径
   "google.golang.org/grpc"
   "net"
)

// 定义空接口
type UserInfoService struct{
    // 使用 新版命令 生成的 需要添加下面的内容
    // pb.UnimplementedGreeterServer
}

var u = UserInfoService{}

// 实现方法
func (s *UserInfoService) GetUserInfo(ctx context.Context, req *pb.UserRequest) (resp *pb.UserResponse, err error) {
   // 通过用户名查询用户信息
   name := req.Name
   // 数据里查用户信息
   if name == "zs" {
      resp = &pb.UserResponse{
         Id:    1,
         Name:  name,
         Age:   22,
         Hobby: []string{"Sing", "Run"},
      }
   }
   return
}

func main() {
   // 地址
   addr := "127.0.0.1:8080"
   // 1.监听
   listener, err := net.Listen("tcp", addr)
   if err != nil {
      fmt.Printf("监听异常:%s\n", err)
   }
   fmt.Printf("监听端口：%s\n", addr)
   // 2.实例化gRPC
   s := grpc.NewServer()
   // 3.在gRPC上注册微服务
   pb.RegisterUserInfoServiceServer(s, &u)
   // 4.启动服务端
   s.Serve(listener)
}

4、编写客户端

package main

import (
   "context"
   "fmt"
   pb "/gRPC/proto"   //注意这个路径
   "google.golang.org/grpc"
)

// 1.连接服务端
// 2.实例gRPC客户端
// 3.调用

func main() {
   // 1.连接
   conn, err := grpc.Dial("127.0.0.1:8080", grpc.WithInsecure())
   if err != nil {
      fmt.Printf("连接异常： %s\n", err)
   }
   defer conn.Close()
   // 2. 实例化gRPC客户端
   client := pb.NewUserInfoServiceClient(conn)
   // 3.组装请求参数
   req := new(pb.UserRequest)
   req.Name = "zs"
   // 4. 调用接口
   response, err := client.GetUserInfo(context.Background(), req)
   if err != nil {
      fmt.Println("响应异常  %s\n", err)
   }
   fmt.Printf("响应结果： %v\n", response)
}

5、gRPC 四种通信方式

• 简单 RPC（Simple RPC）：即客户端发送一个请求给服务端，从服务端获取一个应答，就像一次普通的函数调用。

rpc SayHello(HelloRequest) returns (HelloResponse){
}

• 服务端流式 RPC（Server-side streaming RPC）：一个请求对象，服务端可以传回多个结果对象。
  即客户端发送一个请求给服务端，可获取一个数据流用来读取一系列消息。客户端从返回的数据流里一直读取直到没有更多消息为止。

rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse){
}

• 客户端流式 RPC（Client-side streaming RPC）：客户端传入多个请求对象，服务端返回一个响应结果。
  即客户端用提供的一个数据流写入并发送一系列消息给服务端。一旦客户端完成消息写入，就等待服务端读取这些消息并返回应答。

rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse) {
}

• 双向流式 RPC（Bidirectional streaming RPC）：结合客户端流式 rpc 和服务端流式 rpc，可以传入多个对象，返回多个响应对象。
  即两边都可以分别通过一个读写数据流来发送一系列消息。这两个数据流操作是相互独立的，所以客户端和服务端能按其希望的任意顺序读写。
  例如：服务端可以在写应答前等待所有的客户端消息，或者它可以先读一个消息再写一个消息，或者是读写相结合的其他方式。每个数据流里消息的顺序会被保持。

rpc BidiHello(stream HelloRequest) returns (stream HelloResponse){
}

备注：开启grpc日志方式

设置环境变量

GRPC_GO_LOG_VERBOSITY_LEVEL=99
GRPC_GO_LOG_SEVERITY_LEVEL=info