RPC（Remote Procedure Call）—— 远程过程调用。通过它可以使函数调用模式网络化。客户端就像调用本地函数一样，客户端把这些参数打包之后通过网络传递到服务端，服务端解包到处理过程中执行，然后将执行的结果反馈给客户端。在 OSI 网络通信模型中，RPC 跨越了传输层和应用层。RPC 使得开发分布式应用程序更加容易。
HTTP RPC server using golang net/rpc package
Go 标准包中已经提供了对 RPC 的支持，而且支持三个级别的 RPC：TCP、HTTP、JSONRPC。但 Go 的 RPC 包是独一无二的 RPC，它和传统的 RPC 系统不同，它只支持 Go 开发的服务器与客户端之间的交互，因为在内部采用了 Gob 来编码。
Go RPC 的函数只有符合下面的条件才能被远程访问：
- 函数必须是导出的(首字母大写)
- 必须有两个参数，并且是导出类型或者内建类型
- 第二个参数必须是指针类型的
- 函数还要有一个返回值 error
举个例子，正确的 RPC 函数格式如下：
func (t *T) MethodName(argType T1, replyType *T2) error
T、T1 和 T2 类型必须能被 encoding/gob 包编解码。
接下来，定义服务对象和方法：
http-rpc/arith.go
package http_rpc
import (
"log"
)
type Arith int
type Args struct {
A, B int
}
func (t *Arith) Multiply(args Args, result *int) error {
log.Printf("Multiply %d with %d\n", args.A, args.B)
*result = args.A * args.B
return nil
}
任何的 RPC 都需要通过网络来传递数据，Go RPC 可以利用 HTTP 和 TCP 来传递数据，利用 HTTP 的好处是可以直接复用 net/http 里面的一些函数。
http-rpc/server/main.go
package main
import (
"log"
"net/http"
"net/rpc"
. "rpc-golang/http-rpc"
)
func main() {
arith := new(Arith)
rpc.Register(arith)
// 把该服务注册到 HTTP 协议上
rpc.HandleHTTP()
log.Println("HTTP RPC service listen and serving on port 1234")
if err := http.ListenAndServe(":1234", nil); err != nil {
log.Fatalf("Error serving: %s", err)
}
}
HTTP RPC client using golang net/rpc package
http-rpc/client/main.go
package main
import (
"log"
"net/rpc"
. "rpc-golang/http-rpc"
)
func main() {
client, err := rpc.DialHTTP("tcp", ":1234")
if err != nil {
log.Fatalf("Error in dialing. %s", err)
}
args := Args{
A: 2,
B: 3,
}
var reply int
err = client.Call("Arith.Multiply", args, &reply)
if err != nil {
log.Fatal("Arith error:", err)
}
log.Printf("%d * %d = %d\n", args.A, args.B, reply)
}
JSON RPC server using gorilla rpc/json
使用 Gorilla 工具包来简化默认的 net/rpc/jsonrpc. Gorilla 工具包与默认包之间的微小差别在于它需要方法签名来接受 * Request 对象作为第一个参数，并将 Args 参数更改为指针 * Args。
在 net/rpc 我们的 Multiply 方法看起来是这样的：
func (t *Arith) Multiply(args Args, result *Result) error
对于 gorilla 而言， Multiply 方法看起来是这样的：
func (t *Arith) Multiply(r *http.Request, args *Args, result *Result) error
接下来，定义服务对象和方法：
json-rpc/arith.go
package json_rpc
import (
"log"
"net/http"
)
type Arith int
type Args struct {
A, B int
}
func (t *Arith) Multiply(r *http.Request, args *Args, result *int) error {
log.Printf("Multiply %d with %d\n", args.A, args.B)
*result = args.A * args.B
return nil
}
json-rpc/server/main.go
package main
import (
"github.com/gorilla/mux"
"github.com/gorilla/rpc"
"github.com/gorilla/rpc/json"
"log"
"net/http"
. "rpc-golang/json-rpc"
)
func main() {
server := rpc.NewServer()
server.RegisterCodec(json.NewCodec(), "application/json")
server.RegisterCodec(json.NewCodec(), "application/json;charset=UTF-8")
arith := new(Arith)
server.RegisterService(arith, "")
r := mux.NewRouter()
r.Handle("/rpc", server)
log.Println("JSON RPC service listen and serving on port 1234")
if err := http.ListenAndServe(":1234", r); err != nil {
log.Fatalf("Error serving: %s", err)
}
}
JSON RPC client using gorilla rpc/json
json-rpc/client/main.go
package main
import (
"bytes"
"github.com/gorilla/rpc/json"
"log"
"net/http"
. "rpc-golang/json-rpc"
)
func checkError(err error) {
if err != nil {
log.Fatalf("%s", err)
}
}
func main() {
url := "http://localhost:1234/rpc"
args := Args{
A: 2,
B: 3,
}
message, err := json.EncodeClientRequest("Arith.Multiply", args)
checkError(err)
resp, err := http.Post(url, "application/json", bytes.NewReader(message))
defer resp.Body.Close()
checkError(err)
reply := new(int)
err = json.DecodeClientResponse(resp.Body, reply)
checkError(err)
log.Printf("%d * %d = %d\n", args.A, args.B, *reply)
}
JSON RPC client using Python
我们可以使用 Python 去调用使用 golang + gorilla 工具包写的 JSON RPC server。
json-rpc/client/main.py
# -*- coding: utf-8 -*-
import requests
"""
JSON RPC client using Python
"""
def rpc_call():
url = 'http://localhost:1234/rpc'
payload = {
'id': 1,
'method': 'Arith.Multiply',
'params': [{'A': 2, 'B': 3}]
}
r = requests.post(url, json=payload)
print r.text
if __name__ == '__main__':
rpc_call()
JSON-RPC 简介
In JSON-RPC all messages sent from server or client are valid JSON objects. Client must send JSON object with following keys:
-
method- Name of method/service -
params- Array of arguments to be passed -
id- Id is usually integer and makes it easier for client to know which request it got response to, if RPC calls are done asynchroneously.
Server may reply with JSON object with following keys:
-
result- Contains return value of method called. It’s null if error ocurred. -
error- If error occurred, this will indicate error code or error message, otherwise it’s null -
id- The id of the request it is responding to.
Example:
Request:
{"method": "Arith.Multiply", "params": [{A: 2, B: 3}], "id": 1}
Response:
{"result": 6, "error": null, "id": 1}
JSON-RPC v2 adds support for batch queries and notifications (calls which don’t require response).
目录结构
代码参考地址：https://github.com/happy-python/rpc-golang