本文旨在讲述 rpc 框架设计中的几个核心问题及其解决方法，并基于 golang 反射技术，构建了一个简易的 rpc 框架。
项目地址：tiny-rpc
rpc
rpc（remote procedure call），即远程过程调用，可以理解成，服务 a 想调用不在同一内存空间的服务 b 的函数，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据。
服务端
rpc 服务端需要解决 2 个问题：
核心流程
方法注册
服务端需要维护 rpc 函数名到 rpc 函数实体的映射，我们可以使用 map 数据结构来维护映射关系。
我要评论
type server struct {
addr string
funcs map[string]reflect.value
}
// register a method via name
func (s *server) register(name string, f interface{}) {
if _, ok := s.funcs[name]; ok {
return
}
s.funcs[name] = reflect.valueof(f)
}
执行调用
一般来说，客户端在调用 rpc 时，会将 函数名 和 参数列表 作为请求数据，发送给服务端。
由于我们使用了 map[string]reflect.value 来维护函数名与函数实体之间的映射，则我们可以通过 value.call() 来调用与函数名相对应的函数。
package main
import (
"fmt"
"reflect"
)
func main() {
// register methods
funcs := make(map[string]reflect.value)
funcs["add"] = reflect.valueof(add)
// when receives client's request
req := []reflect.value{reflect.valueof(1), reflect.valueof(2)}
vals := funcs["add"].call(req)
var rsp []interface{}
for _, val := range vals {
rsp = append(rsp, val.interface())
}
fmt.println(rsp)
}
func add(a, b int) (int, error) {
return a + b, nil
}
具体实现
由于篇幅的限制，此处没有贴出服务端实现的具体代码，细节请查看项目地址。
客户端
rpc 客户端需要解决 1 个问题：
核心流程
生成调用
我们可以通过 reflect.makefunc 为指定的函数原型绑定一个函数实体。
package main
import (
"fmt"
"reflect"
)
func main() {
add := func(args []reflect.value) []reflect.value {
result := args[0].interface().(int) + args[1].interface().(int)
return []reflect.value{reflect.valueof(result)}
}
var addptr func(int, int) int
container := reflect.valueof(&addptr).elem()
v := reflect.makefunc(container.type(), add)
container.set(v)
fmt.println(addptr(1, 2))
}
具体实现
由于篇幅的限制，此处没有贴出客户端实现的具体代码，细节请查看项目地址。
数据传输格式
我们需要定义服务端与客户端交互的数据格式。
type data struct {
name string // service name
args []interface{} // request's or response's body except error
err string // remote server error
}
与交互数据相对应的编码与解码函数。
func encode(data data) ([]byte, error) {
var buf bytes.buffer
encoder := gob.newencoder(&buf)
if err := encoder.encode(data); err != nil {
return nil, err
}
return buf.bytes(), nil
}
func decode(b []byte) (data, error) {
buf := bytes.newbuffer(b)
decoder := gob.newdecoder(buf)
var data data
if err := decoder.decode(&data); err != nil {
return data{}, err
}
return data, nil
}
同时，我们需要定义简单的 tlv 协议（固定长度消息头 + 变长消息体），规范数据的传输。
// transport struct
type transport struct {
conn net.conn
}
// newtransport creates a transport
func newtransport(conn net.conn) *transport {
return &transport{conn}
}
// send data
func (t *transport) send(req data) error {
b, err := encode(req) // encode req into bytes
if err != nil {
return err
}
buf := make([]byte, 4+len(b))
binary.bigendian.putuint32(buf[:4], uint32(len(b))) // set header field
copy(buf[4:], b) // set data field
_, err = t.conn.write(buf)
return err
}
// receive data
func (t *transport) receive() (data, error) {
header := make([]byte, 4)
_, err := io.readfull(t.conn, header)
if err != nil {
return data{}, err
}
datalen := binary.bigendian.uint32(header) // read header filed
data := make([]byte, datalen) // read data field
_, err = io.readfull(t.conn, data)
if err != nil {
return data{}, err
}
rsp, err := decode(data) // decode rsp from bytes
return rsp, err
}
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持移动技术网。
如对本文有疑问， 点击进行留言回复！！
网友评论