protobuf与grpc

文档

当您看到我这篇文章的时候，也许protobuf与grpc已经发生了变化，请参阅官方文档获取最新信息
https://developers.google.com/protocol-buffers
https://grpc.io/docs/what-is-grpc/introduction/

安装

protobuf是一种编解码协议,支持多种语言，比如go,python,c++,java,javascript等，效率比json更高，但是没有json那么易于理解。
安装编译工具：
截至到发文时间已更新至v3.18.0，下载位置：github链接

然后将压缩包解压，再将bin目录设置到$PATH环境变量下即可
插件此时还不支持golang，去grp-gateway按照提示安装：

proto文件格式（经常变动，以github为准）

syntax = "proto3";
package coolcar;				//这个是其他proto文件或yaml文件的引用包名，如果没有引用，可以不写此行
option go_package="coolcar/proto/gen/go;trippb";		//前面是生成对应go文件的绝对路径，后面是包名

message Trip {
    string start = 1;
    string end = 2;
    int64 duration_sec = 3;
    int64 fee_cent = 4;
}

import其它的proto文件

syntax = "proto3";
import "base.proto";		# 引用用户自定义文件
import "google/protobuf/empty.proto";    # 引用系统文件
package coolcar;
option go_package="coolcar/proto/gen/go;trippb";

service TripService {
    rpc GetTrip (GetTripReq) returns (GetTripRsp);
    rpc Ping(google.protobuf.Empty) returns (base.Pong);	# 通过 package.xxx 使用
}

message GetTripReq {
    int64 id = 1;
}
message GetTripRsp {
    int32 id = 1;
    Trip tp = 2;
}

enum TripStatus {
    TS_NOT_SPECIFIED = 0;
    NOT_STARTED = 1;
    IN_PROGRESS = 2;
}
message Trip {
    string start = 1;
    string end = 2;
    int64 duration_sec = 3;
    int64 fee_cent = 4;
    TripStatus status = 5;
}

生成xx.pb.go文件

（命令经常变动，以github为准）
将当前目录下的proto文件编译到./gen/go中，生成序列化相关文件

protoc -I . \
--go_out ./gen/go --go_opt paths=source_relative trip.proto

如果需要生成序列化和rpc文件，执行命令

 protoc -I . \
	--go_out ./gen/go/ --go_opt paths=source_relative \
    --go-grpc_out ./gen/go/ --go-grpc_opt paths=source_relative \
    trip.proto

也可以使用如下命令生成到一个文件：
protoc -I . xxx.proto --go_out=plugins=grpc:.

编解码的具体使用

package main

import (
	trippb "coolcar/proto/gen/go"
	"fmt"

	"google.golang.org/protobuf/proto"
)

func main() {
	trip := trippb.Trip{
		Start: "abc",
		End: "def",
		DurationSec: 3600,
		FeeCent: 10000,
	}
	b,err := proto.Marshal(&trip)
	if err != nil {
		return
	}
	fmt.Println(b)
	var bb trippb.Trip
	proto.Unmarshal(b,&bb)
	fmt.Println(&bb)
}

我们知道grpc接口是无法被restful风格的前端调用的，使用grpc的命令可以帮助我们完成接口的转换：
转换前需要定义yaml文件：示例

type: google.api.Service
config_version: 3

http:
  rules:
  - selector: coolcar.TripService.GetTrip
    get: /trip/{id}

输入以下命令会得到trip.pb.pw.go文件

protoc -I . --grpc-gateway_out ./gen/go \
    --grpc-gateway_opt paths=source_relative \
    --grpc-gateway_opt grpc_api_configuration=trip.yaml \
    trip.proto

以上的代码demo：码云链接

grpc部分

metadata

metadata类似http的请求头机制，可以存一些接口以外的数据
参考
使用
client端

	//metadata发送
	md := metadata.New(map[string]string{"name": "lufei", "gender": "male"})
	ctx := metadata.NewOutgoingContext(context.Background(), md)

	tsClient := trippb.NewTripServiceClient(conn)
	ctx,_ = context.WithTimeout(ctx,time.Second * 5)
	rsp, err := tsClient.GetTrip(ctx, &trippb.GetTripReq{Id: 5})

server端

	md, ok := metadata.FromIncomingContext(ctx)
	if !ok {
		fmt.Println("get metadata error")
		return &trippb.GetTripRsp{},errors.New("认证错误,无法获取metadata")
	}
	if nameSlice, ok := md["name"]; ok {
		fmt.Println(nameSlice)
		for i, e := range nameSlice {
			fmt.Println(i, e)
		}
	}

拦截器

go中的拦截器，是请求到来的入口，类似http框架中的中间件
server端拦截器

	// 拦截器
	interceptor := func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error){
		fmt.Println("接收到请求")
		start := time.Now()
		rsp,err := handler(ctx,req)
		execTime := time.Since(start)
		fmt.Println("执行时间",execTime)
		return rsp,err
	}
	svcOption := grpc.UnaryInterceptor(interceptor)

	s := grpc.NewServer(svcOption)

client端拦截器

	// 拦截器
	inerceptor := func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error{
		start := time.Now()
		err := invoker(ctx,method,req,reply,cc,opts...)
		fmt.Println("调用时间: ",time.Since(start))
		return err
	}
	opt := grpc.WithUnaryInterceptor(inerceptor)

	conn,err := grpc.Dial("localhost:8082",grpc.WithInsecure(),opt)
	if err != nil {
		fmt.Println(err)
	}

验证器

作用： 对proto的message消息做格式验证
文档： github库
安装： 下载对应版本安装文件 放到$GOPATH/bin目录下即可
生成对应源码命令：

protoc -I . \
   --go_out ./gen/go/ --go_opt paths=source_relative \
   --go-grpc_out ./gen/go/ --go-grpc_opt paths=source_relative \
   --validate_out="lang=go:./gen/go/" --validate_opt paths=source_relative\
   trip.proto

使用：
集成到grpc的server端拦截器

package main

import (
	"context"
	"example/grpc_validate_emp/handle"
	trippb "example/grpc_validate_emp/proto/gen/go"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"log"
	"net"
)

type validator interface {
	Validate() error
}

func main() {
	log.SetFlags(log.Lshortfile)
	//go startGRPCGateway()
	lis, err := net.Listen("tcp", ":8082")
	if err != nil {
		log.Fatalf("failed")
	}

	// 拦截器
	interceptor := func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
		fmt.Println("接收到请求")
		// 将验证器集成到grpc的拦截器
		if r,ok := req.(validator); !ok {
			return nil,status.Error(codes.InvalidArgument,"类型转换失败")
		}else {
			err := r.Validate()
			if err != nil {
				return nil,status.Error(codes.InvalidArgument,err.Error())
			}
		}
		return handler(ctx, req)
	}
	svcOption := grpc.UnaryInterceptor(interceptor)

	s := grpc.NewServer(svcOption)
	fmt.Println("开启监听")
	trippb.RegisterTripServiceServer(s, &handle.Trip{})
	s.Serve(lis)
}

grpc状态码

文档：github链接
使用：
server端发送状态码：

status.Error(codes.InvalidArgument,"类型转换失败")

client端解析状态码：

	if err != nil {
		status,ok := status.FromError(err)
		if !ok {
			fmt.Println("解析不出状态码")
		}
		fmt.Println("状态码：",status.Code())
		fmt.Println("错误信息：",status.Message())
		return
	}