Go语言中强制函数参数为指针的策略与设计考量

import (
    "encoding/json"
    "fmt"
    "net"
    "reflect"
)

// ReadMessage 尝试从连接读取消息并反序列化到 returnMessage
func ReadMessage(conn net.Conn, returnMessage interface{}) bool {
    // 模拟从连接读取字节
    messageBytes := []byte(`{"ID": 1, "Content": "Hello"}`) 

    // 关键：json.Unmarshal 需要一个指针来修改其指向的数据
    err := json.Unmarshal(messageBytes, returnMessage)
    if err != nil {
        fmt.Printf("Unmarshal error: %v\n", err)
        return false
    }
    return true
}

type MessageType1 struct {
    ID      int
    Content string
}

func main() {
    // 模拟一个网络连接
    var conn net.Conn 

    // 期望的行为：传入指针，MessageType1实例被修改
    msg1 := MessageType1{}
    fmt.Printf("Before ReadMessage (ptr): %+v\n", msg1)
    ok1 := ReadMessage(conn, &msg1)
    fmt.Printf("After ReadMessage (ptr): ok=%t, msg=%+v\n", ok1, msg1) // msg1 会被填充

    fmt.Println("--------------------")

    // 非期望的行为：传入值，MessageType1实例不会被修改
    msg2 := MessageType1{}
    fmt.Printf("Before ReadMessage (val): %+v\n", msg2)
    ok2 := ReadMessage(conn, msg2) // 这里会编译通过，但msg2不会被修改
    fmt.Printf("After ReadMessage (val): ok=%t, msg=%+v\n", ok2, msg2) // msg2 仍为空
}

import (
    "encoding/json"
    "fmt"
    "net"
    "reflect"
)

// ReadMessageWithPointerCheck 带有运行时指针检查的函数
func ReadMessageWithPointerCheck(conn net.Conn, returnMessage interface{}) bool {
    // 使用反射检查 returnMessage 是否为指针
    if reflect.ValueOf(returnMessage).Kind() != reflect.Ptr {
        fmt.Printf("Error: returnMessage must be a pointer, got %T\n", returnMessage)
        // 可以选择 panic 或者返回 false 并记录错误
        // panic("returnMessage must be a pointer") 
        return false
    }

    // 模拟从连接读取字节
    messageBytes := []byte(`{"ID": 101, "Content": "Hello from Checked Function"}`) 

    err := json.Unmarshal(messageBytes, returnMessage)
    if err != nil {
        fmt.Printf("Unmarshal error: %v\n", err)
        return false
    }
    return true
}

type MessageType2 struct {
    ID      int
    Content string
}

func main() {
    var conn net.Conn 

    fmt.Println("\n--- Using ReadMessageWithPointerCheck ---")

    msgA := MessageType2{}
    fmt.Printf("Before (ptr): %+v\n", msgA)
    okA := ReadMessageWithPointerCheck(conn, &msgA) // 正确：传入指针
    fmt.Printf("After (ptr): ok=%t, msg=%+v\n", okA, msgA)

    fmt.Println("--------------------")

    msgB := MessageType2{}
    fmt.Printf("Before (val): %+v\n", msgB)
    okB := ReadMessageWithPointerCheck(conn, msgB) // 错误：传入值，会被运行时检查捕获
    fmt.Printf("After (val): ok=%t, msg=%+v\n", okB, msgB)
}

// ReadMessageSpecificType 明确要求传入 MessageType3 的指针
func ReadMessageSpecificType(conn net.Conn, returnMessage *MessageType3) bool {
    messageBytes := []byte(`{"ID": 201, "Content": "Specific Type Message"}`) 
    err := json.Unmarshal(messageBytes, returnMessage)
    if err != nil {
        fmt.Printf("Unmarshal error: %v\n", err)
        return false
    }
    return true
}

type MessageType3 struct {
    ID      int
    Content string
}

func main() {
    var conn net.Conn 
    fmt.Println("\n--- Using ReadMessageSpecificType ---")

    msgC := MessageType3{}
    fmt.Printf("Before (ptr): %+v\n", msgC)
    okC := ReadMessageSpecificType(conn, &msgC) // 必须传入指针
    fmt.Printf("After (ptr): ok=%t, msg=%+v\n", okC, msgC)

    // msgD := MessageType3{}
    // okD := ReadMessageSpecificType(conn, msgD) // 编译时报错：cannot use msgD (type MessageType3) as type *MessageType3
}