Go语言RPC实现分布式消息通信与确认机制

package main

import (
    "log"
    "net"
    "net/http"
    "net/rpc"
    "time"
)

// Args 定义RPC方法的输入参数结构体
type Args struct {
    A, B int
}

// Arith 是我们的RPC服务类型
type Arith int

// Multiply 是Arith服务的一个方法，用于计算两个整数的乘积
func (t *Arith) Multiply(args *Args, reply *int) error {
    *reply = args.A * args.B
    log.Printf("Received Multiply call: %d * %d = %d", args.A, args.B, *reply)
    return nil
}

func main() {
    // 1. 创建服务实例并注册
    arith := new(Arith)
    rpc.Register(arith) // 注册Arith服务，客户端将通过"Arith.Multiply"调用

    // 2. 注册HTTP处理器，使得RPC可以通过HTTP协议进行通信
    rpc.HandleHTTP()

    // 3. 监听TCP端口
    listener, err := net.Listen("tcp", ":1234")
    if err != nil {
        log.Fatalf("listen error: %v", err)
    }
    log.Println("RPC server listening on :1234")

    // 4. 在goroutine中启动HTTP服务，处理RPC请求
    // http.Serve会阻塞，所以通常在goroutine中运行
    go func() {
        err := http.Serve(listener, nil)
        if err != nil && err != http.ErrServerClosed {
            log.Fatalf("http.Serve error: %v", err)
        }
    }()

    // 保持主goroutine运行，以便服务持续提供
    // 在实际应用中，这里可能是其他业务逻辑或等待信号退出
    select {}
}

package main

import (
    "fmt"
    "log"
    "net/rpc"
    "time"
)

// Args 定义RPC方法的输入参数结构体，需要和服务端保持一致
type Args struct {
    A, B int
}

func main() {
    serverAddress := "127.0.0.1" // 服务端地址

    // 1. 连接到RPC服务端
    // rpc.DialHTTP用于连接通过HTTP协议暴露的RPC服务
    client, err := rpc.DialHTTP("tcp", serverAddress+":1234")
    if err != nil {
        log.Fatalf("dialing error: %v", err)
    }
    defer client.Close() // 确保连接在使用完毕后关闭

    // 2. 准备参数和接收结果的变量
    args := &Args{A: 7, B: 8} // 输入参数
    var reply int             // 接收结果的变量

    // 3. 发起同步RPC调用
    // 第一个参数是服务名.方法名 (例如 "Arith.Multiply")
    // 第二个参数是输入参数 (必须是指针)
    // 第三个参数是接收结果的变量 (必须是指针)
    err = client.Call("Arith.Multiply", args, &reply)
    if err != nil {
        log.Fatalf("Arith.Multiply call error: %v", err)
    }

    fmt.Printf("Arith: %d * %d = %d\n", args.A, args.B, reply)

    // 4. 尝试另一个调用
    args2 := &Args{A: 10, B: 3}
    var reply2 int
    err = client.Call("Arith.Multiply", args2, &reply2)
    if err != nil {
        log.Fatalf("Arith.Multiply call error: %v", err)
    }
    fmt.Printf("Arith: %d * %d = %d\n", args2.A, args2.B, reply2)

    // 5. 异步调用示例 (虽然本例未使用，但rpc支持)
    // replyChan := make(chan *rpc.Call, 1)
    // call := client.Go("Arith.Multiply", args, &reply, replyChan)
    // select {
    // case <-call.Done:
    //     if call.Error != nil {
    //         log.Fatalf("Async call error: %v", call.Error)
    //     }
    //     fmt.Printf("Arith (async): %d * %d = %d\n", args.A, args.B, reply)
    // case <-time.After(5 * time.Second):
    //     log.Println("Async call timed out")
    // }
}