理解Go RPC与Gob：为何无法直接传递匿名函数

package main

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

// TaskArgs 结构体用于承载客户端发来的任务请求
type TaskArgs struct {
    FunctionName string      // 要执行的函数名称
    Data         interface{} // 传递给函数的数据，可以是任何可序列化的类型
}

// TaskResult 结构体用于承载任务执行结果
type TaskResult struct {
    Result interface{} // 函数执行的返回值
    Error  string      // 如果有错误，则包含错误信息
}

// Worker 是RPC服务，包含可被远程调用的方法
type Worker struct{}

// mapFunc 是一个示例映射函数，实际逻辑可能更复杂
func (w *Worker) mapFunc(input []int) []int {
    log.Printf("Executing mapFunc with input: %v", input)
    output := make([]int, len(input))
    for i, v := range input {
        output[i] = v * 2 // 示例：每个元素乘以2
    }
    return output
}

// reduceFunc 是一个示例规约函数
func (w *Worker) reduceFunc(input []int) int {
    log.Printf("Executing reduceFunc with input: %v", input)
    sum := 0
    for _, v := range input {
        sum += v
    }
    return sum // 示例：计算所有元素的和
}

// ExecuteTask 是RPC方法，根据FunctionName调用对应的内部函数
func (w *Worker) ExecuteTask(args *TaskArgs, reply *TaskResult) error {
    log.Printf("Received RPC call for function: %s", args.FunctionName)
    switch args.FunctionName {
    case "mapFunc":
        if input, ok := args.Data.([]int); ok {
            reply.Result = w.mapFunc(input)
        } else {
            reply.Error = "mapFunc expects []int data"
            return fmt.Errorf("invalid data type for mapFunc")
        }
    case "reduceFunc":
        if input, ok := args.Data.([]int); ok {
            reply.Result = w.reduceFunc(input)
        } else {
            reply.Error = "reduceFunc expects []int data"
            return fmt.Errorf("invalid data type for reduceFunc")
        }
    default:
        reply.Error = fmt.Sprintf("unknown function: %s", args.FunctionName)
        return fmt.Errorf("unknown function: %s", args.FunctionName)
    }
    return nil
}

// 启动RPC服务器
func startServer() {
    worker := new(Worker)
    rpc.Register(worker) // 注册RPC服务

    listener, err := net.Listen("tcp", ":1234")
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }
    log.Println("RPC Server listening on :1234")

    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Printf("Failed to accept connection: %v", err)
            continue
        }
        go rpc.ServeConn(conn) // 为每个连接提供RPC服务
    }
}

// 客户端调用示例
func main() {
    go startServer() // 在后台启动服务器
    time.Sleep(time.Second) // 等待服务器启动

    client, err := rpc.Dial("tcp", "localhost:1234")
    if err != nil {
        log.Fatalf("Failed to dial RPC server: %v", err)
    }
    defer client.Close()

    // 示例1: 调用 mapFunc
    mapArgs := TaskArgs{
        FunctionName: "mapFunc",
        Data:         []int{1, 2, 3, 4},
    }
    var mapReply TaskResult
    err = client.Call("Worker.ExecuteTask", mapArgs, &mapReply)
    if err != nil {
        log.Printf("Error calling mapFunc: %v", err)
    } else if mapReply.Error != "" {
        log.Printf("Server error for mapFunc: %s", mapReply.Error)
    } else {
        log.Printf("mapFunc result: %v", mapReply.Result) // 预期: [2 4 6 8]
    }

    // 示例2: 调用 reduceFunc
    reduceArgs := TaskArgs{
        FunctionName: "reduceFunc",
        Data:         []int{10, 20, 30},
    }
    var reduceReply TaskResult
    err = client.Call("Worker.ExecuteTask", reduceArgs, &reduceReply)
    if err != nil {
        log.Printf("Error calling reduceFunc: %v", err)
    } else if reduceReply.Error != "" {
        log.Printf("Server error for reduceFunc: %s", reduceReply.Error)
    } else {
        log.Printf("reduceFunc result: %v", reduceReply.Result) // 预期: 60
    }

    // 示例3: 调用一个不存在的函数
    unknownArgs := TaskArgs{
        FunctionName: "unknownFunc",
        Data:         nil,
    }
    var unknownReply TaskResult
    err = client.Call("Worker.ExecuteTask", unknownArgs, &unknownReply)
    if err != nil {
        log.Printf("Error calling unknownFunc: %v", err)
    } else if unknownReply.Error != "" {
        log.Printf("Server error for unknownFunc: %s", unknownReply.Error) // 预期: unknown function: unknownFunc
    } else {
        log.Printf("unknownFunc result: %v", unknownReply.Result)
    }
}