Go的RPC标准库
简单使用
Go语言标准库(net/rpc)的RPC规则：方法只能有两个可序列化的参数，其中第二个参数是指针类型，并且返回一个error类型，同时必须是公开的方法。
type HelloService struct {}
func (p *HelloService) Hello(request string, reply *string) error {
*reply = "hello:" + request
return nil
}
func main() {
rpc.RegisterName("HelloService", new(HelloService))
listener, err := net.Listen("tcp", ":1234")
if err != nil {
log.Fatal("ListenTCP error:", err)
}
conn, err := listener.Accept()
if err != nil {
log.Fatal("Accept error:", err)
}
rpc.ServeConn(conn)
}
一个服务可以有多个方法，rpc.RegisterName函数调用会将对象类型中所有满足RPC规则的对象方法注册为RPC函数，所有注册的方法会放在“HelloService”服务空间之下。
客户端代码：
func main() {
client, err := rpc.Dial("tcp", "localhost:1234")
if err != nil {
log.Fatal("dialing:", err)
}
var reply string
err = client.Call("HelloService.Hello", "Tom", &reply)
if err != nil {
log.Fatal(err)
}
fmt.Println(reply)
}
跨语言使用
{"method":"HelloService.Hello","params":["hello"],"id":1}
{"id":1,"result":"hello:Tom","error":null}
无论采用何种语言，只要遵循同样的json结构，以同样的流程就可以和Go语言编写的RPC服务进行通信。这样我们就实现了跨语言的RPC。
HTTP上的RPC
func main() {
rpc.RegisterName("HelloService", new(HelloService))
http.HandleFunc("/jsonrpc", func(w http.ResponseWriter, r *http.Request) {
var conn io.ReadWriteCloser = struct {
io.Writer
io.ReadCloser
}{
ReadCloser: r.Body,
Writer: w,
}
rpc.ServeRequest(jsonrpc.NewServerCodec(conn))
})
http.ListenAndServe(":1234", nil)
}
Protobuf
Protobuf是Protocol Buffers的简称，它是Google公司开发的一种数据描述语言，并于2008年对外开源。Protobuf刚开源时的定位类似于XML、JSON等数据描述语言，通过附带工具生成代码并实现将结构化数据序列化的功能。但是我们更关注的是Protobuf作为接口规范的描述语言，可以作为设计安全的跨语言PRC接口的基础工具。
#hello.proto
syntax = "proto3";
option go_package = ".;main";
package main;
message String {
string value = 1;
}
Protobuf核心的工具集是C++语言开发的，安装官方的protoc工具，可以从https://github.com/google/protobuf/releases下载。在官方的protoc编译器中并不支持Go语言。要想基于上面的hello.proto文件生成相应的Go代码，需要安装相应的插件。然后是安装针对Go语言的代码生成插件，可以通过go get google.golang.org/protobuf/cmd/protoc-gen-go命令安装（这个是老版本的：github.com/golang/protobuf/protoc-gen-go）。然后通过以下命令生成相应的Go代码：protoc --go_out=. hello.proto其中go_out参数告知protoc编译器去加载对应的protoc-gen-go工具，然后通过该工具生成代码，生成代码放到当前目录，最后是一系列要处理的protobuf文件的列表，此时目录下会有一个hello.pb.go的文件。
不过用Protobuf定义语言无关的RPC服务接口才是它真正的价值所在。修改一下上面的hello.proto文件：
#hello.proto
syntax = "proto3";
option go_package = ".;main";
package main;
message String {
string value = 1;
}
service HelloService{
rpc Hello (String) returns (String);
}
然后安装go get google.golang.org/grpc/cmd/protoc-gen-go-grpc，然后执行命令生成gRPC代码：protoc --go-grpc_out=. .\hello.proto。此时目录下会出现一个hello_grpc.pb.go的文件。
Protobuf的protoc编译器是通过插件机制实现对不同语言的支持。比如protoc命令出现--xxx_out格式的参数，那么protoc将首先查询是否有内置的xxx插件，如果没有内置的xxx插件那么将继续查询当前系统中是否存在protoc-gen-xxx命名的可执行程序，最终通过查询到的插件生成代码。在上面的例子中，--go_out=.会针对hello.proto文件里的message生成相关代码，而--go-grpc_out=.会针对hello.proto文件里的service生成相关代码。
gRPC
安装gRPC的核心库：go get google.golang.org/grpc
上文讲的，执行protoc --go-grpc_out=. .\hello.proto就可以生成对应的grpc代码。gRPC插件会为服务端和客户端生成不同的接口：
//客户端
type helloServiceClient struct {
cc grpc.ClientConnInterface
}
func NewHelloServiceClient(cc grpc.ClientConnInterface) HelloServiceClient {
return &helloServiceClient{cc}
}
type HelloServiceClient interface {
Hello(ctx context.Context, in *String, opts ...grpc.CallOption) (*String, error)
}
func (c *helloServiceClient) Hello(ctx context.Context, in *String, opts ...grpc.CallOption) (*String, error) {
out := new(String)
err := c.cc.Invoke(ctx, "/main.HelloService/Hello", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
//服务端
type HelloServiceServer interface {
Hello(context.Context, *String) (*String, error)
mustEmbedUnimplementedHelloServiceServer()
}
func RegisterHelloServiceServer(s grpc.ServiceRegistrar, srv HelloServiceServer) {
s.RegisterService(&_HelloService_serviceDesc, srv)
}
type UnimplementedHelloServiceServer struct {
}
func (UnimplementedHelloServiceServer) mustEmbedUnimplementedHelloServiceServer() {}
基于grpc重新实现前面的例子：
//服务端
package main
import (
"context"
"log"
"net"
"google.golang.org/grpc"
)
type HelloServiceImpl struct {
UnimplementedHelloServiceServer
}
func (p *HelloServiceImpl) Hello(ctx context.Context, args *String) (*String, error) {
reply := &String{Value: "hello " + args.GetValue()}
return reply, nil
}
func main() {
grpcServer := grpc.NewServer()
RegisterHelloServiceServer(grpcServer, new(HelloServiceImpl))
lis, err := net.Listen("tcp", ":8899")
if err != nil {
log.Fatal(err)
}
grpcServer.Serve(lis)
}
//----------------------------------------------------------------------
//客户端
package main
import (
"context"
"fmt"
"log"
"google.golang.org/grpc"
)
func main() {
conn, err := grpc.Dial("localhost:8899", grpc.WithInsecure())
if err != nil {
log.Fatal(err)
}
defer conn.Close()
clien := NewHelloServiceClient(conn)
reply, err := client.Hello(context.Background(), &String{
Value: "Wang",
})
if err != nil {
log.Fatal(err)
}
fmt.Println(reply.GetValue())
}
gRPC流
RPC是远程函数调用，因此每次调用的函数参数和返回值不能太大，否则将严重影响每次调用的响应时间。因此传统的RPC方法调用对于上传和下载较大数据量场景并不适合。为此，gRPC框架针对服务器端和客户端分别提供了流特性。
gRPC和TLS
先分别生成服务端和客户端的私钥和证书：
#服务端
$ openssl genrsa -out server.key 2048
$ openssl req -new -x509 -days 3650 \
-subj "/C=GB/L=China/O=grpc-server/CN=server.grpc.io" \
-key server.key -out server.crt
----------------------------------------------------------------------------------
#客户端
$ openssl genrsa -out client.key 2048
$ openssl req -new -x509 -days 3650 \
-subj "/C=GB/L=China/O=grpc-client/CN=client.grpc.io" \
-key client.key -out client.crt
以上命令将生成server.key、server.crt、client.key和client.crt四个文件。其中以.key为后缀名的是私钥文件，需要妥善保管。以.crt为后缀名是证书文件，也可以简单理解为公钥文件，并不需要秘密保存。在subj参数中的/CN=server.grpc.io表示服务器的名字为server.grpc.io，在验证服务器的证书时需要用到该信息。
