Gonet2 游戏服务器框架解析之gRPC入门（4）

Gonet2中，大量使用了gRPC，而对这个我不熟，所以这里花点时间了解一下。当然，环境我已经配好了，这里只是讲代码上如何使用，环境的搭建，网上应该蛮多。不过用gRPC要用科学的方式上网，这个对我华厦民族的同胞们，应该都不陌生了。

远程调用，一开始我想的很复杂，但是真的了解过之后，无非是，server side提供一个开方的接口，公开调用时传送数据的格式，client side遵照这种规定，调用接口提供的方法。

问题来了，既然是远程，那肯定是跨进程，甚至是跨计算机。所以可以通过网络传输的方式来远程调用。比如tcp/ip, http。

gRPC是远程调用框架的一种，传输是通过http2协议，使用接口描述语言 proto3 来定义服务接口，以及数据结构。之前有proto2的，不过proto3是最新的，语法结构有小小不同。

既然是有 A 调用 B 这个过程，有网络协议，那对于接口来说，就肯定会存在客户端，与服务端。服务端处理请求，客户端去调用接口。所以，废话了那么多，来看看一个最简单的hello world接口定义吧。

// 没得更简单了，我试着用int32来做参数和返回值,
// 可是结果确是必须为message类型.
// message是grpc的封装类型，相当于go语言的struct或java的class.
syntax="proto3";

message Req{}
message Res{}

service HelloService {
rpc Hello(Req) returns (Res) {}
}

生成的代码，有点吓到我的感觉！我写了6行，生成这么多！先把完整代码帖上，然后我们一点点拆开看，要是怕吓到，先跳过。

// Code generated by protoc-gen-go.
// source: test.proto
// DO NOT EDIT!

/*
Package test is a generated protocol buffer package.

It is generated from these files:
test.proto

It has these top-level messages:
Req
Res
*/
package test

import proto "github.com/golang/protobuf/proto"

import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal

type Req struct {
}

func (m *Req) Reset()         { *m = Req{} }
func (m *Req) String() string { return proto.CompactTextString(m) }
func (*Req) ProtoMessage()    {}

type Res struct {
}

func (m *Res) Reset()         { *m = Res{} }
func (m *Res) String() string { return proto.CompactTextString(m) }
func (*Res) ProtoMessage()    {}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// Client API for HelloService service

type HelloServiceClient interface {
Hello(ctx context.Context, in *Req, opts ...grpc.CallOption) (*Res, error)
}

type helloServiceClient struct {
cc *grpc.ClientConn
}

func NewHelloServiceClient(cc *grpc.ClientConn) HelloServiceClient {
return &helloServiceClient{cc}
}

func (c *helloServiceClient) Hello(ctx context.Context, in *Req, opts ...grpc.CallOption) (*Res, error) {
out := new(Res)
err := grpc.Invoke(ctx, "/.HelloService/Hello", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}

// Server API for HelloService service

type HelloServiceServer interface {
Hello(context.Context, *Req) (*Res, error)
}

func RegisterHelloServiceServer(s *grpc.Server, srv HelloServiceServer) {
s.RegisterService(&_HelloService_serviceDesc, srv)
}

func _HelloService_Hello_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(Req)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(HelloServiceServer).Hello(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}

var _HelloService_serviceDesc = grpc.ServiceDesc{
ServiceName: ".HelloService",
HandlerType: (*HelloServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Hello",
Handler:    _HelloService_Hello_Handler,
},
},
Streams: []grpc.StreamDesc{},
}

仔细看一下，注释写的也挺清楚了。我个人的感觉是，打个比喻来说，同样的代码，仔细看的话，觉得难度是5，不仔细看，一下就蒙了，那难度可能是8。

上面分析过rpc调用，有服务端和客户端，还有通讯的数据格式，在这个生成分件里刚好有这三个部分。（其实，我是先看了这gRPC，再反过来分析理论的，反正说得通！）

服务端

先看一下Server部分，我加了一些注释，更详细的解释了每一部分的作用，完全是照顾新手，还有跟我一样，不喜欢仔细看代码的。

// HelloService服务接口定义
// 通过实现这个接口，来定义服务方法Hello的具体内容，这就是服务端(Server Side)了
type HelloServiceServer interface {
Hello(context.Context, *Req) (*Res, error)
}

// 实现了上面的服务端(Server Side)
// 需要调用这个方法来告诉gRPC框架，我们的服务端对象是谁。
func RegisterHelloServiceServer(s *grpc.Server, srv HelloServiceServer) {
s.RegisterService(&_HelloService_serviceDesc, srv)
}

// 这个是服务接口的代理，就是加了一层封装的意思，
// 网络传来的数据是byte[]，在这里解析成了一个Req对象，
// 然后才去调用我们server side的Hello方法。
func _HelloService_Hello_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(Req)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(HelloServiceServer).Hello(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}

// 这个变量是服务的描述对象。定义了服务的名字，类型，方法等。
// 在RegisterHelloServiceServer方法中，就是把这个变量传给了gRPC框架。
var _HelloService_serviceDesc = grpc.ServiceDesc{
ServiceName: ".HelloService",
HandlerType: (*HelloServiceServer)(nil),
Methods: []grpc.MethodDesc{//服务方法数组
{
MethodName: "Hello",
Handler:    _HelloService_Hello_Handler,
},
},
Streams: []grpc.StreamDesc{},
}

第一步 - 定义并实现服务：

type helloServiceServer struct {
}

func (s *helloServiceServer) Hello(ctx context.Context, req *test.Req) (*test.Res, error) {
fmt.Println("Hello")
return &test.Res{}, nil
}

第二步 - 开启网络服务：

// 监听端口
lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
if err != nil {
log.Fatalf("failed to listen: %v", err)
}
// 创建grpc实例
grpcServer := grpc.NewServer()
// 注册helloService服务
test.RegisterHelloServiceServer(grpcServer, &helloServiceServer{})
// 启动服务
grpcServer.Serve(lis)

其实逻辑上，它跟一个http service也差不了多少啊，监听一个端口，然后注册服务，然后就等着收到请求啦。如果再仔细看一看Methods里面是一个数组，这里对Hello和_HelloService_Hello_Handle做了一个映射，应该是一个路由功能，说白了，就是根据请求的名字，调用相应的方法进行处理。

客户端

// 客户端接口，里面定义了服务的方法
type HelloServiceClient interface {
Hello(ctx context.Context, in *Req, opts ...grpc.CallOption) (*Res, error)
}

// 这是客户端(Client side)的实现
type helloServiceClient struct {
cc *grpc.ClientConn
}

// 工厂方法，获得一个客户端实例。
// 我们的代码要通过这个实例来调用远程服务。
func NewHelloServiceClient(cc *grpc.ClientConn) HelloServiceClient {
return &helloServiceClient{cc}
}

// 客户端(Client side)的服务方法封装。
// 我们调用这个方法，在这里gRPC把我们的参数封装好，然后发送出去。
// 作为客户端，只管调用就完事了，是不是很方便！
func (c *helloServiceClient) Hello(ctx context.Context, in *Req, opts ...grpc.CallOption) (*Res, error) {
out := new(Res)
err := grpc.Invoke(ctx, "/.HelloService/Hello", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}

上面是生成的go语言代码，里面我自己加了注释。相信大家看过便懂，不懂的话是我表达的不好。接下来看看如何使用：

// 先连接到服务器
conn, err := grpc.Dial(*serverAddr)
if err != nil {
...
}
defer conn.Close()

// 通过工厂方法得到一个客户端对象
client := test.NewHelloServiceClient(conn)
// 调用
client.Hello(context.Background(), &test.Req{})

*注明一下，以上代码，除了proto是我自己生成了，下面的测试代码我都没跑过，说了是解析嘛。