Golang实现RPC
RPC
一、简介
远程过程调用（Remote Procedure Call，RPC）是一个计算机通信协议 ；
该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额 外地为这个交互作用编程 ；
如果涉及的软件采用面向对象编程，那么远程过程调用亦可称作远程调用或远程方 法调用 ；
二、Golang中实现RPC
Golang中实现RPC非常简单，官方提供了封装好的库，还有一些第三方的库，官方的net/rpc库使用encoding/gob进行编码，所以Golang的RPC只支持Golang开发的服务器和客户端之间交互。
官方还提供了net/rpc/jsonrpc库来实现RPC方法，jsonrpc采用了JSON进行数据编码解码，因而支持跨语言调用，目前jsonrpc库是基于tcp协议实现的,暂不支持http传输方式。
- Golang的RPC必须符合四个条件才可以：
- 结构体首字母必须大写，要跨域访问，所以大写
- 函数名首字母必须大写
- 函数第一个参数是接收参数，第二个参数是返回个客户端的参数，必须是指针类型
- 函数有一个返回值error
示例
1、Golang实现RPC程序，实现求矩形面积和周长。
- 服务端
package main
import (
"fmt"
"net/http"
"net/rpc"
)
// 服务端求矩形面积和周长
// 声明矩形对象
type Rect struct{}
// 声明参数结构体，字段首字母大写
type Params struct{
Width, Height int
}
// 定义求矩形面积的方法
func (r *Rect)Area(p Params,ret *int) error {
*ret = p.Width * p.Height
return nil
}
// 定义求矩形周长的方法
func (r *Rect) Perimeter(p Params, ret *int)error{
*ret = (p.Width + p.Height) * 2
return nil
}
func main() {
// 注册服务
rect := new(Rect)
rpc.Register(rect)
// 把服务处理绑定到http协议上
rpc.HandleHTTP()
// 监听服务，等待客户端调用求面试和周长的方法
if err := http.ListenAndServe(":8080",nil); err != nil {
fmt.Println(err)
}
}
- 客户端
package main
import (
"fmt"
"log"
"net/rpc"
)
type Params struct{
Width,Height int
}
// 调用服务
func main() {
// 连接远程rpc服务
client, err := rpc.DialHTTP("tcp","127.0.0.1:8080")
if err != nil {
fmt.Println(err)
}
// 调用远程的方法
// 定义接受服务端传回来的计算结果变量
ret := 0
// 求面积
if err = client.Call("Rect.Area",Params{50,100},&ret); err != nil {
log.Fatal(err)
}
fmt.Println("面积:", ret)
// 求周长
if err = client.Call("Rect.Perimeter",Params{50,100},&ret);err !=nil{
log.Fatal(err)
}
fmt.Println("周长：",ret)
}
2 、服务端接收两个参数，可以做乘法运算，也可以做商和余数的运算，客户端进行传参和访问，得到结果如下：
9 * 2 =18
9 / 2, 商 = 4， 余数 = 1
- 服务端
package main
import (
"errors"
"fmt"
"log"
"net"
"net/rpc"
"net/rpc/jsonrpc"
)
// 声明算术运算的结构体
type Arith struct{}
// 声明接收参数的结构体
type ArithRequest struct{
A, B int
}
// 声明返回客户端参数结构体
type ArithResponse struct{
Pro int // 乘积
Quo int // 商
Rem int // 余数
}
// 乘法运算
func (a *Arith) Multiply(req ArithRequest, resp *ArithResponse)error{
resp.Pro = req.A * req.B
fmt.Println(resp.Pro)
return nil
}
// 商和余数
func (a *Arith) Divide(req ArithRequest, resp *ArithResponse) error {
if req.B == 0 {
return errors.New("除数不能为0")
}
resp.Quo = req.A / req.B
resp.Rem = req.A % req.B
return nil
}
// jsonRPC编码方式
func main() {
// 注册服务
rpc.Register(new(Arith))
// 监听
lis,err := net.Listen("tcp","127.0.0.1:8080")
if err != nil {
log.Fatal(err)
}
// 循环监听服务
for {
conn, err := lis.Accept()
if err != nil{
continue
}
go func(conn net.Conn) {
fmt.Println("a new Client")
jsonrpc.ServeConn(conn)
}(conn)
}
}
- 客户端
package main
import (
"fmt"
"log"
"net/rpc/jsonrpc"
)
// 声明请求参数的结构体
type ArithRequest struct{
A, B int
}
// 声明响应的结构体
type ArithResponse struct{
Pro int
Quo int
Rem int
}
func main() {
// 连接远程的rpc
conn, err := jsonrpc.Dial("tcp","127.0.0.1:8080")
if err != nil{
log.Fatal(err)
}
req := ArithRequest{
A: 9,
B: 2,
}
resp := ArithResponse{}
// 商和余数
if err = conn.Call("Arith.Divide",req,&resp); err != nil {
log.Fatal(err)
}
// 乘法
if err = conn.Call("Arith.Multiply", req, &resp); err != nil {
log.Fatal(err)
}
fmt.Printf("%d 和 %d, 积=%d, 商=%d,余数=%d\n",req.A,req.B,resp.Pro,resp.Quo,resp.Rem)
}
三、RPC调用流程
微服务架构下数据交互一般都是对内RPC,对外REST。
将业务按功能模块拆分到各个微服务，具有提高项目协作效率，降低模块耦合度，提高系统系统可用性等优点，但是开发门槛较高，比如RPC框架的使用，后期服务监控等工作。
一般情况下，我们会将功能代码在本地直接调用，微服务架构下，我们需要将这个函数作为单独的服务运行，客户端通过网络调用。
四、网络传输数据格式
成熟的RPC框架会有自定义传输协议，这里网络传输格式定义如下，前面是固定长度消息头，后面是变长消息体。
- 编写连接会话
package rpc
import (
"encoding/binary"
"io"
"net"
)
// 编写会话中数据读写
// 会话连接的结构体
type Session struct {
conn net.Conn
}
// 创建新的连接
func NewSession(conn net.Conn) *Session{
return &Session{
conn: conn,
}
}
// 向连接中写入数据
func (s *Session) Write(data []byte)error{
// 4字节头+数据长度的切片
buf := make([]byte, 4 + len(data))
// 写入头部数据，记录数据长度
// binary只认固定长度的类型，所以使用了uint32，而不是直接写入
binary.BigEndian.PutUint32(buf[:4],uint32(len(data)))
// 写入数据
copy(buf[4:],data)
_, err := s.conn.Write(buf)
if err != nil {
return err
}
return nil
}
// 从连接中读数据
func (s *Session)Read()([]byte, error){
// 读取头部长度
header := make([]byte,4)
// 按头部长度，读取头部数据
_, err := io.ReadFull(s.conn, header)
if err != nil {
return nil, err
}
// 读取数据长度
dataLen := binary.BigEndian.Uint32(header)
// 按数据长度去读取数据
data := make([]byte,dataLen)
_, err = io.ReadFull(s.conn, data)
if err != nil{
return nil ,err
}
return data, nil
}
- 测试会话读写
package rpc
import (
"fmt"
"net"
"sync"
"testing"
)
// 测试读写
func TestSession_ReadWrite(t *testing.T) {
// 定义监听的ip和端口
addr := "127.0.0.1:8000"
// 定义传输的数据
my_data := "hello"
// 等待组
wg := sync.WaitGroup{}
// 协程 一个读，一个写
wg.Add(2)
// 写数据
go func(){
defer wg.Done()
// 创建tcp连接
lis, err := net.Listen("tcp",addr)
if err != nil{
t.Fatal(err)
}
conn, _ := lis.Accept()
s := Session{conn: conn}
// 写数据
if err := s.Write([]byte(my_data)); err != nil {
t.Fatal(err)
}
}()
// 读数据
go func() {
defer wg.Done()
conn, err := net.Dial("tcp",addr)
if err != nil {
t.Fatal(err)
}
s := Session{conn: conn}
// 读数据
data, err := s.Read()
if err != nil{
t.Fatal(err)
}
if string(data) != my_data{
t.Fatal(err)
}
fmt.Println(string(data))
}()
wg.Wait()
}
- 编写编解码
package rpc
import (
"bytes"
"encoding/gob"
)
// 定义数据格式和编解码
// 定义RPC交互的数据格式
type RPCData struct{
// 访问的函数
Name string
// 访问时穿的参数
Args []interface{}
}
// 编码
func encode(data RPCData)([]byte,error){
var buf bytes.Buffer
// 得到字节数据的编码器
bufEnc := gob.NewEncoder(&buf)
// 对数据进行编码
if err := bufEnc.Encode(data); err != nil{
return nil, err
}
return buf.Bytes(),nil
}
// 解码
func decode(b []byte)(RPCData,error){
buf := bytes.NewBuffer(b)
// 返回字节数组解码器
bufDec := gob.NewDecoder(buf)
var data RPCData
// 对数据解码
if err := bufDec.Decode(&data); err != nil {
return data, err
}
return data,nil
}
五、实现RPC服务端
1、服务端接收到的数据需要包括什么？
- 调用的函数名，参数列表
- 一般会约定函数的第二个返回值是error类型
- 通过反射实现
2、服务端需要解决的问题是什么？
- Client调用时只传过来函数名，需要维护函数名到函数之间的map映射
3、服务端的核心功能有哪些？
- 维护函数名导函数反射值的map
- client端传函数名，参数列表后，服务端要解析为反反射值，调用执行
- 函数的返回值打包，并通过网络返回个客户端
package rpc
import (
"fmt"
"net"
"reflect"
)
// 声明服务端
type Server struct {
// 地址
addr string
// 服务端维护的函数名到函数反射值的map
funcs map[string]reflect.Value
}
// 创建服务端对象
func NewServer(addr string)*Server{
return &Server{
addr: addr,
funcs: make(map[string]reflect.Value),
}
}
// 服务端绑定注册方法
// 将函数名与函数真正实现对应起来
// 第一个参数为函数名，第二个传入真正的函数
func (s *Server) Register (rpcName string, f interface{}){
if _, ok := s.funcs[rpcName]; ok {
return
}
// map 中没有值，则将映射添加到map,便于调用
fVal := reflect.ValueOf(f)
s.funcs[rpcName] = fVal
}
// 服务端等待调用
func (s *Server) Run(){
// 监听
lis, err := net.Listen("tcp",s.addr)
if err != nil {
fmt.Printf("监听 %s err：%v\n",s.addr,err)
return
}
for {
// 拿到连接
conn ,err := lis.Accept()
if err != nil {
fmt.Printf("accept err :%v\n",err)
return
}
// 创建会话
srvSession := NewSession(conn)
// RPC读取数据
b,err := srvSession.Read()
if err != nil {
fmt.Printf("read err:%v\n",err)
return
}
// 对数据进行解码
rpcData, err := decode(b)
if err != nil {
fmt.Printf("decode err:%v\n", err)
return
}
// 根据读取到数据的Name,得到调用的函数名
f, ok := s.funcs[rpcData.Name]
if !ok{
fmt.Printf("函数 %s 不存在", rpcData.Name)
return
}
// 解析遍历客户端出来的参数，放到一个数组中
inArgs := make([]reflect.Value,0,len(rpcData.Args))
for _, arg := range rpcData.Args{
inArgs = append(inArgs, reflect.ValueOf(arg))
}
// 反射调用方法， 传入参数
out := f.Call(inArgs)
// 解析遍历执行结果，放到一个数组中
outArgs := make([]interface{},0,len(out))
for _, o := range out{
outArgs = append(outArgs, o.Interface())
}
// 包装数据，返回给客户端
respRPCData := RPCData{rpcData.Name,outArgs}
// 编码
respBytes, err := encode(respRPCData)
if err != nil {
fmt.Printf("encode err:%v\n",err)
return
}
// 使用rpc写出数据
err = srvSession.Write(respBytes)
if err != nil {
fmt.Printf("session write err :%v\n",err)
return
}
}
}
六、实现RPC客户端
- 客户端只有函数原型，使用
reflect.MakeFunc()可以完成原型到函数的调用 reflect.MakeFunc()是Client从函数原型到网络调度的关键
package rpc
import (
"net"
"reflect"
)
// 声明客户端
type Client struct{
conn net.Conn
}
// 创建客户端对象
func NewClient(conn net.Conn) * Client {
return &Client{conn:conn}
}
// 实现通用的RPC客户端
// 绑定RPC访问的方法
// 传入访问的函数名
// 函数具体实现在Server端，Client只有函数原型
// 使用MakeFunc()完成原型到函数的调用
// fPtr指向函数原型
// xxx.callRPC("queryUser", &query)
func (c *Client)callRPC(rpcName string, fPtr interface{}){
// 通过反射，获取fPtr未初始化的函数原型
fn := reflect.ValueOf(fPtr).Elem()
// 另一个函数，作用是对用是对第一个函数操作
// 完成与Server的交互
f := func(args []reflect.Value)[]reflect.Value{
// 处理输入的参数
inArgs := make([]interface{},0, len(args))
for _, arg := range args {
inArgs = append(inArgs,arg.Interface())
}
// 创建连接
cliSession := NewSession(c.conn)
// 编码数据
reqRPC := RPCData{Name: rpcName,Args:inArgs}
b, err := encode(reqRPC)
if err != nil {
panic(err)
}
// 写出数据
if err= cliSession.Write(b); err != nil {
panic(err)
}
// 读取响应数据
respBytes, err := cliSession.Read()
if err != nil{
panic(err)
}
// 解码数据
respRPC, err := decode(respBytes)
if err != nil {
panic(err)
}
// 处理服务端返回的数据
outArgs := make([]reflect.Value,0,len(respRPC.Args))
for i, arg := range respRPC.Args{
// 必须对nil进行处理
if arg == nil {
// 必须填充一个真正的类型，不能是nil
outArgs = append(outArgs,reflect.Zero(fn.Type().Out(i)))
continue
}
outArgs = append(outArgs,reflect.ValueOf(arg))
}
return outArgs
}
// 参数1： 一个未初始化函数的方法值，类型时reflect.Type
// 参数2： 另一个函数，作用是对第一个函数参数操作
// 返回reflect.Value 类型
// MakeFunc 使用传入的函数原型，创建一个绑定 参数2 的新函数
v := reflect.MakeFunc(fn.Type(), f)
// 为函数fPtr赋值
fn.Set(v)
}
七、实现RPC通信测试
- 给服务端注册一个查询用户的方法，客户端去RPC调用。
package rpc
import (
"encoding/gob"
"fmt"
"net"
"testing"
)
// 用户查询
// 用于测试的结构体
type User struct{
Name string
Age int
}
// 用于测试的查询用户的方法
func queryUser(uid int)(User, error){
user := make(map[int]User)
user[0] = User{"zs",20}
user[1] = User{"ls",20}
user[2] = User{"ws",20}
// 模拟查询用户
if u, ok := user[uid]; ok {
return u, nil
}
return User{}, fmt.Errorf("ud %d not in user db", uid)
}
// 测试方法
func TestRPC(t *testing.T){
// 需要对interface{}可能产生的类型进行注册
gob.Register(User{})
addr := "127.0.0.1:8000"
// 创建服务端
srv := NewServer(addr)
// 将方法注册到服务端
srv.Register("queryUser", queryUser)
// 服务端等待调用
go srv.Run()
// 客户端获取连接
conn, err := net.Dial("tcp", addr)
if err != nil {
t.Error(err)
}
// 创建客户端
cli := NewClient(conn)
// 声明函数原型
var query func(int)(User,error)
cli.callRPC("queryUser", &query)
// 得到查询结果
u, err := query(1)
if err != nil {
t.Fatal(err)
}
fmt.Println(u)
}
