使用Go语言构建分布式RPC服务：实现跨主机消息通信与确认机制

// server/main.go
package main

import (
    "log"
    "net"
    "net/http"
    "net/rpc"
    "fmt" // 引入fmt包用于打印日志
)

// Args 结构体用于封装RPC方法的输入参数
type Args struct {
    A, B int
}

// Arith 结构体定义了一个算术服务
type Arith int

// Multiply 方法是Arith服务的一个RPC方法，用于计算两个整数的乘积
func (t *Arith) Multiply(args *Args, reply *int) error {
    *reply = args.A * args.B
    fmt.Printf("Server received: %d * %d, sending reply: %d\n", args.A, args.B, *reply) // 服务端日志
    return nil
}

// server/main.go (续)
func main() {
    arith := new(Arith)
    rpc.Register(arith) // 注册Arith服务

    // 使用HTTP协议处理RPC请求
    rpc.HandleHTTP()

    // 监听TCP端口
    port := ":1234"
    l, e := net.Listen("tcp", port)
    if e != nil {
        log.Fatalf("监听错误: %v", e)
    }
    fmt.Printf("RPC服务器正在监听端口 %s...\n", port)

    // 在新的goroutine中启动HTTP服务器，处理RPC请求
    go http.Serve(l, nil)

    // 保持主goroutine运行，或者添加其他逻辑
    select {} // 阻塞主goroutine，使服务器持续运行
}

// client/main.go
package main

import (
    "fmt"
    "log"
    "net/rpc"
    "time" // 引入time包用于模拟重试或等待
)

// Args 结构体与服务端保持一致
type Args struct {
    A, B int
}

func main() {
    serverAddress := "127.0.0.1" // 服务器地址
    port := ":1234"

    // 尝试连接RPC服务器
    client, err := rpc.DialHTTP("tcp", serverAddress+port)
    if err != nil {
        log.Fatalf("连接RPC服务器失败: %v", err)
    }
    defer client.Close() // 确保客户端连接关闭

    fmt.Printf("成功连接到RPC服务器 %s%s\n", serverAddress, port)

    // 定义输入参数
    args := &Args{7, 8}
    var reply int // 定义输出结果变量

    // 发起同步RPC调用
    fmt.Printf("客户端发起调用: Arith.Multiply(%d, %d)\n", args.A, args.B)
    err = client.Call("Arith.Multiply", args, &reply)
    if err != nil {
        log.Fatalf("RPC调用失败: %v", err)
    }

    fmt.Printf("RPC调用成功，结果: %d * %d = %d\n", args.A, args.B, reply)

    // 示例：向多个主机发送消息（模拟）
    // 实际场景中，客户端可能需要维护一个主机列表，并循环连接/调用
    fmt.Println("\n--- 模拟向多个主机发送消息 ---")
    hosts := []string{"127.0.0.1:1234", "127.0.0.1:1235"} // 假设有多个RPC服务器
    for i, host := range hosts {
        fmt.Printf("尝试连接主机 %d: %s\n", i+1, host)
        multiClient, err := rpc.DialHTTP("tcp", host)
        if err != nil {
            fmt.Printf("连接主机 %s 失败: %v\n", host, err)
            continue
        }
        defer multiClient.Close() // 在循环内部defer，确保每次连接都关闭

        multiArgs := &Args{10 + i, 5 + i}
        var multiReply int
        err = multiClient.Call("Arith.Multiply", multiArgs, &multiReply)
        if err != nil {
            fmt.Printf("调用主机 %s 上的 Arith.Multiply 失败: %v\n", host, err)
        } else {
            fmt.Printf("主机 %s 返回结果: %d * %d = %d\n", host, multiArgs.A, multiArgs.B, multiReply)
        }
        time.Sleep(100 * time.Millisecond) // 模拟间隔
    }
}

// 客户端异步调用示例 (可以在client/main.go中添加)
func asyncCallExample(client *rpc.Client) {
    fmt.Println("\n--- 异步RPC调用示例 ---")
    args := &Args{10, 3}
    reply := 0
    call := client.Go("Arith.Multiply", args, &reply, nil) // 最后一个参数为done channel，nil表示使用内部channel

    // 可以在这里执行其他任务，不被RPC调用阻塞
    fmt.Println("异步调用已发起，客户端正在执行其他任务...")
    time.Sleep(500 * time.Millisecond) // 模拟其他任务

    // 等待异步调用完成
    <-call.Done
    if call.Error != nil {
        fmt.Printf("异步RPC调用失败: %v\n", call.Error)
    } else {
        fmt.Printf("异步RPC调用成功，结果: %d * %d = %d\n", args.A, args.B, reply)
    }
}