Golang实现JSON-RPC 2.0协议开发指南

JSON-RPC 2.0是一种轻量级的远程过程调用协议，使用JSON作为数据格式。在Golang中，标准库net/rpc/jsonrpc提供了基本的JSON-RPC支持，但功能较为基础。下面我将介绍如何使用更强大的第三方库github.com/gorilla/rpc/v2/jsonrpc来实现JSON-RPC 2.0服务。

安装依赖

首先安装必要的库：

go get github.com/gorilla/rpc/v2
go get github.com/gorilla/rpc/v2/jsonrpc

服务端实现

1. 定义服务方法

package main

import (
	"errors"
	"net/http"
	"log"

	"github.com/gorilla/rpc/v2"
	"github.com/gorilla/rpc/v2/jsonrpc"
)

type Args struct {
	A, B int
}

type Reply struct {
	Result int
}

type ArithService struct{}

func (s *ArithService) Multiply(r *http.Request, args *Args, reply *Reply) error {
	reply.Result = args.A * args.B
	return nil
}

func (s *ArithService) Divide(r *http.Request, args *Args, reply *Reply) error {
	if args.B == 0 {
		return errors.New("divide by zero")
	}
	reply.Result = args.A / args.B
	return nil
}

2. 创建并启动服务

func main() {
	// 创建RPC服务
	s := rpc.NewServer()
	s.RegisterCodec(jsonrpc.NewCodec(), "application/json")
	
	// 注册服务
	arith := new(ArithService)
	s.RegisterService(arith, "")
	
	// 设置HTTP路由
	http.Handle("/rpc", s)
	
	// 启动HTTP服务
	log.Println("Starting JSON-RPC server on localhost:8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

客户端实现

1. 创建客户端

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
)

type Client struct {
	url string
}

func NewClient(url string) *Client {
	return &Client{url: url}
}

func (c *Client) Call(method string, args interface{}, reply interface{}) error {
	// 构造请求体
	request := map[string]interface{}{
		"jsonrpc": "2.0",
		"method":  method,
		"params":  args,
		"id":      1,
	}
	
	// 编码为JSON
	body, err := json.Marshal(request)
	if err != nil {
		return err
	}
	
	// 发送HTTP请求
	resp, err := http.Post(c.url, "application/json", bytes.NewBuffer(body))
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	
	// 读取响应
	data, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	
	// 解析响应
	var response struct {
		Jsonrpc string      `json:"jsonrpc"`
		Result  interface{} `json:"result"`
		Error   interface{} `json:"error"`
		Id      int         `json:"id"`
	}
	
	if err := json.Unmarshal(data, &response); err != nil {
		return err
	}
	
	// 处理错误
	if response.Error != nil {
		return fmt.Errorf("RPC error: %v", response.Error)
	}
	
	// 解码结果
	resultBytes, err := json.Marshal(response.Result)
	if err != nil {
		return err
	}
	
	return json.Unmarshal(resultBytes, reply)
}

2. 使用客户端调用服务

func main() {
	client := NewClient("http://localhost:8080/rpc")
	
	// 乘法调用
	var multiplyReply Reply
	err := client.Call("ArithService.Multiply", &Args{A: 5, B: 6}, &multiplyReply)
	if err != nil {
		fmt.Println("Multiply error:", err)
	} else {
		fmt.Println("Multiply result:", multiplyReply.Result)
	}
	
	// 除法调用
	var divideReply Reply
	err = client.Call("ArithService.Divide", &Args{A: 10, B: 2}, &divideReply)
	if err != nil {
		fmt.Println("Divide error:", err)
	} else {
		fmt.Println("Divide result:", divideReply.Result)
	}
	
	// 错误调用(除零)
	err = client.Call("ArithService.Divide", &Args{A: 10, B: 0}, &divideReply)
	if err != nil {
		fmt.Println("Divide error:", err)
	} else {
		fmt.Println("Divide result:", divideReply.Result)
	}
}

高级特性

1. 批量请求支持

JSON-RPC 2.0支持批量请求，可以一次发送多个方法调用：

func (c *Client) BatchCall(requests []map[string]interface{}) ([]map[string]interface{}, error) {
	body, err := json.Marshal(requests)
	if err != nil {
		return nil, err
	}

	resp, err := http.Post(c.url, "application/json", bytes.NewBuffer(body))
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	data, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	var responses []map[string]interface{}
	if err := json.Unmarshal(data, &responses); err != nil {
		return nil, err
	}

	return responses, nil
}

2. 通知(Notification)支持

JSON-RPC 2.0支持通知(没有返回值的调用)：

func (c *Client) Notify(method string, args interface{}) error {
	request := map[string]interface{}{
		"jsonrpc": "2.0",
		"method":  method,
		"params":  args,
	}
	
	body, err := json.Marshal(request)
	if err != nil {
		return err
	}
	
	_, err = http.Post(c.url, "application/json", bytes.NewBuffer(body))
	return err
}

错误处理

JSON-RPC 2.0定义了标准错误格式：

type RPCError struct {
	Code    int         `json:"code"`
	Message string      `json:"message"`
	Data    interface{} `json:"data,omitempty"`
}

func (e *RPCError) Error() string {
	return fmt.Sprintf("RPC error %d: %s", e.Code, e.Message)
}

// 预定义错误
var (
	ErrParseError     = &RPCError{Code: -32700, Message: "Parse error"}
	ErrInvalidRequest = &RPCError{Code: -32600, Message: "Invalid Request"}
	ErrMethodNotFound = &RPCError{Code: -32601, Message: "Method not found"}
	ErrInvalidParams  = &RPCError{Code: -32602, Message: "Invalid params"}
	ErrInternal      = &RPCError{Code: -32603, Message: "Internal error"}
)

总结

通过gorilla/rpc/jsonrpc库，我们可以方便地实现JSON-RPC 2.0协议的服务端和客户端。主要特点包括：

1. 支持JSON-RPC 2.0规范
2. 易于集成到现有HTTP服务中
3. 支持批量请求和通知
4. 提供了标准的错误处理机制

对于更简单的需求，也可以考虑使用标准库net/rpc/jsonrpc，但它只实现了JSON-RPC 1.0规范，功能较为有限。

在实际项目中，你可能还需要考虑添加认证、限流、日志记录等中间件功能，这些都可以通过包装HTTP处理器来实现。