【GO】六、protubuf 与 GRPC （二）

grpc中的错误处理机制

client

server

proto

client.go：

package main

import (
	"FirstGo/goon/grpc_test/proto"
	"context"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/status"
)

func main() {
	var opts []grpc.DialOption
	opts = append(opts, grpc.WithInsecure())
	conn, err := grpc.Dial("127.0.0.1:8080", opts...) // 然后再将形成的 slice 以 ... 进行拆分传入
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	// 创建客户端
	c := proto.NewGreeterClient(conn)
	// 调用对应的方法
	_, err = c.SayHello(context.Background(), &proto.HelloRequest{
		Name: "Chen",
	})
	// 若接收到错误信息
	if err != nil {
		// 从Error中取出状态码和对应的信息
		st, ok := status.FromError(err)
		if !ok {
			panic("Error解析失败")
		}
		fmt.Println(st.Code(), st.Message())
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

server.go

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"net"

	"FirstGo/goon/grpc_test/proto-bak"
)

type Server struct{}

func (s *Server) SayHello(ctx context.Context, request *proto_bak.HelloRequest) (*proto_bak.HelloReply, error) {
	fmt.Println("收到请求")
	// 测试错误信息，第一个参数是错误码，第二个参数是错误信息
	return nil, status.Errorf(codes.NotFound, "找不到资源:%s", request.Name)
}

func main() {
	g := grpc.NewServer()
	proto_bak.RegisterGreeterServer(g, &Server{})
	lis, err := net.Listen("tcp", "0.0.0.0:8080")
	if err != nil {
		panic("failed to listen: " + err.Error())
	}
	err = g.Serve(lis)
	if err != nil {
		panic("failed to start grpc: " + err.Error())
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

超时机制

超时机制的设置有其必要性，每个对服务的调用都要设置超时机制，因为服务的调用需要超时机制来限制网络，以及可能发生的一系列情况，后面会慢慢提到，这里需要理解的是：超时机制是一个务必设置的内容

超时机制最简单的设置就是在修改context：

在客户端：

ctx, _ := context.WithTimeout(context.Background(), time.Second * 3)
	// 调用对应的方法
	_, err = c.SayHello(ctx, &proto.HelloRequest{
		Name: "Chen",
	})
1
2
3
4
5

若超时，我们可以捕捉到错误，其状态码是 DeadlineExceeded

proto源码理解

对于一个简单的proto源码

syntax = "proto3";
option go_package = ".;proto";
service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

message 部分其会生成对应的struct

type HelloRequest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}
1
2
3
4
5
6
7

rpc部分的serverstub部分：其会生成统一管理的xxxServer接口与用来将接口注册进rpc的RegisterxxxServer：

type GreeterServer interface {
	SayHello(context.Context, *HelloRequest) (*HelloReply, error)
}

type GreeterServer interface {
	SayHello(context.Context, *HelloRequest) (*HelloReply, error)
}
1
2
3
4
5
6
7

rpc部分的client部分：生成：

type GreeterClient interface {
	SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error)
}

type greeterClient struct {
	cc grpc.ClientConnInterface
}

func NewGreeterClient(cc grpc.ClientConnInterface) GreeterClient {
	return &greeterClient{cc}
}

func (c *greeterClient) SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, Greeter_SayHello_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20