golang通过内置net/rpc实现实现一个简单rpc服务并做优化

快来打我* 2022-09-16 14:29 197阅读 0赞

### 文章目录 ###

*  规则
 *  原始版的 rpc 服务
 *   *  服务端注册 rpc 服务
     *  客户端请求 rpc 服务
 *  进一步：更优美的 rpc
 *   *  服务端 rpc 服务优化
     *  客户端调用优化
 *  进一步：跨语言的 rpc
 *   *  rpc 服务端
     *  客户端
 *  进一步：http 中访问 rpc
 *   *  rpc 客户端
 *  总结

# 规则 #

使用 golang 中的 net/rpc，需要将被注册为 rpc 服务的对象满足以下规则：

*  方法只能有两个可序列化的参数
 *  方法中第二个参数是指针类型
 *  方法返回一个 error 类型
 *  方法是公开的方法

type HelloService struct {
        }
    
    func (p *HelloService) Hello(request string, reply *string) error {
        
        *reply = "hello:" + request
        return nil
    }

# 原始版的 rpc 服务 #

## 服务端注册 rpc 服务 ##

先来看如何利用 golang 提供的 net/rpc 包来创建一个 rpc 服务

type HelloService struct{
        }
    
    func (p *HelloService) Hello(request string, reply *string) error {
        
    	*reply = "hello " + request
    	return nil
    }
    
    func main() {
        
    	// 用名字来注册
    	rpc.RegisterName("HelloService", new(HelloService))
    
    	// 持续监听端口中...
    	listener, err := net.Listen("tcp", ":1234")
    	if err != nil {
        
    		log.Fatal("ListenTCP error:", err)
    	}
    
    	// 一旦监听接收到数据
    	conn, err := listener.Accept()
    	if err != nil {
        
    		log.Fatal("Accept error:", err)
    	}
    
    	// rpc 建立连接
    	rpc.ServeConn(conn)
    }

解释：

`rpc.Register`这样的函数会将被注册对象类型中的满足 rpc 规则的对象方法注册为 rpc 函数，所有被注册的方法会放在 HelloService 服务空间下

然后我们通过`net.Listen`函数不断监听端口为 xxxx 的 tcp 链接是否有接收数据

一旦`listener.Accept`接收到了数据

`rpc.ServeConn`就建立起了链接可以提供 rpc 服务了

## 客户端请求 rpc 服务 ##

func main() {
        
    	// 客户端通过 tcp 连接指定端口，直到连接成功，程序放行
    	client, err := rpc.Dial("tcp", "localhost:1234")
    	if err != nil {
        
    		log.Fatal("dialing:", err)
    	}
    
    	// 客户端调用服务的具体方法，其中 Call 中 2，3 参数对应原服务方法中的两个参数「请求数据，响应数据」
    	var reply string
    	err = client.Call("HelloService.Hello", "world!", &reply)
    	if err != nil {
        
    		log.Fatal(err)
    	}
    
    	// 最后打印出客户端调用 rpc 的响应结果
    	fmt.Println(reply)
    }

解释：

先通过`rpc.Dial`来连接 tcp

然后通过连接成功后获取的 client 调用 Call 函数来实现 rpc 的远程调用，其中参数一是调用什么服务中的什么方法，参数二表示服务方法中要传什么入参过去，参数三表示服务方法的第二个参数也就是方法响应结果是什么

最后输出远程 rpc 调用的结果

# 进一步：更优美的 rpc #

## 服务端 rpc 服务优化 ##

/* ----------- 服务名称 ----------- */
    
    // HelloServiceName 服务名称
    const HelloServiceName = "abcnull.test.HelloService"
    
    /* ----------- 服务结构体 ----------- */
    
    // HelloServiceInterface 接口
    type HelloServiceInterface interface {
        
    	Hello(request string, reply *string) error
    }
    
    // HelloService 结构体
    type HelloService struct{
        }
    
    // Hello 结构体方法
    func (p *HelloService) Hello(request string, reply *string) error {
        
    	*reply = "hello " + request
    	return nil
    }
    
    /* ----------- 服务注册的函数 ----------- */
    
    // RegisterHelloService 实际服务注册的函数
    func RegisterHelloService(svc HelloServiceInterface) error {
        
    	return rpc.RegisterName(HelloServiceName, svc)
    }
    
    /* ----------- 服务端核心流程 ----------- */
    func main() {
        
    	// 用名字来注册
    	RegisterHelloService(new(HelloService))
    	// 注册其他服务...
    
    	// 持续监听端口中...
    	listener, err := net.Listen("tcp", ":1234")
    	if err != nil {
        
    		log.Fatal("ListenTCP error:", err)
    	}
    
    	for {
        
    		// 一旦监听接收到数据
    		conn, err := listener.Accept()
    		if err != nil {
        
    			log.Fatal("Accept error:", err)
    		}
    
    		// rpc 建立连接
    		go rpc.ServeConn(conn)
    	}
    }

解释：

在服务端我们把服务名称进行了优化，使用 xxx.yyy.zzz 的形式来描述服务名称，是一个 string 类型

然后把原本服务的结构体给接口化声明

然后把服务注册给封装成函数，这样就无需往`rpc.RegisterName`函数中传递服务名称，就可以直接调用封装的函数就表示是想注册哪个服务了

最后 for 循环监听调用者情况

## 客户端调用优化 ##

/* ----------- 服务名称 ----------- */
    
    // HelloServiceName 服务名称
    const HelloServiceName = "abcnull.test.HelloService"
    
    /* ------------- 将客户端封装成结构 ------------ */
    
    // HelloServiceClient 声明客户端
    type HelloServiceClient struct {
        
    	// 链接
    	*rpc.Client
    }
    
    // Hello 客户端调用指定 rpc 服务方法的方法
    func (p *HelloServiceClient) Hello(request string, reply *string) error {
        
    	return p.Client.Call(HelloServiceName+".Hello", request, reply)
    }
    
    /* ------------- 连接服务端的函数 ------------ */
    
    // DialHelloService 连接远程服务
    func DialHelloService(network, address string) (*HelloServiceClient, error) {
        
    	c, err := rpc.Dial(network, address)
    	if err != nil {
        
    		return nil, err
    	}
    	return &HelloServiceClient{
        Client: c}, nil
    }
    
    /* ------------- 客户端核心流程 ----------- */
    func main() {
        
    	// 先使用 DialHelloService 函数建立连接
    	client, err := DialHelloService("tcp", "localhost:1234")
    	if err != nil {
        
    		log.Fatal(err)
    	}
    
    	// 客户端远程调用服务中的方法
    	var reply string
    	err = client.Hello("world!", &reply)
    	if err != nil {
        
    		log.Fatal(err)
    	}
    
    	// 最后打印出客户端调用 rpc 的响应结果
    	fmt.Println(reply)
    }

解释：

客户端也进行了优化，原本客户端主要流程分为连接远程服务，然后调用远程服务，现在连接远程服务直接被封装成一个函数，封装后的函数主要用来产生一个结构对象

还有一个更改就是封装了一个客户端的结构体，这个客户端结构包含了一个 rpc 的 Client 结构体变量，还有一个调用远程服务的方法。结构体实际就是连接远程服务时返回的内容

最后我们通过结构体调用指定的方法来访问远程服务即可。原来的操作是你还需要指定远程服务的服务名和服务方法名，现在这个结构体的方法名字其实就表示了是哪一个服务方法

# 进一步：跨语言的 rpc #

go rpc 标准库默认采取 go 语言独有的 gob 编码方式，因此其他语言调用 go 语言实现 rpc 服务比较困难。但是 go 的 rpc 框架有两个比较有意思的设计，一个是 rpc 数据打包时可以通过插件实现自定义的编解码，另一个是 rpc 建立在抽象的 io.ReadWriteCloser 接口上，所以可以将 rpc 架设在不同的通讯协议上

## rpc 服务端 ##

核心：`rpc.ServeCodec(jsonrpc.NewServerCodec(conn))`

func main() {
        
    	// 用名字来注册
    	RegisterHelloService(new(HelloService))
    	// 注册其他服务...
    
    	// 持续监听端口中...
    	listener, err := net.Listen("tcp", ":1234")
    	if err != nil {
        
    		log.Fatal("ListenTCP error:", err)
    	}
    
    	for {
        
    		// 一旦监听接收到数据
    		conn, err := listener.Accept()
    		if err != nil {
        
    			log.Fatal("Accept error:", err)
    		}
    
    		// rpc 建立连接，关键代码
    		go rpc.ServeCodec(jsonrpc.NewServerCodec(conn))
    	}
    }

解释：

代码中的变化是`rpc.ServeConn`与客户端建立连接的函数改成了`rpc.ServeCodec`，入参是针对服务端的 json 编解码器

## 客户端 ##

核心：`client := rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))`

func main() {
        
        conn, err := net.Dial("tcp", "localhost:1234")
        if err != nil {
        
            log.Fatal("net.Dial:", err)
        }
    
        client := rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))
    
        var reply string
        err = client.Call("HelloService.Hello", "world!", &reply)
        if err != nil {
        
            log.Fatal(err)
        }
    
        fmt.Println(reply)
    }

解释：

客户端代码的主要变化是使用 Dial 函数生成一个连接，然后这个连接去建立针对于客户端的 json 编解码器

我们可以使用 nc 命令来观察`nc -l 1234`可以在同样的端口号启动一个 tcp 服务来查看客户端调用时候发送的数据格式，然后执行 rpc 客户端调用的时候就能看到 json 信息

`{"method":"HelloService.Hello","params":["world!"],"id":0}`

然后我们通过 nc 命令直接模拟一个 json 发到服务端

`$ echo -e '{"method":"HelloService.Hello","params":["world!"],"id":1}' | nc localhost 1234`会发现返回结果也是一个 json

因此无论用什么语言，因为客户端和服务端通信采用的是 json，就可以显示跨语言通信了

# 进一步：http 中访问 rpc #

golang 内的 rpc 已经支持基于 http 协议提供 rpc 服务，但是 http 协议的服务同样采用了 gob 编码，所以我们有做如下改动

## rpc 客户端 ##

这里算是 http 的服务端，但却是 rpc 的客户端，因为当 http 接口请求到 http 之后，接口的数据还会访问 rpc 服务

func main() {
        
    	// 注册服务
    	rpc.RegisterName("HelloService", new(HelloService))
    
    	// 注册路由
    	http.HandleFunc("/jsonrpc", func(w http.ResponseWriter, r *http.Request) {
        
    		// 拿到 http 建立连接的通道
    		var conn io.ReadWriteCloser = struct {
        
    			io.Writer
    			io.ReadCloser
    		}{
        
    			ReadCloser: r.Body,
    			Writer:     w,
    		}
    
    		// 做 rpc 连接
    		rpc.ServeRequest(jsonrpc.NewServerCodec(conn))
    	})
    
    	// 监听端口
    	http.ListenAndServe(":1234", nil)
    }

解释：

当我们调用 http 接口请求时候，传入的请求体参数是是一个 json，那么程序会走到路由的函数中，路由函数最后的`rpc.ServeRequest`会做 json 解析，然后把这个数据传输给 rpc 的服务端拿到结果

我们可以尝试用如下命令发送一个 json 过去掉 rpc

$ curl localhost:1234/jsonrpc -X POST \
        --data '{"method":"HelloService.Hello","params":["world!"],"id":0}'

会发现实际返回的也是 json，这样就可以基于 http 来访问 rpc

# 总结 #

golang net/rpc 实现 rpc 总结

*  服务端
    
     *  定义服务对象和对象中的服务方法
     *  注册服务
     *  持续监听端口
     *  接收到监听
     *  建立连接
 *  客户端
    
     *  与服务端建立连接
     *  调用 rpc 服务的方法并获得响应