阅读 4532

一个轻量级RPC的实现

前言

最近公司在做分布式相关的东西,需要用到RPC。以前对RPC不是很了解,网上也看了很多文章,发现看过之后并没有加深我的理解,仍然云里雾里,只知道是远程过程调用,一个计算机上的程序可以调用另一个计算机上的服务,或一个进程调用另一个进程提供的服务,仅此而已。也用了golang官方的net/rpc库实现了这个目的,但是对net/rpc的底层不了解(只是会用),本着一颗“钻牛角尖”的心,我决定深入研究一下RPC的原理,并自己实现一个RPC,故有了这篇文章。

什么是RPC

维基百科对RPC是这样解释的:

In distributed computing, a remote procedure call (RPC) is when a computer program causes a procedure (subroutine) to execute in a different address space (commonly on another computer on a shared network), which is coded as if it were a normal (local) procedure call, without the programmer explicitly coding the details for the remote interaction.

我就不翻译了,大体是说程序A调用程序B,A跟B不在一个地址空间(通常A跟B也不在同一台电脑上),但是A调用B就跟调用本地的程序是一样的,程序员无需对这个远程的交互细节进行额外的编程。

这里有两个关键词,我用黑体标出来了。 分布式:表明了RPC的应用场景,一般是用在多台计算机,而不是单台计算机上。 在不同的地址空间:说明了至少有两个进程,一个服务端进程,一个客户端进程。服务端进程提供服务(暴露出某些接口),客户端进程调用服务。当然测试的时候服务端和客户端程序写在一个文件里面也行,在主线程里面写服务端程序,提供接口,然后新开一个线程写客户端程序,调用接口也是可以的。

RPC原理图

实现一个RPC需要解决哪些问题

从RPC原理图中我们可以看出,server端是服务提供方,client端是服务调用方。既然server端可以提供服务,那么它要先实现服务的注册,只有注册过的服务才能被client端调用。前文也说过,client端和server端一般不在一个进程内,甚至不在一个计算机内,那么他们之间的通信必然是通过网络传输,这样就涉及到了网络传输协议,说的更直白的,就是如何将client端的数据(一般是要调用的服务名和相应的参数)安全传输到server端,而server端也能完整的接收到。在client端和server端,数据一般是以对象的形式存在,而对象是无法进行网络传输的,在网络传输之前,我们需要先把对象序列化成字节流,然后传输这些字节流,server端在接收到这些字节流之后,再反序列化得到原始对象,这就是序列化与反序列化。总结一下,要实现一个RPC就必须解决这三个问题,即

  1. 服务的注册
  2. 网络传输
  3. 序列化与反序列化

调用形式

在讲解具体的实现之前,我们先看一下我们的testrpc是如何使用的。 server.go

package main

import (
	"log"
	"net"
	"testrpc"
)

type Args struct {
	A, B int
}

type Arith int

func (t *Arith) Multiply(args Args, reply *int) error {
	*reply = args.A * args.B
	return nil
}

func main() {
	// 创建一个rpc server对象
	newServer := testrpc.NewServer()

	// 向rpc server对象注册一个Arith对象,注册后,client就可以调用Arith的Multiply方法
	arith := new(Arith)
	newServer.Register(arith)

	// 监听本机的1234端口
	l, e := net.Listen("tcp", "127.0.0.1:1234")
	if e != nil {
		log.Fatalf("net.Listen tcp :0: %v", e)
	}

	for {
		// 阻塞直到从1234端口收到一个网络连接
		conn, e := l.Accept()
		if e != nil {
			log.Fatalf("l.Accept: %v", e)
		}

		//开始工作
		go newServer.ServeConn(conn)
	}
}
复制代码

代码比较简单,也有注释,这里简单说明一下流程:我们先是new出来了一个rpc server对象,然后向这个server注册了Arith对象,注册后,client就可调用Arith暴露出来的所有方法,这里只有Multiply。然后我们监听了本机的1234端口,并且在for循环中等待来自1234端口的连接,等来了一个连接我们就调用ServeConn方法在一个新的goroutine中处理这个连接,然后我们继续等待新的连接,如此反复。

client.go

package main

import (
	"log"
	"net"
	"os"
	"testrpc"
)

type Args struct {
	A, B int
}

func main() {

	// 连接本机的1234端口,返回一个net.Conn对象
	conn, err := net.Dial("tcp", "127.0.0.1:1234")
	if err != nil {
		log.Println(err.Error())
		os.Exit(-1)
	}

	// main函数退出时关闭该网络连接
	defer conn.Close()

	// 创建一个rpc client对象
	client := testrpc.NewClient(conn)
	// main函数退出时关闭该client
	defer client.Close()

	// 调用远端Arith.Multiply函数
	args := Args{7, 8}
	var reply int
	err = client.Call("Arith.Multiply", args, &reply)
	if err != nil {
		log.Fatal("arith error:", err)
	}
	log.Println(reply)
}
复制代码

我们先连接本机的1234端口(这个端口server.go在监听),得到一个net.Conn对象,然后用这个对象new出来了一个rpc client,然后再通过这个client调用服务端提供的方法Multiply,计算完后把结果存到reply中。代码很简单,就不多说了。

这个用法参考了golang官方的net/rpc库,有兴趣的读者也可以去学习一下net/rpc的使用方法。

实现原理

Server的定义

前面说过,server端要解决的问题有服务的注册,也就是Register方法,那么server端必须要能够存储这些服务,所以server的定义可以如下:

type Service struct {
	Method    reflect.Method
	ArgType   reflect.Type
	ReplyType reflect.Type
}

type Server struct {
	ServiceMap  map[string]map[string]*Service
	serviceLock sync.Mutex
}
复制代码

一个Service对象就对应一个服务,一个服务包括方法、参数类型和返回值类型。Server有两个属性:ServiceMap和serviceLock,ServiceMap是一系列service的集合,之所以要以Map的形式是为了方便查找,serviceLock是为了保护ServiceMap,确保同一时刻只有一个goroutine能够写ServiceMap。

服务的注册

func (server *Server) Register(obj interface{}) error {
	server.serviceLock.Lock()
	defer server.serviceLock.Unlock()

	//通过obj得到其各个方法,存储在servicesMap中
	tp := reflect.TypeOf(obj)
	val := reflect.ValueOf(obj)
	serviceName := reflect.Indirect(val).Type().Name()
	if _, ok := server.ServiceMap[serviceName]; ok {
		return errors.New(serviceName + " already registed.")
	}

	s := make(map[string]*Service)
	numMethod := tp.NumMethod()
	for m := 0; m < numMethod; m++ {
		service := new(Service)
		method := tp.Method(m)
		mtype := method.Type
		mname := method.Name

		service.ArgType = mtype.In(1)
		service.ReplyType = mtype.In(2)
		service.Method = method
		s[mname] = service
	}
	server.ServiceMap[serviceName] = s
	server.ServerType = reflect.TypeOf(obj)
	return nil
}
复制代码

这里把前面的调用Register的代码放出来一起看可能会更清楚一些。

type Arith int

func (t *Arith) Multiply(args Args, reply *int) error {
	*reply = args.A * args.B
	return nil
}

...
newServer := testrpc.NewServer()
newServer.Register(new(Arith))
...
复制代码

Register的大概逻辑就是拿到obj(Register的参数)的各个暴露出来的方法(这里只有一个Multiply),然后存到server的ServiceMap中。这里主要用到了golang的reflect,如果对reflect不了解的话看Register代码还是比较吃力的。网上有很多讲解reflect的文章,建议不了解reflect的读者先去看看,这里就不讲了。注册之后,ServiceMap大概是这个样子

{
	"Arith": {"Multiply":&{Method:Multiply, ArgType:main.Args, ReplyType:*int}}	
}
复制代码

网络传输

testrpc的网络传输是基于golang提供的net.Conn,这个net.Conn提供了两个方法:Read和Write。Read表示从网络连接中读取数据,Write表示向网络连接中写数据。我们就基于这两个方法来实现我们的网络传输,代码如下:

const (
	EachReadBytes = 500
)

type Transfer struct {
	conn net.Conn
}

func NewTransfer(conn net.Conn) *Transfer {
	return &Transfer{conn: conn}
}

func (trans *Transfer) ReadData() ([]byte, error) {
	finalData := make([]byte, 0)
	for {
		data := make([]byte, EachReadBytes)
		i, err := trans.conn.Read(data)
		if err != nil {
			return nil, err
		}
		finalData = append(finalData, data[:i]...)
		if i < EachReadBytes {
			break
		}
	}
	return finalData, nil
}

func (trans *Transfer) WriteData(data []byte) (int, error) {
	num, err := trans.conn.Write(data)
	return num, err
}
复制代码

ReadData是从网络连接中读取数据,每次读500字节(由EachReadBytes指定),直到读完为止,然后把读到的数据返回;WriteData是向网络连接中写数据

序列化与反序列化

上节讲到了网络传输,我们知道,传输的对象是字节流。序列化就是负责把对象变成字节流的,相反的,反序列化就是负责将字节流变成程序中的对象的。在网络传输之前我们要先进行序列化,testrpc采用了json做为序列化方式,未来可能会加入其它的序列化方式,如gob、xml、protobuf等。我们先来看下采用json做为序列化的代码:

type EdCode int

func (edcode EdCode) encode(v interface{}) ([]byte, error) {
	return json.Marshal(v)
}

func (edcode EdCode) decode(data []byte, v interface{}) error {
	return json.Unmarshal(data, v)
}
复制代码

这里采用了golang官方提供的json库,代码很简单,就不解释了。

Server端处理网络连接

  1. 构造一个Transfer对象,代表一个网络传输
  2. 调用Transfer的ReadData方法从网络连接中读数据
  3. 调用EdCode的decode方法将数据反序列化成普通对象
  4. 获取反序列化后数据,如方法名、参数
  5. 根据方法名查找ServiceMap,拿到对应的service
  6. 调用对应的service,得到结果
  7. 将结果序列化
  8. 使用Transfer的WriteData方法的写回到网络连接中

以上就是Server端在拿到Client端请求后的处理过程,我们把它封装在了ServeConn方法里。代码比较长,就不在这里贴了,有兴趣的可以去github里面看。

Client端发起网络连接

  1. 构造一个Transfer对象,代表一个网络传输
  2. 将要调用的服务名和参数序列化
  3. 使用Transfer的WriteData方法将序列化后的数据的写入到网络连接中
  4. 阻塞直到Server端计算完
  5. 调用Transfer的ReadData方法从网络连接中读取计算后的结果
  6. 将结果反序列化后返回给client 代码如下:
func (client *Client) Call(methodName string, req interface{}, reply interface{}) error {

	// 构造一个Request
	request := NewRequest(methodName, req)

	// encode
	var edcode EdCode
	data, err := edcode.encode(request)
	if err != nil {
		return err
	}

	// write
	// 构造一个Transfer
	trans := NewTransfer(client.conn)
	_, err = trans.WriteData(data)
	if err != nil {
		log.Println(err.Error())
		return err
	}

	// read
	data2, err := trans.ReadData()
	if err != nil {
		log.Println(err.Error())
		return err
	}

	// decode and assin to reply
	edcode.decode(data2, reply)

	// return
	return nil
}
复制代码

Client的定义很简单,就一个代表网络连接的conn,代码如下:

type Client struct {
	conn net.Conn
}
复制代码

为什么不用Python来实现

由于我平常写Python代码写得比较多,如果用Python来实现这个testrpc的话确实要更快。那么为什么要使用golang呢?因为我们公司最近做的一个项目是基于golang的net/rpc来实现的,工作之便,了解了net/rpc的使用,也稍微看了下net/rpc的底层代码,猜出了其大概原理,于是就想自己也写一个,就这样。当然,以后有机会的话再用Python实现一遍。

总结

本文主要讲述了RPC的原理,以及实现了一个轻量级的RPC。这里说一下我在调试的时候遇到的问题,由于golang是强类型语言,那么我必须要面对的问题是,怎么在一个对象经过序列化和反序列化之后依然保持其原来的类型。比如一个Args类型的对象(读者可以翻到最前面看看Args是如何定义的)在序列化和反序列化之后变成了map[string]interface{}类型,用map[string]interface{}类型当做Args类型传参是会报错的,这部分感兴趣的读者可以去看看代码。读者可能看过这篇文章没什么感觉,看过一遍也就看过了,感觉有收获又感觉没收获,我建议把代码下载下来,然后在自己的电脑上跑一下,调试一下,我相信你会有很深的理解,不管是对RPC,还是对golang的reflect等。比如说我,我以前对reflect掌握的不是很好,写完这个testrpc之后基本掌握了reflect的使用。

代码在github上,欢迎给个star和提交issue,也欢迎你提出自己的看法,比如这段代码写得不好,可以这么优化等等,都可以与我交流,多谢!

github地址:https://github.com/TanLian/testrpc

另也可关注下我个人的技术公众号,期待一起进步。

关注下面的标签,发现更多相似文章
评论