gRPC入门

RPC远程过程调用

什么是RPC

Remote Procedure Call —— 远程过程调用

  • 理解RPC：像调用本地函数一样，去调用远程函数

  • 为什么微服务使用RPC：

    • 每个服务都被封装成进程，彼此独立
    • 进程和进程之可以使用不同语言来实现

RPC使用

  • 服务端使用
  1. 注册rpc服务对象，给对象绑定方法（定义类、绑定类方法）
1
rpc.RegisterName("服务名",回调对象)
  1. 创建一个监听器
1
listener,err := net.Listen()
  1. 建立连接
1
conn,err := listener.Accept()
  1. 将连接绑定rpc服务
1
rpc.ServerConn(conn)
  • 客户端使用
  1. 用rpc连接服务器
1
conn ,err := rpc.Dial()
  1. 调用远程函数
1
conn.Call("服务名.方法名",传入参数,传出参数)

RPC相关函数原型

  1. 注册rpc服务
1
2
3
4
5
6
// 参数1：服务名 string类型
// 参数2：对应的rpc对象，绑定方法要满足： 1）方法必须是导出的 ——包外可见（首字母大写）
//								   2）方法必须有两个参数，且都是导出类型、内建类型
//								   3）方法的第二个参数必须是指针（传出参数）
//								   4) 方法只有一个error类型的返回值
func (server *Server) RegisterName(name string, rcvr interface{}) error
  1. 绑定rpc服务
1
2
// 参数： conn  成功建立连接的socket
func (server *Server) ServeConn(conn io.ReadWriteCloser)
  1. 调用远程函数
1
2
3
4
// 参数1： serviceMethod："服务名.方法名"
// 参数2： args：传入参数
// 参数3： reply：传出参数
func (client *Client) Call(serviceMethod string, args interface{}, reply interface{}) error

Demo演示

  • 服务端
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
package main

import (
	"fmt"
	"net"
	"net/rpc"
)

//rpc server

type World struct {
}

func (w *World) Hello(name string, resp *string) (err error) {
	*resp = "Hello" + name
	return nil
}

func main() {
	//注册rpc服务
	err := rpc.RegisterName("test", new(World))
	if err != nil {
		fmt.Printf("注册rpc服务失败,err:%s\n", err)
		return
	}
	fmt.Println("注册rpc服务成功")
	//监听
	listener, err := net.Listen("tcp", "127.0.0.1:20000")
	if err != nil {
		fmt.Printf("启动监听失败，err:%s\n", err)
		return
	}
	fmt.Println("启动监听成功")
	defer listener.Close()
	//建立连接
	conn, err := listener.Accept()
	if err != nil {
		fmt.Printf("建立连接失败，err:%s\n", err)
	}
	fmt.Println("建立连接成功")
	//绑定服务
	rpc.ServeConn(conn)
}
  • 客户端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import (
	"fmt"
	"net/rpc"
)

func main() {
	conn, err := rpc.Dial("tcp", "127.0.0.1:20000")
	if err != nil {
		fmt.Printf("连接失败，err：%s\n", err)
		return
	}
	fmt.Println("建立连接成功")
	var resp string
	err = conn.Call("test.Hello", "world", &resp)
	if err != nil {
		fmt.Printf("远程调用失败,err:%s\n", err)
		return
	}
	fmt.Println("远程调用成功")
	fmt.Println(resp)
}

RPC封装

  • 服务端封装

上述代码中，如果Hello函数没有按照rpc规定的格式书写，那么代码会在运行时报错。如何能让错误在编译期就被发现呢？

这里使用接口的方式进行实现。

1
2
3
4
5
6
7
8
type MyInterface interface {
    Hello(string , *string) error
}

//调用该方法来进行rpc注册，传递的参数i应该是实现了Hello方法的对象
func RegisterService(i MyInterface){
    rpc.RegisterName("test",i)
}

这时原本注册rpc的程序需要先实现MyInterface接口，向RegisterService传递对象来进行rpc注册。如果方法没有实现该接口，程序会在编译期报错。

1
2
3
4
5
6
7
8
9
10
11
12
func (w *World) Hello(name string, resp *string) (err error) {
	*resp = "Hello" + name
	return nil
}


//main函数中注册：
func main(){
    ...
    RegisterService(new(World))
    ...
}
  • 客户端封装

客户端同样应该对Call函数进行封装，防止错误的调用。封装之后，客户端真正可以“像调用本地函数一样调用远程函数”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
type MyClient struct{
    c *rpc.Client
}

func InitClient(addr string) *MyClient{
    conn,err := rpc.Dial("tcp",addr)
    return &MyClient{
        c : conn,
    }
}

func (this *MyClient) Hello (a string, b *string) error{
    return this.c.Call("test.Hello",a,b)
}

func main(){
    myClient := InitClient("127.0.0.1:20000")
    var resp string
    err := myClient.Hello("World",&resp)
    if err != nil {
        ...
    }
    fmt.Println(resp)
}

各种RPC框架实际上都将rpc协议进行了封装，从而很方便地进行远程调用

Protobuf

protocol buffer安装

  • 下载官方release

Protocol Buffers Releases传送门

下载完成之后解压

unzip xxx xxx

protobuf的可执行文件protoc在bin文件夹下，进入文件夹执行protoc --version可以查看版本信息

  • 添加环境变量

这里有很多种方式，export添加环境变量，修改配置文件，或者软链接等方式都可以，配置完之后在任何文件夹下都可以执行protoc命令。

这里详细介绍一下软链接的方式。

  1. 使用echo $PATH命令查看系统环境变量，不出意外的话，都会包括/usr/bin/、/usr/sbin/等几个文件夹。
  2. 以/usr/bin/为例，假如解压之后得到的protoc文件位于/xxx/bin/文件夹下，使用ln命令在/usr/bin/文件夹下建立一个虚拟的protoc文件，将虚拟文件链接到真实的/xxx/bin/protoc。
1
ln -s xxx/bin/protoc /usr/bin/protoc

编写.proto文件

例子：

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
//默认是proto2
syntax="proto3";

//指定所在包名
package pb;


//定义枚举类型
enum Week {
    Monday = 0;
    Tuesday = 1;
}
//定义一个消息体
message Student{
    int32 age = 1;  //编号可以不从1开始，但不能使用19000~19999
    string name = 2;
    Person p =3;
    repeated int32 socre = 4;    //数组
    //枚举
    Week w = 5;
    //联合体
    oneof data{
        string class = 6;
        string teacher = 7;
    }
}

//消息体可以嵌套
message Person {
    int32 weight = 1;
}

一些语法小结：

  1. message成员编号，可以不从1开始，但是不能重复，不能使用19000~19999；
  2. 可以使用message嵌套
  3. 定义数组、切片使用repeated关键字
  4. 可以使用枚举enum，enum第一个成员必须为0；
  5. 可以使用联合体，使用oneof关键字，成员编号不能重复。

proto文件编译

  • go语言中编译命令

    protoc --go_out=./ *.proto —-> xxx.pb.go

    protoc命令会将.proto文件编译成相应的代码文件，文件后缀名为.pb.go

    对于go语言，这里的protoc命令会调用protoc-gen-go插件生成go代码。

    protoc-gen-go的安装非常方便，直接使用go get即可

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

    go get安装的protoc-gen-go默认在$GOPATH/bin目录下，这里也需要添加到环境变量中，如果你之前已经将$GOPATH添加进去了，这里就不需要进行操作。当然，同样也可以使用软链接的方式进行操作。

    但是经过实际测试，该插件会报错protoc-gen-go: unable to determine Go import path for "test.proto"，建议使用protoc-gen-gofast。

    1
    2
    3
    4
    5
    //go get
    go get github.com/gogo/protobuf/protoc-gen-gofast

    //protoc
    protoc --gofast_out=./ *.proto

添加RPC服务

  • 语法
1
2
3
service 服务名{
	rpc 函数名(参数：消息体)	returns (返回值：消息体);
}

例：

1
2
3
4
5
6
7
8
9
message People{
	string name = 1;
}
message Student{
	int32 age = 1;
}
service hello{
	rpc Hello(People) returns (Student);
}

  • 默认protobuf在编译期间不编译服务，要想使之编译，需要使用gRPC，使用的编译指令为：protoc --gofast_out=plugins=grpc:./ *.proto

  • 生成的xxx.pb.go与我们自己封装的rpc对比：

1
2
3
4
5
6
7
8
9
type bj38Client struct{}      -----    type MyClient struct{}
func NewBj38Client()   		  -----    func InitClient()
func (c *bj38Client) Say()    -----    func (this *Myclient) Hello()

							  客户端
--------------------------------------------------------------------------
							  服务端
type Bj38Server interface{}   -----     type MyInterface interface{}
func RegisterBj38Server()     -----     func RegisterService()

gRPC

如前文所述，在.proto文件中定义服务之后，可以使用protoc工具生成对应的go文件。

使用gRPC定义服务端和客户端的方法如下：

  • 服务端
  1. 定义类

  2. 按照接口绑定类方法

  3. 主函数中启动服务

    1. 初始化一个grpc对象
    2. 注册服务
    3. 设置监听
    4. 启动服务
  • 客户端
  1. 连接gRPC服务
    1. 给grpc.Dial()传参，第一个参数为”ip:port”，第二个参数选用grpc.WithInsecure()，表示以安全的方式操作
  2. 初始化grpc客户端
  3. 调用远程服务

下面是一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//proto_demo.proto
syntax = "proto3";

package pb;
message TestIn {
    int32 id = 1;
    string word = 2;
}

message TestOut{
    int32 id = 1;
    string word = 2;
}

service test {
    rpc RunTest (TestIn) returns (TestOut);
}
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
//proto_server.go
package main

import (
	"context"
	"fmt"
	"grpc_demo/pb"
	"net"

	"google.golang.org/grpc"
)

type ServerStruct struct {
}

func (s *ServerStruct) RunTest(c context.Context, t *pb.TestIn) (*pb.TestOut, error) {
	to := &pb.TestOut{
		Id:   t.Id,
		Word: t.Word,
	}
	return to, nil
}

func main() {
	// 初始化一个grpc对象
	grpcServer := grpc.NewServer()
	//注册grpc服务
	pb.RegisterTestServer(grpcServer, new(ServerStruct))
	//启动监听
	listener, err := net.Listen("tcp", "127.0.0.1:20000")
	if err != nil {
		fmt.Printf("listen failed,err:%s\n", err)
		return
	}
	defer listener.Close()
	// 启动服务
	grpcServer.Serve(listener)
}
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
//proto_client.go
package main

import (
	"context"
	"fmt"
	"grpc_demo/pb"

	"google.golang.org/grpc"
)

func main() {
	conn, err := grpc.Dial("127.0.0.1:20000", grpc.WithInsecure())
	if err != nil {
		fmt.Printf("dial failed ,err : %s\n", err)
		return
	}
	defer conn.Close()
	client := pb.NewTestClient(conn)
	t := pb.TestIn{
		Id:   10,
		Word: "HelloWorld",
	}
	res, err := client.RunTest(context.TODO(), &t)
	if err != nil {
		fmt.Printf("grpc failed,err:%s\n", err)
		return
	}
	fmt.Printf("%#v\n", res)
}
赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

武汉大学研究生在读<br><br>喜爱电影、摄影和健身运动<br>希望能和你相识！ <br><br>宠辱不惊，闲看庭前花开花落；<br>去留无意，漫随天外云卷云舒。