[每周一更]-(第22期)：什么是gRPC?

gRPC 是Google发起的一个开源远程过程调用 系统。

该系统基于HTTP/2 协议传输，使用Protocol Buffers 作为接口描述语言。

其他功能： 认证 双向流 流控制 超时 最常见的应用场景是： 微服务框架下，多种语言服务之间的高效交互。

将手机服务、浏览器连接至后台 产生高效的客户端库

为什么要用gRPC

使用gRPC， 我们可以一次性的在一个.proto文件中定义服务并使用任何支持它的语言去实现客户端和服务端，反过来，它们可以应用在各种场景中，从Google的服务器到你自己的平板电脑—— gRPC帮你解决了不同语言及环境间通信的复杂性。使用protocol buffers还能获得其他好处，包括高效的序列号，简单的IDL以及容易进行接口更新。总之一句话，使用gRPC能让我们更容易编写跨语言的分布式代码。

安装gRPC

go get -u google.golang.org/grpc

1
2

安装Protocol Buffers v3

安装用于生成gRPC服务代码的协议编译器，最简单的方法是从下面的链接：

https://github.com/google/protobuf/releases下载适合你平台的预编译好的二进制文件（protoc--.zip）。
1

下载完之后，执行下面的步骤：

• 解压下载好的文件
• 把protoc二进制文件的路径加到环境变量中

接下来执行下面的命令安装protoc的Go插件：

go get -u github.com/golang/protobuf/protoc-gen-go
1

编译插件protoc-gen-go将会安装到$GOBIN，默认是$GOPATH/bin，它必须在你的$PATH中以便协议编译器protoc能够找到它。

gRPC入门示例

编写proto代码

gRPC是基于Protocol Buffers。

Protocol Buffers是一种与语言无关，平台无关的可扩展机制，用于序列化结构化数据。使用Protocol Buffers可以一次定义结构化的数据，然后可以使用特殊生成的源代码轻松地在各种数据流中使用各种语言编写和读取结构化数据。

关于Protocol Buffers的教程可以自行在网上搜索，本文默认读者熟悉Protocol Buffers。

syntax = "proto3"; // 版本声明，使用Protocol Buffers v3版本

package pb; // 包名


// 定义一个打招呼服务
service Greeter {
    // SayHello 方法
    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
14
15
16
17
18
19
20

执行下面的命令，生成go语言源代码：

protoc -I helloworld/ helloworld/pb/helloworld.proto --go_out=plugins=grpc:helloworld
1

在gRPC_demo/helloworld/pb目录下会生成helloworld.pb.go文件。

Windows下安装protobuf

windows下需要下载对应版本：https://github.com/protocolbuffers/protobuf/releases，将bin下载protoc移动到GOPATH的bin中即可

参考：https://mp.weixin.qq.com/s?__biz=MzIzNDcwNjQxMg==&mid=2247484792&idx=1&sn=1d1d83b54d6617200de7f14eb97e9518&chksm=e8f301fbdf8488ed66556942694961c1e15231826f8058d332901d81c6354994fba99f41ae39&token=1951920362&lang=zh_CN#rd
1
2
3

第零步：

增加 pb/HelleWorld.proto

syntax = "proto3"; // 版本声明，使用Protocol Buffers v3版本
option go_package = "/";

package models.pb; // 包名


service Calculate {
    rpc Sum (stream SumRequest) returns (SumResponse) {
    }
}

message SumRequest {
    int64 num = 1;
}

message SumResponse {
    int64 result = 1;
}

// 定义一个打招呼服务
service Greeter {
    // SayHello 方法
    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
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

第一步：

将HelleWorld.proto进行编译生成pb文件

protoc --go_out=plugins=grpc:. *.proto
1

第二步：

安装gRPC：

go get -u google.golang.org/grpc
1

第三步：

分别创建client/server代码

client.go

package main

import (
	"fmt"

	"golang.org/x/net/context"
	"google.golang.org/grpc"

	pb "go-coding/tools/RPC/gRPC/test/pb"
)

func TestGrpcClient() {
	// 连接服务器
	conn, err := grpc.Dial(":8972", grpc.WithInsecure())
	if err != nil {
		fmt.Printf("faild to connect: %v", err)
	}
	defer conn.Close()

	c := pb.NewGreeterClient(conn)
	// 调用服务端的SayHello
	r, err := c.SayHello(context.Background(), &pb.HelloRequest{Name: "CN"})
	if err != nil {
		fmt.Printf("could not greet: %v", err)
	}
	fmt.Printf("Greeting: %s !\n", r.Message)
}

func main() {
	TestGrpcClient()
}

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

server.go

package main
import (
	"fmt"
	"net"

	"google.golang.org/grpc"
	"google.golang.org/grpc/reflection"

	pb "go-coding/tools/RPC/gRPC/test/pb"

	"golang.org/x/net/context"
)

type server struct{}

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
	return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}

func TestGrpcServer() {
	// 监听本地的8972端口
	lis, err := net.Listen("tcp", ":8972")
	if err != nil {
		fmt.Printf("failed to listen: %v", err)
		return
	}
	s := grpc.NewServer()                  // 创建gRPC服务器
	pb.RegisterGreeterServer(s, &server{}) // 在gRPC服务端注册服务

	reflection.Register(s) // 在给定的gRPC服务器上注册服务器反射服务
	// Serve方法在lis上接受传入连接，为每个连接创建一个ServerTransport和server的goroutine。
	// 该goroutine读取gRPC请求，然后调用已注册的处理程序来响应它们。
	err = s.Serve(lis)
	if err != nil {
		fmt.Printf("failed to serve: %v", err)
		return
	}
}

func main() {
	TestGrpcServer()
}

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
37
38
39
40
41
42
43

第四步：

启动server/ 然后启动client的时候就能请求到server的方法；
启动client返回：Greeting: Hello CN !

参考地址：https://www.liwenzhou.com/posts/Go/gRPC/