Go语言rpc/jsonrpc连接外部服务：认证与协议兼容性深度解析及实践

package main

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

// RPCRequest represents a standard JSON-RPC 1.0 or 2.0 request
type RPCRequest struct {
    JSONRPC string        `json:"jsonrpc,omitempty"` // For JSON-RPC 2.0
    ID      int           `json:"id"`
    Method  string        `json:"method"`
    Params  []interface{} `json:"params"`
}

// RPCResponse represents a standard JSON-RPC 1.0 or 2.0 response
type RPCResponse struct {
    JSONRPC string          `json:"jsonrpc,omitempty"` // For JSON-RPC 2.0
    Result  json.RawMessage `json:"result"`
    Error   *RPCError       `json:"error"`
    ID      int             `json:"id"`
}

// RPCError represents a JSON-RPC error object
type RPCError struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
}

func main() {
    // Bitcoin RPC connection details
    rpcUser := "your_rpc_username" // Replace with your Bitcoin RPC username
    rpcPass := "your_rpc_password" // Replace with your Bitcoin RPC password
    rpcHost := "localhost"
    rpcPort := "8332" // Default Bitcoin RPC port

    // Construct the RPC URL
    rpcURL := fmt.Sprintf("http://%s:%s", rpcHost, rpcPort)

    // Create a JSON-RPC request for "getblockcount"
    request := RPCRequest{
        JSONRPC: "1.0", // Bitcoin Core often uses JSON-RPC 1.0
        ID:      1,
        Method:  "getblockcount",
        Params:  []interface{}{}, // No parameters for getblockcount
    }

    // Marshal the request struct to JSON
    requestBody, err := json.Marshal(request)
    if err != nil {
        fmt.Printf("Error marshaling request: %v\n", err)
        return
    }

    // Create a new HTTP client
    client := &http.Client{
        Timeout: 10 * time.Second, // Set a timeout for the request
    }

    // Create a new HTTP POST request
    req, err := http.NewRequest("POST", rpcURL, bytes.NewBuffer(requestBody))
    if err != nil {
        fmt.Printf("Error creating request: %v\n", err)
        return
    }

    // Add HTTP Basic Authentication header
    auth := rpcUser + ":" + rpcPass
    basicAuth := base64.StdEncoding.EncodeToString([]byte(auth))
    req.Header.Set("Authorization", "Basic "+basicAuth)
    req.Header.Set("Content-Type", "application/json") // Important for JSON-RPC

    // Send the request
    resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("Error sending request: %v\n", err)
        return
    }
    defer resp.Body.Close() // Ensure the response body is closed

    // Read the response body
    responseBody, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Error reading response body: %v\n", err)
        return
    }

    // Check HTTP status code
    if resp.StatusCode != http.StatusOK {
        fmt.Printf("HTTP Error: %s, Response: %s\n", resp.Status, responseBody)
        return
    }

    // Unmarshal the JSON-RPC response
    var rpcResponse RPCResponse
    err = json.Unmarshal(responseBody, &rpcResponse)
    if err != nil {
        fmt.Printf("Error unmarshaling response: %v\n", err)
        return
    }

    // Check for RPC errors
    if rpcResponse.Error != nil {
        fmt.Printf("RPC Error: Code %d, Message: %s\n", rpcResponse.Error.Code, rpcResponse.Error.Message)
        return
    }

    // Process the result
    var blockCount float64 // Bitcoin's getblockcount returns a number
    err = json.Unmarshal(rpcResponse.Result, &blockCount)
    if err != nil {
        fmt.Printf("Error unmarshaling result: %v\n",