不做大哥好多年
xiaonaiqiang
2021-11-08
目录

01.RPC

# 01.rpc介绍

/opt/GoLand-2021.1.3/bin/goland.sh
1

# 1.1 什么是rpc

RPC，即 Remote Procedure Call（远程过程调用），说得通俗一点就是：调用远程计算机上的服务，就像调用本地服务一样。

  • 一般公司的项目是采用基于Restful的微服务架构，随着微服务之间的沟通越来越频繁
  • 就希望可以做成用rpc来做内部的通讯对外依然用Restful。
  • 于是就想到了golang标准库的rpc包和google的grpc

# 1.2 rpc说明

  • golang的rpc支持三个级别的RPC：TCP、HTTP、JSONRPC。

  • 但Go的RPC包是独一无二的RPC，它和传统的RPC系统不同，它只支持Go开发的服务器与客户端之间的交互，因为在内部，它们采用了Gob来编码。

  • Go RPC的函数只有符合下面的条件才能被远程访问，不然会被忽略，详细的要求如下

    • 函数必须是导出的(首字母大写)
    • 必须有两个导出类型的参数，
    • 第一个参数是接收的参数，第二个参数是返回给客- 户端的参数，第二个参数必须是指针类型的
    • 函数还要有一个返回值error

  • 举个例子，正确的RPC函数格式如下：

func (t *T) MethodName(argType T1, replyType *T2) error
1

# 02.net/rpc库

# 2.1 server端

  • rpc_server.go

    • 下面的例子演示一下如何使用golang官方的net/rpc库实现RPC方法
    • 使用http作为RPC的载体，通过net/http包监听客户端连接请求

  • 规则

  • Multiply方法必须满足GO语言的RPC规则

    • 方法只能有两个可序列化的参数

      • 其中第二个参数是指针类型
      • 并且返回一个error类型
      • 同时必须是公开的方法。

    • 然后就可以将HelloService类型的对象注册为一个RPC服务

package main

import (
	"errors"
	"fmt"
	"log"
	"net"
	"net/http"
	"net/rpc"
	"os"
)

// 算数运算结构体
type Arith struct {

}

// 算数运算请求结构体
type ArithRequest struct {
	A int
	B int
}

// 算数运算响应结构体
type ArithResponse struct {
	Pro int // 乘积
	Quo int // 商
	Rem int // 余数
}

// 乘法运算方法
func (this *Arith) Multiply(req ArithRequest, res *ArithResponse) error {
	res.Pro = req.A * req.B
	return nil
}

// 除法运算方法
func (this *Arith) Divide(req ArithRequest, res *ArithResponse) error {
	if req.B == 0 {
		return errors.New("divide by zero")
	}
	res.Quo = req.A / req.B
	res.Rem = req.A % req.B
	return nil
}

func main() {
  // 其中`rpc.Register`函数调用会将对象类型中所有满足RPC规则的对象方法注册为RPC函数，所有注册的方法会放在“Arith”服务空间之下
	rpc.Register(new(Arith))   // 注册rpc服务
	rpc.HandleHTTP()         // 采用http协议作为rpc载体

	lis, err := net.Listen("tcp", "127.0.0.1:8095")
	if err != nil {
		log.Fatalln("fatal error: ", err)
	}

	fmt.Fprintf(os.Stdout, "%s", "start connection")
	http.Serve(lis, nil)
}
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

# 2.2 client端

  • rpc_client.go
    • 上述服务端程序运行后，将会监听本地的8095端口，我们可以实现一个客户端程序，连接服务端并实现RPC方法调用。
package main

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

// 算数运算请求结构体
type ArithRequest struct {
	A int
	B int
}

// 算数运算响应结构体
type ArithResponse struct {
	Pro int // 乘积
	Quo int // 商
	Rem int // 余数
}

func main() {
  // rpc.DialHTTP拨号RPC服务
	conn, err := rpc.DialHTTP("tcp", "127.0.0.1:8095")
	if err != nil {
		log.Fatalln("dailing error: ", err)
	}

	req := ArithRequest{9, 2}
	var res ArithResponse
 
  // 然后通过client.Call调用具体的RPC方法
  // 第一个参数是用点号链接的RPC服务名字和方法名字，第二和第三个参数分别我们定义RPC方法的两个参数
	err = conn.Call("Arith.Multiply", req, &res) // 乘法运算
	if err != nil {
		log.Fatalln("arith error: ", err)
	}
	fmt.Printf("%d * %d = %d\n", req.A, req.B, res.Pro)

	err = conn.Call("Arith.Divide", req, &res)
	if err != nil {
		log.Fatalln("arith error: ", err)
	}
	fmt.Printf("%d / %d, quo is %d, rem is %d\n", req.A, req.B, res.Quo, res.Rem)
}
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
44
45

# 2.3 运行结果

root@dev:test_rpc# go run rpc_client.go 
9 * 2 = 18
9 / 2, quo is 4, rem is 1
1
2
3

# 03.net/rpc/jsonrpc库

  • 上面的例子我们演示了使用net/rpc实现RPC的过程，但是没办法在其他语言中调用上面例子实现的RPC方法。
  • 所以接下来的例子我们演示一下使用net/rpc/jsonrpc库实现RPC方法，此方式实现的RPC方法支持跨语言调用。
  • 服务端程序启动后，将会监听本地的8096端口，并处理客户端的tcp连接请求。
  • 我们可以用golang实现一个客户端程序连接上述服务端并进行RPC调用。

# 3.1 server端

package main

import (
	"errors"
	"fmt"
	"log"
	"net"
	"net/rpc"
	"net/rpc/jsonrpc"
	"os"
)

// 算数运算结构体
type Arith struct {
}

// 算数运算请求结构体
type ArithRequest struct {
	A int
	B int
}

// 算数运算响应结构体
type ArithResponse struct {
	Pro int // 乘积
	Quo int // 商
	Rem int // 余数
}

// 乘法运算方法
func (this *Arith) Multiply(req ArithRequest, res *ArithResponse) error {
	res.Pro = req.A * req.B
	return nil
}

// 除法运算方法
func (this *Arith) Divide(req ArithRequest, res *ArithResponse) error {
	if req.B == 0 {
		return errors.New("divide by zero")
	}
	res.Quo = req.A / req.B
	res.Rem = req.A % req.B
	return nil
}

func main() {
	rpc.Register(new(Arith)) // 注册rpc服务

	lis, err := net.Listen("tcp", "127.0.0.1:8096")
	if err != nil {
		log.Fatalln("fatal error: ", err)
	}

	fmt.Fprintf(os.Stdout, "%s", "start connection")

	for {
		conn, err := lis.Accept() // 接收客户端连接请求
		if err != nil {
			continue
		}

		go func(conn net.Conn) { // 并发处理客户端请求
			fmt.Fprintf(os.Stdout, "%s", "new client in coming\n")
			jsonrpc.ServeConn(conn)
		}(conn)
	}
}
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

# 3.2 client端

package main

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

// 算数运算请求结构体
type ArithRequest struct {
	A int
	B int
}

// 算数运算响应结构体
type ArithResponse struct {
	Pro int // 乘积
	Quo int // 商
	Rem int // 余数
}

func main() {
	conn, err := jsonrpc.Dial("tcp", "127.0.0.1:8096")
	if err != nil {
		log.Fatalln("dailing error: ", err)
	}

	req := ArithRequest{9, 2}
	var res ArithResponse

	err = conn.Call("Arith.Multiply", req, &res) // 乘法运算
	if err != nil {
		log.Fatalln("arith error: ", err)
	}
	fmt.Printf("%d * %d = %d\n", req.A, req.B, res.Pro)

	err = conn.Call("Arith.Divide", req, &res)
	if err != nil {
		log.Fatalln("arith error: ", err)
	}
	fmt.Printf("%d / %d, quo is %d, rem is %d\n", req.A, req.B, res.Quo, res.Rem)
}
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
编辑 (opens new window)
上次更新: 2022/09/21, 11:19:29
101.nginx部署
02.protobuf

← 02.protobuf→

最近更新
01
15.redis淘汰策略
09-20
02
21.regexp2
09-16
03
01.istio
09-16
更多文章>
Theme by Vdoing | Copyright © 2019-2022 肖乃强 技术博客 京ICP备2021005373号