Go学习笔记 - 使用jsonrpc进行远程访问

##JSON-RPC

----------
JSON-RPC是一个轻量级的远程调用协议，简单易用。

**请求数据体**:

{
"method": "getName",
"params": ["1"],
"id": 1
}

`method`: 远端的方法名

`params`: 远程方法接收的参数列表

`id`: 本次请求的标识码，远程返回时数据的标识码应与本次请求的标识码相同

**返回数据体**:

{
"result": {"id": 1, "name": "name1"},
"error": null,
"id": 1
}

`result`: 远程方法返回值

`error`: 错误信息

`id`: 调用时所传来的id

----------

##Go的rpc包
**`net/rpc`**

`net/rpc`包实现了最基本的rpc调用，它默认通过`HTTP`协议传输`gob`数据来实现远程调用。

服务端实现了一个HTTP server,接收客户端的请求，在收到调用请求后，会反序列化客户端传来的gob数据，获取要调用的方法名，并通过反射来调用我们自己实现的处理方法，这个处理方法传入固定的两个参数，并返回一个error对象，参数分别为客户端的请求内容以及要返回给客户端的数据体的指针。

**`net/rpc/jsonrpc`**

`net/rpc/jsonrpc`包实现了JSON-RPC协议，即实现了`net/rpc`包的`ClientCodec`接口与`ServerCodec`，增加了对json数据的序列化与反序列化。

----------
##Go JSON-RPC远程调用
客户端与服务端双方传输数据，其中数据结构必须得让双方都能处理。

首先定义rpc所传输的数据的结构，client端与server端都得用到。

// 需要传输的对象
type RpcObj struct {
Id int `json:"id"` // struct标签， 如果指定，jsonrpc包会在序列化json时，将该聚合字段命名为指定的字符串
Name string `json:"name"`
}

// 需要传输的对象
type ReplyObj struct {
Ok bool `json:"ok"`
Id int `json:"id"`
Msg string `json:"msg"`
}

`RpcObj` 为传输的数据

`ReplyObj` 为服务端返回的数据

这两个结构体均可以在client和server端双向传递

**服务端**

引入两个包

"net/rpc"
"net/rpc/jsonrpc"

`net/rpc`实现了go的rpc框架，而`net/rpc/jsonrpc`则具体实现了JSON-RPC协议，具有json数据的序列化与反序列化功能。

实现处理器

// server端的rpc处理器
type ServerHandler struct {}

// server端暴露的rpc方法
func (serverHandler ServerHandler) GetName(id int, returnObj *RpcObj) error {
log.Println("server\t-", "recive GetName call, id:", id)
returnObj.Id = id
returnObj.Name = "名称1"
return nil
}

// server端暴露的rpc方法
func (serverHandler ServerHandler) SaveName(rpcObj RpcObj, returnObj *ReplyObj) error {
log.Println("server\t-", "recive SaveName call, RpcObj:", rpcObj)
returnObj.Ok = true
returnObj.Id = rpcObj.Id
returnObj.Msg = "存储成功"
return nil
}

`ServerHandler`结构可以不需要什么字段，只需要有符合`net/rpc`server端处理器约定的方法即可。

符合约定的方法必须具备两个参数和一个`error`类型的返回值

*第一个参数* 为client端调用rpc时交给服务器的数据，可以是指针也可以是实体。`net/rpc/jsonrpc`的json处理器会将客户端传递的json数据解析为正确的struct对象。

*第二个参数* 为server端返回给client端的数据,必须为指针类型。`net/rpc/jsonrpc`的json处理器会将这个对象正确序列化为json字符串，最终返回给client端。

`ServerHandler`结构需要注册给`net/rpc`的HTTP处理器，HTTP处理器绑定后，会通过反射得到其暴露的方法，在处理请求时，根据JSON-RPC协议中的`method`字段动态的调用其指定的方法。

// 新建Server
server := rpc.NewServer()

// 开始监听,使用端口 8888
listener, err := net.Listen("tcp", ":8888")
if err != nil {
log.Fatal("server\t-", "listen error:", err.Error())
}
defer listener.Close()

log.Println("server\t-", "start listion on port 8888")

// 新建处理器
serverHandler := &ServerHandler{}

// 注册处理器
server.Register(serverHandler)

// 等待并处理链接
for {
conn, err := listener.Accept()
if err != nil {
log.Fatal(err.Error())
}

// 在goroutine中处理请求
// 绑定rpc的编码器，使用http connection新建一个jsonrpc编码器，并将该编码器绑定给http处理器
go server.ServeCodec(jsonrpc.NewServerCodec(conn))
}

rpc server端大致的处理流程


**客户端**

客户端必须确保存在服务端在传输的数据中所使用的struct，在这里，必须确保客户端也能使用`RpcObj`与`ReplyObj` struct。

client, err := net.DialTimeout("tcp", "localhost:8888", 1000*1000*1000*30) // 30秒超时时间
if err != nil {
log.Fatal("client\t-", err.Error())
}

defer client.Close()

首先，通过`net`包使用TCP协议连接至服务器，这里设定了超时时间。

clientRpc := jsonrpc.NewClient(client)

然后使用`jsonrpc.NewClient`通过之前的TCP链接建立一个rpcClient实例。

对于`net/rpc`的客户端，在远程调用是有同步(Synchronous)和异步(Asynchronous)两种方式。不论那种方式，在源码中，请求总是在一个新的goroutine中执行，并且使用一个通道(chan)来存放服务器返回值。使用同步方式调用时，调用方法内部会等待chan的数据，并一直阻塞直到远程服务器返回。而使用异步方式时，客户端的调用方法会直接将chan返回，这样就可以适时的处理数据而不影响当前goroutine。

下面是`net/rpc/client`中调用远程rpc的源码

// Go invokes the function asynchronously. It returns the Call structure representing
// the invocation. The done channel will signal when the call is complete by returning
// the same Call object. If done is nil, Go will allocate a new channel.
// If non-nil, done must be buffered or Go will deliberately crash.
func (client *Client) Go(serviceMethod string, args interface{}, reply interface{}, done chan *Call) *Call {
call := new(Call)
call.ServiceMethod = serviceMethod
call.Args = args
call.Reply = reply
if done == nil {
done = make(chan *Call, 10) // buffered.
} else {
// If caller passes done != nil, it must arrange that
// done has enough buffer for the number of simultaneous
// RPCs that will be using that channel. If the channel
// is totally unbuffered, it's best not to run at all.
if cap(done) == 0 {
log.Panic("rpc: done channel is unbuffered")
}
}
call.Done = done
client.send(call)
return call
}

// Call invokes the named function, waits for it to complete, and returns its error status.
func (client *Client) Call(serviceMethod string, args interface{}, reply interface{}) error {
call := <-client.Go(serviceMethod, args, reply, make(chan *Call, 1)).Done
return call.Error
}

*同步调用的使用*

// 远程服务器返回的对象
var rpcObj RpcObj
// 请求数据，rpcObj对象会被填充
clientRpc.Call("ServerHandler.GetName", 1, &rpcObj)

// 远程返回的对象
var reply ReplyObj
// 传给远程服务器的对象参数
saveObj := RpcObj{2, "对象2"}
// 请求数据
clientRpc.Call("ServerHandler.SaveName", saveObj, &reply)

`Call`方法属于同步方式的调用。第一个参数为Server端JSON-RPC处理器的类名加方法名，第二个参数为提交给远端服务器的数据，第三个参数是服务器的返回数据,必须是指针。

*异步调用的使用*

// 传给远程的对象
saveObj := RpcObj{i, "对象"}

// 异步的请求数据
divCall := clientRpc.Go("ServerHandler.SaveName", saveObj, &ReplyObj{}, nil)

// 在一个新的goroutine中异步获取远程的返回数据，并不阻塞当前的goroutine
go func() {
reply := <-divCall.Done // 取出远程返回的数据
}()

`Call`方法属于同步方式的调用。第一个参数为Server端JSON-RPC处理器的类名加方法名，第二个参数为提交给远端服务器的数据，第三个参数是服务器的返回数据,必须是指针，第四个参数为一个通道，可以留空，留空的话它会帮忙建一个，并保存在divCall中。

`net/rpc/jsonrpc/client`会把方法名与参数自动序列化为json格式，其结构如开头所述的JSON-RPC结构一样，并自动为JSON-RPC中的id赋值。而服务端返回的对象也会被正确的反序列化。

rpc client端大致的处理流程


----------
完整的程序

package main

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

// 需要传输的对象
type RpcObj struct {
Id int `json:"id"` // struct标签， 如果指定，jsonrpc包会在序列化json时，将该聚合字段命名为指定的字符串
Name string `json:"name"`
}

// 需要传输的对象
type ReplyObj struct {
Ok bool `json:"ok"`
Id int `json:"id"`
Msg string `json:"msg"`
}

// server端的rpc处理器
type ServerHandler struct {}

// server端暴露的rpc方法
func (serverHandler ServerHandler) GetName(id int, returnObj *RpcObj) error {
log.Println("server\t-", "recive GetName call, id:", id)
returnObj.Id = id
returnObj.Name = "名称1"
return nil
}

// server端暴露的rpc方法
func (serverHandler ServerHandler) SaveName(rpcObj *RpcObj, returnObj *ReplyObj) error {
log.Println("server\t-", "recive SaveName call, RpcObj:", rpcObj)
returnObj.Ok = true
returnObj.Id = rpcObj.Id
returnObj.Msg = "存储成功"
return nil
}

// 开启rpc服务器
func startServer() {
// 新建Server
server := rpc.NewServer()

// 开始监听,使用端口 8888
listener, err := net.Listen("tcp", ":8888")
if err != nil {
log.Fatal("server\t-", "listen error:", err.Error())
}
defer listener.Close()

log.Println("server\t-", "start listion on port 8888")

// 新建处理器
serverHandler := &ServerHandler{}

// 注册处理器
server.Register(serverHandler)

// 等待并处理链接
for {
conn, err := listener.Accept()
if err != nil {
log.Fatal(err.Error())
}

// 在goroutine中处理请求
// 绑定rpc的编码器，使用http connection新建一个jsonrpc编码器，并将该编码器绑定给http处理器
go server.ServeCodec(jsonrpc.NewServerCodec(conn))
}
}

// 客户端以同步的方式向rpc服务器请求
func callRpcBySynchronous() {
// 连接至服务器
client, err := net.DialTimeout("tcp", "localhost:8888", 1000*1000*1000*30) // 30秒超时时间
if err != nil {
log.Fatal("client\t-", err.Error())
}

defer client.Close()

// 建立rpc通道
clientRpc := jsonrpc.NewClient(client)

// 远程服务器返回的对象
var rpcObj RpcObj
log.Println("client\t-", "call GetName method")
// 请求数据，rpcObj对象会被填充
clientRpc.Call("ServerHandler.GetName", 1, &rpcObj)
log.Println("client\t-", "recive remote return", rpcObj)

// 远程返回的对象
var reply ReplyObj

// 传给远程服务器的对象参数
saveObj := RpcObj{2, "对象2"}

log.Println("client\t-", "call SetName method")
// 请求数据
clientRpc.Call("ServerHandler.SaveName", saveObj, &reply)

log.Println("client\t-", "recive remote return", reply)
}

// 客户端以异步的方式向rpc服务器请求
func callRpcByAsynchronous() {
// 打开链接
client, err := net.DialTimeout("tcp", "localhost:8888", 1000*1000*1000*30) // 30秒超时时间
if err != nil {
log.Fatal("client\t-", err.Error())
}
defer client.Close()

// 建立rpc通道
clientRpc := jsonrpc.NewClient(client)

// 用于阻塞主goroutine
endChan := make(chan int, 15)

// 15次请求
for i := 1 ; i <= 15; i++ {

// 传给远程的对象
saveObj := RpcObj{i, "对象"}

log.Println("client\t-", "call SetName method")
// 异步的请求数据
divCall := clientRpc.Go("ServerHandler.SaveName", saveObj, &ReplyObj{}, nil)

// 在一个新的goroutine中异步获取远程的返回数据
go func(num int) {
reply := <-divCall.Done
log.Println("client\t-", "recive remote return by Asynchronous", reply.Reply)
endChan <- num
}(i)
}

// 15个请求全部返回时此方法可以退出了
for i := 1 ; i <= 15; i++ {
_ = <-endChan
}

}

func main() {
go startServer()
callRpcBySynchronous()
callRpcByAsynchronous()
}

----------
##总结
在使用`net/rpc/jsonrpc`时遇到这样一个问题：

有多个client与一个server进行rpc调用，而这些client又处于不同的内网，在server端需要获取client端的公网IP。

按照`net/rpc`的实现，在服务端处理器的自定义方法中只能获取被反序列化的数据，其他请求相关信息如client的IP只能在主goroutine的`net.Listener.Accept`中的`Conn`对象取得。

按源码中的示例，每接收一个TCP请求都会在一个新的goroutine中处理，但是处理器的自定义方法都运行在不同的goroutine中，这些回调的方法没有暴露任何能获取conn的字段、方法。

我是这样解决的，在server端rpc处理器struct中放一个聚合字段，用于存储ip地址的。

处理器被注册与rpc server，全局只有一个，在每次接受到tcp请求后，开启一个goroutine，然后在goroutine内部立即加上排斥锁，然后再把请求的conn绑定给rpc server处理器，这样，即能保证handler字段的线程安全，又能及时的相应client的请求。

....
....
....
mutex := &sync.Mutex{}

// 等待链接
for {
// 相应请求
conn, err := listener.Accept()
if err != nil {
log.Println(err.Error())
}

// 开启一个goroutine来处理请求，紧接着等待下一个请求。
go func() {
// 应用排斥锁
mutex.Lock()
// 记录ip地址
reciveHandler.Ip = strings.Split(conn.RemoteAddr().String(), ":")[0]
// 处理JSON-RPC调用
server.ServeCodec(jsonrpc.NewServerCodec(conn))
// 解锁
mutex.Unlock()
}()
}
....
....
....