Go语言中处理双重指针类型与接口的挑战与技巧

type Foo struct{}

// 编译错误：invalid receiver type **Foo (*Foo is an unnamed type)
// func (f **Foo) Unmarshal(data []byte) error {
//     return json.Unmarshal(data, f)
// }

type FooPtr *Foo

// 编译错误：invalid receiver type FooPtr (FooPtr is a pointer type)
// func (f *FooPtr) Unmarshal(data []byte) error {
//     return json.Unmarshal(data, f)
// }

type Unmarshaler interface {
    Unmarshal([]byte) error
}

type Foo struct{}

func (f *Foo) Unmarshal(data []byte) error {
    // ... implementation ...
    return nil
}

// 假设 target 变量持有 **main.Foo
// x := target.(Unmarshaler) // panic: interface conversion: **main.Foo is not main.Unmarshaler: missing method Unmarshal
// x := target.(*Unmarshaler) // panic: interface conversion: interface is **main.Foo, not *main.Unmarshaler

package main

import "fmt"

// P 是一个命名指针类型，指向 int
type P *int

// W 是一个包装结构体，它包含一个类型为 P 的字段
type W struct{ p P }

// foo 方法定义在 *W 类型上
func (w *W) foo() {
    // 通过 w.p 访问底层 *int。Go编译器会自动解引用 *w
    // 实际上是 (*w).p
    fmt.Println(*w.p)
}

func main() {
    // 创建一个 *int 类型的变量 p，并赋值 42
    var p P = new(int)
    *p = 42

    // 创建一个 W 结构体实例，并用 p 初始化其 p 字段
    w := W{p}

    // 调用 *W 上的 foo 方法
    w.foo()
}

42

package main

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

type Marshaler interface {
    Marshal() ([]byte, error)
}

type Unmarshaler interface {
    Unmarshal([]byte) error
}

type Foo struct {
    Name string
}

func (f *Foo) Marshal() ([]byte, error) {
    return json.Marshal(f)
}

func (f *Foo) Unmarshal(data []byte) error {
    // 注意：这里需要解引用 f，因为 json.Unmarshal 期望接收一个指针
    // 如果 f 是 *Foo，则 data, f 即可
    // 如果 f 是 **Foo，则 data, *f 即可
    // 但在这里，f 已经是 *Foo，所以直接传 f
    return json.Unmarshal(data, f)
}

// FromDb 模拟一个接收 interface{} 的通用函数
func FromDb(target interface{}) {
    fmt.Printf("Received type in FromDb: %T\n", target) // 打印 **main.Foo

    // 1. 获取 target 的 reflect.Value
    val := reflect.ValueOf(target)

    // 2. 检查类型是否为指针的指针
    if val.Kind() != reflect.Ptr || val.Elem().Kind() != reflect.Ptr {
        fmt.Printf("Error: target is not a pointer to pointer. Actual kind: %v, Elem kind: %v\n", val.Kind(), val.Elem().Kind())
        return
    }

    // 3. 两次解引用以获取到 *Foo 的 reflect.Value
    // val.Elem() 第一次解引用，从 **Foo 得到 *Foo 的 reflect.Value
    ptrToFooValue := val.Elem()

    // 4. 检查是否可以转换为接口
    if !ptrToFooValue.CanInterface() {
        fmt.Println("Error: Cannot convert *Foo's reflect.Value to interface{}")
        return
    }

    // 5. 将 *Foo 的 reflect.Value 转换为 interface{}，然后尝试类型断言
    if unmarshaler, ok := ptrToFooValue.Interface().(Unmarshaler); ok {
        fmt.Println("Successfully asserted to Unmarshaler!")
        // 示例用法：调用 Unmarshal 方法
        data := []byte(`{"Name":"ReflectTest"}`)
        err := unmarshaler.Unmarshal(data)
        if err != nil {
            fmt.Printf("Unmarshal error: %v\n", err)
        } else {
            fmt.Printf("Unmarshal successful. Data applied to underlying struct.\n")
        }
    } else {
        fmt.Println("Failed to assert to Unmarshaler.")
    }
}

func main() {
    var f Foo
    ptrF := &f       // *main.Foo
    ptrPtrF := &ptrF // **main.Foo

    FromDb(ptrPtrF)

    // 验证 Unmarshal 操作是否更新了原始的 Foo 结构体
    fmt.Printf("Final Foo value after FromDb: %+v\n", f) // 应该显示 {Name:ReflectTest}
}

Received type in FromDb: **main.Foo
Successfully asserted to Unmarshaler!
Unmarshal successful. Data applied to underlying struct.
Final Foo value after FromDb: {Name:ReflectTest}