Golang的序列化-RPC和GRPC
作者：尹正杰
版权声明：原创作品，谢绝转载！否则将追究法律责任。
一.RPC概述
1>.什么是RPC
RPC(Remote Procedure Call Protocol)，是远程过程调用的缩写，通俗的说就是调用远处(一般指不同的主机)的一个函数。
2>.为什么微服务需要RPC
我们使用微服务化的一个好处就是，不限定服务的提供方使用什么技术选型，能够实现公司跨团队的技术解耦。
这样的话，如果没有统一的服务框架，RPC框架，各个团队的服务提供方就需要各自实现一套序列化、反序列化、网络框架、连接池、收发线程、超时处理、状态机等“业务之外”的重复技术劳动，造成整体的低效。
所以，统一RPC框架把上述“业务之外”的技术劳动统一处理，是服务化首要解决的问题。
二.RPC入门案例
在互联网时代，RPC已经和IPC(进程间通信)一样成为一个不可或缺的基础构件。因此Go语言的标准库也提供了一个简单的RPC实现，我们将以此为入口学习RPC的常见用法。
1>.RPC的服务端
package main import ( "fmt" "net" "net/rpc" ) type Zabbix struct{} /** 定义成员方法: 第一个参数是传入参数. 第二个参数必须是传出参数(引用类型). Go语言的RPC规则： 方法只能有两个可序列化的参数，其中第二个参数是指针类型，并且返回一个error类型，同时必须是公开的方法。 温馨提示: 当调用远程函数之后，如果返回的错误不为空，那么传出参数为空。 */ func (Zabbix) MonitorHosts(name string, response *string) error { *response = name + "主机监控中..." return nil } func main() { /** 进程间交互有很多种，比如基于信号,共享内存,管道,套接字等方式. 1>.rpc基于是TCP的,因此我们需要先开启监听端口 */ listener, err := net.Listen("tcp", ":8888") if err != nil { fmt.Println("开启监听器失败,错误原因: ", err) return } defer listener.Close() fmt.Println("服务启动成功...") /** 2>.接受链接，即接受传输的数据 */ conn, err := listener.Accept() if err != nil { fmt.Println("建立链接失败...") return } defer conn.Close() fmt.Println("建立连接: ", conn.RemoteAddr()) /** 3>.注册rpc服务，维护一个hash表，key值是服务名称，value值是服务的地址。服务器有很多函数，希望被调用的函数需要注册到RPC上。 以下是RegisterName的函数签名: func RegisterName(name string, rcvr interface{}) error 以下是对函数签名相关参数的说明: name: 指的是服务名称。 rcvr: 指的是结构体对象(这个结构体必须含有成员方法)。 */ rpc.RegisterName("zabbix", new(Zabbix)) /** 4>.链接的处理交给RCP框架处理,即rpc调用,并返回执行后的数据,其工作原理大致分为以下3个步骤: (1)read,获取服务名称和方法名，获取请求数据; (2)调用对应服务里面的方法，获取传出数据; (3)write,把数据返回给client; */ rpc.ServeConn(conn) }
2>.RPC的客户端
package main import ( "fmt" "net" "net/rpc" ) func main() { /** 1>.首选是通过rpc.Dial拨号RPC服务 温馨提示: 默认数据传输过程中编码方式是gob,可以选择json */ conn, err := net.Dial("tcp", "127.0.0.1:8888") if err != nil { fmt.Println("链接服务器失败") return } defer conn.Close() /** 2>.把conn和rpc进行绑定 */ client := rpc.NewClient(conn) /** 3>.然后通过client.Call调用具体的RPC方法。其中Call函数的签名如下所示: func (client *Client) Call(serviceMethod string, args interface{}, reply interface{}) error 以下是对函数签名的相关参数进行补充说明: serviceMethod: 用点号(.)链接的RPC服务名字和方法名字 args: 指定输入参数 reply: 指定输出参数接收的 */ var data string err = client.Call("zabbix.MonitorHosts", "Nginx", &data) if err != nil { fmt.Println("远程接口调用失败,错误原因: ", err) return } fmt.Println(data) }
三.跨语言的RPC
标准库的RPC默认采用Go语言特有的gob编码，因此从其它语言调用Go语言实现的RPC服务将比较困难。跨语言是互联网时代RPC的一个首要条件，这里我们再来实现一个跨语言的RPC。
得益于RPC的框架设计，Go语言的RPC其实也是很容易实现跨语言支持的。这里我们将尝试通过官方自带的net/rpc/jsonrpc扩展实现一个跨语言RPC。
1>.RPC的服务端
package main import ( "fmt" "net" "net/rpc" "net/rpc/jsonrpc" ) type OpenFalcon struct{} /** 定义成员方法: 第一个参数是传入参数. 第二个参数必须是传出参数(引用类型). Go语言的RPC规则： 方法只能有两个可序列化的参数，其中第二个参数是指针类型，并且返回一个error类型，同时必须是公开的方法。 温馨提示: 当调用远程函数之后，如果返回的错误不为空，那么传出参数为空。 */ func (OpenFalcon) MonitorHosts(name string, response *string) error { *response = name + "主机监控中..." return nil } func main() { /** 进程间交互有很多种，比如基于信号,共享内存,管道,套接字等方式. 1>.rpc基于是TCP的,因此我们需要先开启监听端口 */ listener, err := net.Listen("tcp", ":8888") if err != nil { fmt.Println("开启监听器失败,错误原因: ", err) return } defer listener.Close() fmt.Println("服务启动成功...") /** 2>.接受链接，即接受传输的数据 */ conn, err := listener.Accept() if err != nil { fmt.Println("建立链接失败...") return } defer conn.Close() fmt.Println("建立连接: ", conn.RemoteAddr()) /** 3>.注册rpc服务，维护一个hash表，key值是服务名称，value值是服务的地址。服务器有很多函数，希望被调用的函数需要注册到RPC上。 以下是RegisterName的函数签名: func RegisterName(name string, rcvr interface{}) error 以下是对函数签名相关参数的说明: name: 指的是服务名称。 rcvr: 指的是结构体对象(这个结构体必须含有成员方法)。 */ rpc.RegisterName("open_falcon", new(OpenFalcon)) /** 4>.链接的处理交给RCP框架处理,即rpc调用,并返回执行后的数据,其工作原理大致分为以下3个步骤: (1)read,获取服务名称和方法名，获取请求数据; (2)调用对应服务里面的方法，获取传出数据; (3)write,把数据返回给client; */ jsonrpc.ServeConn(conn) }
2>.RPC的客户端
package main import ( "fmt" "net/rpc/jsonrpc" ) func main() { /** 首选是通过rpc.Dial拨号RPC服务 温馨提示: 默认数据传输过程中编码方式是gob,可以选择json,需要导入"net/rpc/jsonrpc"包。 */ conn, err := jsonrpc.Dial("tcp", "127.0.0.1:8888") if err != nil { fmt.Println("链接服务器失败") return } defer conn.Close() var data string /** 其中Call函数的签名如下所示: func (client *Client) Call(serviceMethod string, args interface{}, reply interface{}) error 以下是对函数签名的相关参数进行补充说明: serviceMethod: 用点号(.)链接的RPC服务名字和方法名字 args: 指定输入参数 reply: 指定输出参数接收的 */ err = conn.Call("open_falcon.MonitorHosts", "Httpd", &data) if err != nil { fmt.Println("远程接口调用失败,错误原因: ", err) return } fmt.Println(data) }
四.ProtoBuf
博主推荐阅读: https://www.cnblogs.com/yinzhengjie2020/p/12741943.html
五.GRPC框架
1>.什么是GRPC
GRPC是Google公司基于Protobuf开发的跨语言的开源RPC框架。 GRPC是一个高性能、开源和通用的 RPC 框架，面向移动和 HTTP/2 设计。目前提供C,Java和Go语言版本，分别是：grpc, grpc-java, grpc-go. 其中C版本支持 C, C++, Node.js, Python, Ruby, Objective-C, PHP 和 C# 支持. GRPC基于HTTP/2标准设计，带来诸如双向流、流控、头部压缩、单 TCP 连接上的多复用请求等特。这些特性使得其在移动设备上表现更好，更省电和节省空间占用。 博主推荐阅读: GRPC 官方文档中文版: http://doc.oschina.net/grpc?t=60133 GRPC官网： https://grpc.io
2>.安装grpc环境
C:Usersyinzhengjie>go get -u -v google.golang.org/grpc
3>.基于protobuf编写Grpc服务
////protobuf默认支持的版本是2.0,现在一般使用3.0版本,所以需要手动指定版本号 //c语言的编程风格 syntax = "proto3"; //指定包名 package pb; //定义传输数据的格式 message People{ string name = 1; //1表示表示字段是1 数据库中表的主键id等于1,主键不能重复,标示位数据不能重复 //标示位不能使用19000 -19999 系统预留位 int32 age = 2; //结构体嵌套 student s = 3; //使用数组/切片 repeated string phone = 4; //oneof的作用是多选一 oneof data{ int32 score = 5; string city = 6; bool good = 7; } } //oneof c语言中的联合体 message student{ string name = 1; int32 age = 6; } //通过定义服务,然后借助框架,帮助实现部分的rpc代码 service Hello{ rpc World(student)returns(student); }
////protobuf默认支持的版本是2.0,现在一般使用3.0版本,所以需要手动指定版本号 //c语言的编程风格 // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.21.0 // protoc v3.11.4 // source: grpc.proto //指定包名 package pb import ( context "context" proto "github.com/golang/protobuf/proto" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" ) const ( // Verify that this generated code is sufficiently up-to-date. _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) // Verify that runtime/protoimpl is sufficiently up-to-date. _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) // This is a compile-time assertion that a sufficiently up-to-date version // of the legacy proto package is being used. const _ = proto.ProtoPackageIsVersion4 //定义传输数据的格式 type People struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` //1表示表示字段是1 数据库中表的主键id等于1,主键不能重复,标示位数据不能重复 //标示位不能使用19000 -19999 系统预留位 Age int32 `protobuf:"varint,2,opt,name=age,proto3" json:"age,omitempty"` //结构体嵌套 S *Student `protobuf:"bytes,3,opt,name=s,proto3" json:"s,omitempty"` //使用数组/切片 Phone []string `protobuf:"bytes,4,rep,name=phone,proto3" json:"phone,omitempty"` //oneof的作用是多选一 // // Types that are assignable to Data: // *People_Score // *People_City // *People_Good Data isPeople_Data `protobuf_oneof:"data"` } func (x *People) Reset() { *x = People{} if protoimpl.UnsafeEnabled { mi := &file_grpc_proto_msgTypes[0] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *People) String() string { return protoimpl.X.MessageStringOf(x) } func (*People) ProtoMessage() {} func (x *People) ProtoReflect() protoreflect.Message { mi := &file_grpc_proto_msgTypes[0] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use People.ProtoReflect.Descriptor instead. func (*People) Descriptor() ([]byte, []int) { return file_grpc_proto_rawDescGZIP(), []int{0} } func (x *People) GetName() string { if x != nil { return x.Name } return "" } func (x *People) GetAge() int32 { if x != nil { return x.Age } return 0 } func (x *People) GetS() *Student { if x != nil { return x.S } return nil } func (x *People) GetPhone() []string { if x != nil { return x.Phone } return nil } func (m *People) GetData() isPeople_Data { if m != nil { return m.Data } return nil } func (x *People) GetScore() int32 { if x, ok := x.GetData().(*People_Score); ok { return x.Score } return 0 } func (x *People) GetCity() string { if x, ok := x.GetData().(*People_City); ok { return x.City } return "" } func (x *People) GetGood() bool { if x, ok := x.GetData().(*People_Good); ok { return x.Good } return false } type isPeople_Data interface { isPeople_Data() } type People_Score struct { Score int32 `protobuf:"varint,5,opt,name=score,proto3,oneof"` } type People_City struct { City string `protobuf:"bytes,6,opt,name=city,proto3,oneof"` } type People_Good struct { Good bool `protobuf:"varint,7,opt,name=good,proto3,oneof"` } func (*People_Score) isPeople_Data() {} func (*People_City) isPeople_Data() {} func (*People_Good) isPeople_Data() {} type Student struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` Age int32 `protobuf:"varint,6,opt,name=age,proto3" json:"age,omitempty"` } func (x *Student) Reset() { *x = Student{} if protoimpl.UnsafeEnabled { mi := &file_grpc_proto_msgTypes[1] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Student) String() string { return protoimpl.X.MessageStringOf(x) } func (*Student) ProtoMessage() {} func (x *Student) ProtoReflect() protoreflect.Message { mi := &file_grpc_proto_msgTypes[1] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Student.ProtoReflect.Descriptor instead. func (*Student) Descriptor() ([]byte, []int) { return file_grpc_proto_rawDescGZIP(), []int{1} } func (x *Student) GetName() string { if x != nil { return x.Name } return "" } func (x *Student) GetAge() int32 { if x != nil { return x.Age } return 0 } var File_grpc_proto protoreflect.FileDescriptor var file_grpc_proto_rawDesc = []byte{ 0x0a, 0x0a, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x02, 0x70, 0x62, 0x22, 0xab, 0x01, 0x0a, 0x06, 0x50, 0x65, 0x6f, 0x70, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x61, 0x67, 0x65, 0x12, 0x19, 0x0a, 0x01, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x70, 0x62, 0x2e, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x01, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x68, 0x6f, 0x6e, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x70, 0x68, 0x6f, 0x6e, 0x65, 0x12, 0x16, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x12, 0x14, 0x0a, 0x04, 0x63, 0x69, 0x74, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x04, 0x63, 0x69, 0x74, 0x79, 0x12, 0x14, 0x0a, 0x04, 0x67, 0x6f, 0x6f, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x04, 0x67, 0x6f, 0x6f, 0x64, 0x42, 0x06, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2f, 0x0a, 0x07, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x67, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x61, 0x67, 0x65, 0x32, 0x2a, 0x0a, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x12, 0x21, 0x0a, 0x05, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x12, 0x0b, 0x2e, 0x70, 0x62, 0x2e, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x1a, 0x0b, 0x2e, 0x70, 0x62, 0x2e, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( file_grpc_proto_rawDescOnce sync.Once file_grpc_proto_rawDescData = file_grpc_proto_rawDesc ) func file_grpc_proto_rawDescGZIP() []byte { file_grpc_proto_rawDescOnce.Do(func() { file_grpc_proto_rawDescData = protoimpl.X.CompressGZIP(file_grpc_proto_rawDescData) }) return file_grpc_proto_rawDescData } var file_grpc_proto_msgTypes = make([]protoimpl.MessageInfo, 2) var file_grpc_proto_goTypes = []interface{}{ (*People)(nil), // 0: pb.People (*Student)(nil), // 1: pb.student } var file_grpc_proto_depIdxs = []int32{ 1, // 0: pb.People.s:type_name -> pb.student 1, // 1: pb.Hello.World:input_type -> pb.student 1, // 2: pb.Hello.World:output_type -> pb.student 2, // [2:3] is the sub-list for method output_type 1, // [1:2] is the sub-list for method input_type 1, // [1:1] is the sub-list for extension type_name 1, // [1:1] is the sub-list for extension extendee 0, // [0:1] is the sub-list for field type_name } func init() { file_grpc_proto_init() } func file_grpc_proto_init() { if File_grpc_proto != nil { return } if !protoimpl.UnsafeEnabled { file_grpc_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*People); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_grpc_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Student); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } } file_grpc_proto_msgTypes[0].OneofWrappers = []interface{}{ (*People_Score)(nil), (*People_City)(nil), (*People_Good)(nil), } type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_grpc_proto_rawDesc, NumEnums: 0, NumMessages: 2, NumExtensions: 0, NumServices: 1, }, GoTypes: file_grpc_proto_goTypes, DependencyIndexes: file_grpc_proto_depIdxs, MessageInfos: file_grpc_proto_msgTypes, }.Build() File_grpc_proto = out.File file_grpc_proto_rawDesc = nil file_grpc_proto_goTypes = nil file_grpc_proto_depIdxs = nil } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConnInterface // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion6 // HelloClient is the client API for Hello service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type HelloClient interface { World(ctx context.Context, in *Student, opts ...grpc.CallOption) (*Student, error) } type helloClient struct { cc grpc.ClientConnInterface } func NewHelloClient(cc grpc.ClientConnInterface) HelloClient { return &helloClient{cc} } func (c *helloClient) World(ctx context.Context, in *Student, opts ...grpc.CallOption) (*Student, error) { out := new(Student) err := c.cc.Invoke(ctx, "/pb.Hello/World", in, out, opts...) if err != nil { return nil, err } return out, nil } // HelloServer is the server API for Hello service. type HelloServer interface { World(context.Context, *Student) (*Student, error) } // UnimplementedHelloServer can be embedded to have forward compatible implementations. type UnimplementedHelloServer struct { } func (*UnimplementedHelloServer) World(context.Context, *Student) (*Student, error) { return nil, status.Errorf(codes.Unimplemented, "method World not implemented") } func RegisterHelloServer(s *grpc.Server, srv HelloServer) { s.RegisterService(&_Hello_serviceDesc, srv) } func _Hello_World_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(Student) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(HelloServer).World(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/pb.Hello/World", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(HelloServer).World(ctx, req.(*Student)) } return interceptor(ctx, in, info, handler) } var _Hello_serviceDesc = grpc.ServiceDesc{ ServiceName: "pb.Hello", HandlerType: (*HelloServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "World", Handler: _Hello_World_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "grpc.proto", }
4>.grpcServer.go
package main import ( "context" "google.golang.org/grpc" "net" "yinzhengjie/pb" ) //定义一个结构体,继承自HelloServer接口(该接口是我们通过protobuf代码生成的) type HelloService struct {} func (HelloService)World(ctx context.Context, req*pb.Student) (*pb.Student, error){ req.Name += " nihao" req.Age += 10 return req,nil } func main() { //先获取grpc对象 grpcServer := grpc.NewServer() //注册服务 pb.RegisterHelloServer(grpcServer,new(HelloService)) //开启监听 lis,err := net.Listen("tcp",":8888") if err != nil { return } defer lis.Close() //先获取grpc服务端对象 grpcServer.Serve(lis) }
5>.grpcClient.go
package main import ( "google.golang.org/grpc" "context" "fmt" "yinzhengjie/pb" ) func main() { //和grpc服务端建立连接 grpcCnn ,err := grpc.Dial("127.0.0.1:8888",grpc.WithInsecure()) if err != nil { fmt.Println(err) return } defer grpcCnn.Close() //得到一个客户端对象 client :=pb.NewHelloClient(grpcCnn) var s pb.Student s.Name = "Jason Yin" s.Age = 20 resp,err := client.World(context.TODO(),&s) fmt.Println(resp,err) }