Java

json-rpc

2017-08-25  本文已影响971人  juniway

json-rpc 是 rpc 通信过程中定义的一套 json 格式标准，最早是 json-rpc1.0，最新是 json-rpc2.0。

使用 json 格式来通信，通信的双方 client，server 必须约定好统一的字段，以便彼此能互相解析，这就是 json-rpc 标准的来由。

根据 json-rpc 1.0 约定，Request 和 Response 的格式必须符合如下要求：

（1）Request
（2）Response

例子：
request：data sent to service

{ "method": "echo", "params": ["Hello JSON-RPC"], "id": 1}

response：data coming from service

{ "result": "Hello JSON-RPC", "error": null, "id": 1}

json-rpc2.0

（1）Request
（2）Response
Notification

A Notification is a Request object without an "id" member. A Request object that is a Notification signifies the Client's lack of interest in the corresponding Response object, and as such no Response object needs to be returned to the client.
The Server MUST NOT reply to a Notification, including those that are within a batch request.

例子：
request：data sent to service

{"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": 1}

response：data coming from service

{"jsonrpc": "2.0", "result": 19, "id": 1}

a notification request

{"jsonrpc": "2.0", "method": "update", "params": [1,2,3,4,5]}

a notification response

{"jsonrpc": "2.0", "method": "foobar"}

json-rpc1.0 VS json-rpc2.0

Go官方库实现了JSON-RPC 1.0。JSON-RPC是一个通过JSON格式进行消息传输的RPC规范，因此可以进行跨语言的调用。

源文件：rpc/jsonrpc/client.go

type clientRequest struct {
    Method string         `json:"method"`
    Params [1]interface{} `json:"params"`
    Id     uint64         `json:"id"`
}

func (c *clientCodec) WriteRequest(r *rpc.Request, param interface{}) error {
    c.mutex.Lock()
    c.pending[r.Seq] = r.ServiceMethod
    c.mutex.Unlock()
    c.req.Method = r.ServiceMethod
    c.req.Params[0] = param
    c.req.Id = r.Seq
    return c.enc.Encode(&c.req)
}

上面的 enc 就是 json.Encoder()，可见 WriteRequest() 函数最终把请求 encode 成 json 格式发送了。

调用流程分析：

func CallRpcService(c *rpc.Client) {
    args := &server.Args{7, 8}
    var reply int
    err := c.Call("Arith.Mult", args, &reply)
    if err != nil {
        log.Fatal("Arith error: ", err)
    }
    fmt.Printf("Arith: %d*%d= %d\n", args.A, args.B, reply)
}

这里是调用的 c.Call("Arith.Mult", args, &reply") 来实现发送 json-rpc request 到服务器的。
Call() 函数内部的调用过程如下：
源文件：rpc/client.go

// (1)
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
}

// (2)
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
    ...
    client.send(call)
    return call
}

// (3)
func (client *Client) send(call *Call) {
    ...
    // Encode and send the request.
    client.request.Seq = seq
    client.request.ServiceMethod = call.ServiceMethod
    err := client.codec.WriteRequest(&client.request, call.Args)
    ...
}

源文件：rpc/jsonrpc/client.go

// (4)
func (c *clientCodec) WriteRequest(r *rpc.Request, param interface{}) error {
    c.mutex.Lock()
    c.pending[r.Seq] = r.ServiceMethod
    c.mutex.Unlock()
    c.req.Method = r.ServiceMethod
    c.req.Params[0] = param
    c.req.Id = r.Seq
    return c.enc.Encode(&c.req)
}

Go 的 net/rpc/jsonrpc 库可以将 JSON-RPC 的请求转换成自己内部的格式，比如 request header 的处理：

func (c *serverCodec) ReadRequestHeader(r *rpc.Request) error {
    c.req.reset()
    if err := c.dec.Decode(&c.req); err != nil {
        return err
    }
    r.ServiceMethod = c.req.Method
    c.mutex.Lock()
    c.seq++
    c.pending[c.seq] = c.req.Id
    c.req.Id = nil
    r.Seq = c.seq
    c.mutex.Unlock()
    return nil
}

Go 语言官方库目前不支持 JSON-RPC 2.0 ，但是有第三方开发者提供了实现，比如:
https://github.com/powerman/rpc-codec
https://github.com/dwlnetnl/generpc

一些其它的 codec 如 bsonrpc、messagepack、protobuf 等。
如果你使用其它特定的序列化框架，你可以参照这些实现来写一个你自己的 rpc codec。
关于 Go 序列化库的性能的比较可以参考 gosercomp。

注意：
Go 语言提供的 jsonrpc 包不支持 json-rpc over HTTP，因此我们不能通过 curl 命令来给 Server 发送请求来测试。如果我们真的需要用 http 请求来测试的话，那么我们就应该提供一个 HTTP Hanlder 来处理 HTTP request/response，然后把他适配到 ServerCodec 函数中去，比如：

package main

import (
    "io"
    "log"
    "net"
    "net/http"
    "net/rpc"
    "net/rpc/jsonrpc"
    "os"
)

const addr = "localhost:8080"

type HttpConn struct {
    in  io.Reader
    out io.Writer
}

func (c *HttpConn) Read(p []byte) (n int, err error)  { return c.in.Read(p) }
func (c *HttpConn) Write(d []byte) (n int, err error) { return c.out.Write(d) }
func (c *HttpConn) Close() error                      { return nil }

// RPC Api structure
type Test struct{}

// Greet method arguments
type GreetArgs struct {
    Name string
}

// Grret message accept object with single param Name
func (test *Test) Greet(args *GreetArgs, result *string) error {
    *result = "Hello " + args.Name
    return nil
}

// Start server with Test instance as a service
func startServer() {
    test := new(Test)

    server := rpc.NewServer()
    server.Register(test)

    listener, err := net.Listen("tcp", addr)
    if err != nil {
        log.Fatal("listen error:", err)
    }
    defer listener.Close()
    
    http.Serve(listener, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path == "/test" {
            serverCodec := jsonrpc.NewServerCodec(&HttpConn{in: r.Body, out: w})
            w.Header().Set("Content-type", "application/json")
            w.WriteHeader(200)
            err := server.ServeRequest(serverCodec)
            if err != nil {
                log.Printf("Error while serving JSON request: %v", err)
                http.Error(w, "Error while serving JSON request, details have been logged.", 500)
                return
            }
        }
    }))
}

func main() {
    startServer()
}

现在，我们就可以用 curl 命令来测试了，比如：

$ curl -X POST -H "Content-Type: application/json" -d '{"id": 1, "method": "Test.Greet", "params": [{"name":"world"}]}' http://localhost:8080/test

网上也有 json-rpc over http 的第三方开源库，比如 gorilla/rpc

使用 gorrlla/rpc 的实例：
https://haisum.github.io/2015/10/13/rpc-jsonrpc-gorilla-example-in-golang/

参考:
http://www.simple-is-better.org/rpc/#differences-between-1-0-and-2-0

上一篇下一篇

猜你喜欢

热点阅读