gRPC入门指南 — 简单RPC（一）
接下来一段时间我们来一段 gRPC 之旅，欢迎入坑！
需要的背景知识
学习 gRPC 需要提前掌握的背景知识：
Protocol Buffer 协议； 安装 protoc 和 protoc-gen-go；
这两部分知识不会重点讲解，需要自行学习，我们把重点放在 gRPC。
介绍
gRPC 有四种数据交互模式：
简单模式（Simple RPC），客户端发起请求并等待服务端响应； 服务端流式 RPC（Server-side streaming RPC），客户端发起一个请求到服务端，服务端返回一段连续的数据流响应； 客户端流式 RPC（Client-side streaming RPC），与服务端流式相反，客户端流式是客户端不断地向服务端发送数据流，最后由服务端返回一个响应； 双向流式 RPC（Bidirectional streaming RPC），客户端和服务端可同时向对方发送数据流，同时也可以接收数据；
先从简单的入手，我们先来看下简单模式 RPC，这种交互模式就是客户端请求一次，服务端回应一次，双方一来一回就算单次通信结束了。
新建并编译 proto 文件
新建文件 simple.proto
syntax = "proto3";
package proto;
// 定义发送请求信息
message SimpleRequest{
// 参数类型 参数名称 标识号
string data = 1;
}
// 定义响应信息
message SimpleResponse{
int32 code = 1;
string value = 2;
}
// 定义我们的服务(可以定义多个服务，每个服务可以定义多个接口)
service Simple{
rpc GetSimpleInfo(SimpleRequest) returns (SimpleResponse){};
}
进入 simple.proto 所在的目录，使用如下命令编译文件
protoc --go_out=plugins=grpc:. simple.proto
执行完成之后会生成 simple.pb.go 文件，文件内容会在文章后半段给大家梳理，我们先把 demo 跑起来。
创建 server 端
需要在 server 端实现 GetSimpleInfo 方法。
package main
import (
"context"
pb "go-grpc-example/1-simple_rpc/proto"
"google.golang.org/grpc"
"log"
"net"
)
const (
Address string = ":8000"
Network string = "tcp"
)
// 定义我们的服务
type SimpleService struct{}
// 实现 GetSimpleInfo 方法
func (s *SimpleService) GetSimpleInfo(ctx context.Context, req *pb.SimpleRequest) (*pb.SimpleResponse, error) {
data := req.Data
log.Println("get from client: ", data)
resp := &pb.SimpleResponse{
Code: 8888,
Value: "grpc",
}
return resp, nil
}
func main() {
// 1.监听端口
listener, err := net.Listen(Network, Address)
if err != nil {
log.Fatalf("net.listen err: %v", err)
}
log.Println(Address, " net listening...")
// 2.实例化gRPC服务端
grpcServer := grpc.NewServer()
// 3.注册我们实现的服务 SimpleService
pb.RegisterSimpleServer(grpcServer, &SimpleService{})
// 4.启动gRPC服务端
err = grpcServer.Serve(listener)
if err != nil {
log.Fatalf("grpc server err: %v",err)
}
}
服务端实现的主要流程，如上面代码注释的：1 -> 2 -> 3 -> 4。
运行服务端：
go run server.go
输出：
:8000 net listening...
创建 client 端
客户端可以直接调用服务端提供的服务（接口）
package main
import (
"context"
pb "go-grpc-example/1-simple_rpc/proto"
"google.golang.org/grpc"
"log"
)
const (
Address string = ":8000"
)
func main() {
// 1.创建于gRPC服务端的连接
conn, err := grpc.Dial(Address, grpc.WithInsecure())
if err != nil {
log.Fatalf("dial conn err: %v", err)
}
defer conn.Close()
// 2.创建grpc客户端
client := pb.NewSimpleClient(conn)
// 3.调用服务端提供的服务
req := pb.SimpleRequest{
Data: "Hello,Server",
}
resp, err := client.GetSimpleInfo(context.Background(), &req)
if err != nil {
log.Fatalf("resp err: %v", err)
}
log.Printf("get from server,code: %v,value: %v", resp.Code, resp.Value)
}
客户端实现的流程如上面注释：1 -> 2 -> 3。
运行客户端：
go run client.go
输出：
get from server,code: 8888,value: grpc
成功调用了服务端提供的方法并返回数据。
simple.pb.go 文件详解
撸完最基础的 demo，现在来看下编译完的 simple.proto 文件，熟悉这里面的内容有助于我们理解 gRPC 的调用过程。
1.按照 simple.proto 定义的消息类型会生成不同的 struct。
// 定义发送请求信息
type SimpleRequest struct {
// 参数类型 参数名称 标识号
Data string `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}
// 定义响应信息
type SimpleResponse struct {
Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}
2.为结构体生成了不同的方法。
func (m *SimpleRequest) Reset() { *m = SimpleRequest{} }
func (m *SimpleRequest) String() string { return proto.CompactTextString(m) }
func (m *SimpleResponse) Reset() { *m = SimpleResponse{} }
func (m *SimpleResponse) String() string { return proto.CompactTextString(m) }
func (m *SimpleResponse) GetCode() int32 {
if m != nil {
return m.Code
}
return 0
}
func (m *SimpleResponse) GetValue() string {
if m != nil {
return m.Value
}
return ""
}
3.生成了服务端和客户端的接口定义，如下：
// 客户端
type SimpleClient interface {
GetSimpleInfo(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error)
}
// 服务端
type SimpleServer interface {
GetSimpleInfo(context.Context, *SimpleRequest) (*SimpleResponse, error)
}
通信双方都必须实现接口里面定义的方法，仔细的同学可以发现，客户端的方法 GetSimpleInfo() 实际上已经自动生成了，客户端只需要调用即可。
func (c *simpleClient) GetSimpleInfo(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) {
out := new(SimpleResponse)
err := c.cc.Invoke(ctx, "/proto.Simple/GetSimpleInfo", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
但是服务端的方法需要自己实现，毕竟是服务提供方，服务的具体逻辑是由我们自己来定的。
4.最后还有一个注册服务的函数，我们需要做的就是，自己去定义一个 struct 对象，实现上面提到的 SimpleServer 接口，然后把那个 struct 注册到 gRPC 服务上。
func RegisterSimpleServer(s *grpc.Server, srv SimpleServer) {
s.RegisterService(&_Simple_serviceDesc, srv)
}
总结
这篇文章主要介绍了 gRPC 第一种交互模式 - Simple RPC，演示了最基础的 demo，大家重点需要掌握以下两点：
服务端和客户端的实现流程； simple.pb.go 的内容；
下篇我们接着来介绍第二种模式 - 服务端流式 RPC。
推荐阅读
评论