Go语言JSON-RPC 1.0中字符串ID的灵活解析与兼容性处理

type clientResponse struct {
    Result *json.RawMessage `json:"result"`
    Error  interface{}      `json:"error"`
    Id     string           `json:"id"` // 将Id类型改为string
}

httprpc.CallRaw(address, method, &params, &reply, "application/json",
            gjson.EncodeClientRequest, DecodeClientResponse) // 使用自定义的DecodeClientResponse

package main

import "encoding/json"

type ClientResponse struct {
    Result *json.RawMessage `json:"result"`
    Error  interface{}      `json:"error"`
    Id     interface{}      `json:"id"` // Id字段定义为interface{}
}

package main

import (
    "encoding/json"
    "fmt"
    "strconv"
)

// DecodeClientResponse 是一个自定义的解码函数示例
// 它接收原始的响应字节流，并将其解码到 ClientResponse 结构体中
// 同时处理 Id 字段的类型不确定性
func DecodeClientResponse(body []byte, v interface{}) error {
    // 首先将响应体解码到我们定义的 ClientResponse 结构体
    var rawResponse ClientResponse
    if err := json.Unmarshal(body, &rawResponse); err != nil {
        return fmt.Errorf("failed to unmarshal JSON-RPC response: %w", err)
    }

    // 假设 v 是一个指向目标结构体的指针，我们需要将 rawResponse.Result 解码到 v
    if rawResponse.Result != nil {
        if err := json.Unmarshal(*rawResponse.Result, v); err != nil {
            return fmt.Errorf("failed to unmarshal result field: %w", err)
        }
    }

    // 现在处理 Id 字段
    var id uint64 // 假设我们最终希望得到一个 uint64 类型的 id
    if rawResponse.Id != nil {
        switch t := rawResponse.Id.(type) {
        case float64: // JSON数字默认会被解码为 float64
            id = uint64(t)
        case string:
            var err error
            id, err = strconv.ParseUint(t, 10, 64) // 尝试将字符串转换为 uint64
            if err != nil {
                return fmt.Errorf("failed to convert string id '%s' to uint64: %w", t, err)
            }
        case int: // 某些情况下也可能直接解码为 int
            id = uint64(t)
        default:
            return fmt.Errorf("unsupported id type: %T, value: %v", t, t)
        }
    } else {
        // id 字段可能为空，根据业务需求处理
        fmt.Println("Warning: JSON-RPC response id field is nil.")
    }

    // 在这里，id 变量现在包含了经过解析的 uint64 值。
    // 你可以将其存储到某个地方，或者作为函数返回值的一部分。
    // 为了演示，我们打印出来。
    fmt.Printf("Parsed ID: %d\n", id)

    // 如果需要将解析后的 ID 传递给调用者，
    // 可以在目标结构体中添加一个字段来接收它，或者通过其他方式返回。
    // 例如，如果你的目标结构体也有一个 Id 字段，可以这样赋值：
    // if target, ok := v.(*YourTargetStruct); ok {
    //     target.Id = id
    // }

    return nil
}

// 假设这是你的实际业务响应结构体
type MyReply struct {
    Message string `json:"message"`
    Status  string `json:"status"`
    // Id      uint64 // 如果需要，可以在这里接收解析后的 ID
}

func main() {
    // 模拟服务器返回的 JSON 响应
    jsonResponseStr := `{
        "result": {"message": "Hello", "status": "ok"},
        "error": null,
        "id": "345"
    }`
    jsonResponseBytes := []byte(jsonResponseStr)

    var reply MyReply
    err := DecodeClientResponse(jsonResponseBytes, &reply)
    if err != nil {
        fmt.Printf("Error decoding response: %v\n", err)
        return
    }
    fmt.Printf("Decoded Reply: %+v\n", reply)

    // 模拟另一种服务器返回的 JSON 响应，id为数字
    jsonResponseNum := `{
        "result": {"message": "World", "status": "success"},
        "error": null,
        "id": 123
    }`
    jsonResponseBytesNum := []byte(jsonResponseNum)

    var reply2 MyReply
    err = DecodeClientResponse(jsonResponseBytesNum, &reply2)
    if err != nil {
        fmt.Printf("Error decoding response: %v\n", err)
        return
    }
    fmt.Printf("Decoded Reply 2: %+v\n", reply2)
}

// 假设 gjson.EncodeClientRequest 是你的请求编码函数
// 假设 address, method, params, reply 已经定义
// 这里的 DecodeClientResponse 就是上面我们自定义的函数
err := httprpc.CallRaw(address, method, &params, &reply, "application/json",
            gjson.EncodeClientRequest, DecodeClientResponse)
if err != nil {
    // 处理错误
}