Go语言中指向指针类型 (T) 的接口断言与操作实践

package main

import (
    "encoding/json"
    "fmt"
)

// 定义Marshaler接口
type Marshaler interface {
    Marshal() ([]byte, error)
}

// 定义Unmarshaler接口
type Unmarshaler interface {
    Unmarshal([]byte) error
}

// Foo类型，其方法由*Foo实现
type Foo struct{}

func (f *Foo) Marshal() ([]byte, error) {
    // 示例实现，将*f（Foo的指针）编码为JSON
    return json.Marshal(f)
}

func (f *Foo) Unmarshal(data []byte) error {
    // 示例实现，将JSON数据解码到*f（Foo的指针）
    return json.Unmarshal(data, f)
}

// 假设有一个库函数，接收interface{}
func FromDb(target interface{}) {
    fmt.Printf("FromDb: 接收到的target类型为 %T\n", target)

    // 尝试直接断言为Unmarshaler
    if u, ok := target.(Unmarshaler); ok {
        fmt.Println("FromDb: 成功直接断言为Unmarshaler")
        // ... 使用u进行操作
    } else {
        fmt.Println("FromDb: 直接断言为Unmarshaler失败")
    }
}

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

    fmt.Println("--- 调用 FromDb(ptrPtrF) ---")
    FromDb(ptrPtrF)

    fmt.Println("\n--- 调用 FromDb(ptrF) ---")
    FromDb(ptrF) // 对比：传递 *Foo 时的情况
}

package main

import (
    "encoding/json"
    "fmt"
    "reflect" // 引入reflect包
)

// 定义Marshaler接口
type Marshaler interface {
    Marshal() ([]byte, error)
}

// 定义Unmarshaler接口
type Unmarshaler interface {
    Unmarshal([]byte) error
}

// Foo类型，其方法由*Foo实现
type Foo struct {
    Name string `json:"name"`
}

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

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

// 改进后的FromDb函数，支持对**T进行接口断言
func FromDbReflect(target interface{}) {
    fmt.Printf("FromDbReflect: 接收到的target类型为 %T\n", target)

    val := reflect.ValueOf(target)
    // 目标接口的reflect.Type，用于Implements方法
    unmarshalerType := reflect.TypeOf((*Unmarshaler)(nil)).Elem()

    // 循环解引用直到找到非指针类型或可断言的类型
    for val.Kind() == reflect.Ptr {
        // 检查当前指针指向的类型是否实现了Unmarshaler接口
        // 注意：Implements方法需要Type，所以我们检查val.Type()
        if val.Type().Implements(unmarshalerType) {
            // 如果当前指针类型实现了接口，则可以直接断言
            if u, ok := val.Interface().(Unmarshaler); ok {
                fmt.Printf("FromDbReflect: 成功通过reflect将 %v 断言为Unmarshaler\n", val.Type())
                // 示例：使用接口方法
                data := []byte(`{"name":"Reflected Foo"}`)
                if err := u.Unmarshal(data); err != nil {
                    fmt.Printf("FromDbReflect: Unmarshal error: %v\n", err)
                } else {
                    fmt.Printf("FromDbReflect: Unmarshal successful, Foo.Name: %s\n", u.(*Foo).Name)
                }
                return
            }
        }
        // 继续解引用
        val = val.Elem()
    }

    // 最终的非指针类型或无法继续解引用的类型
    // 再次检查是否实现了接口 (例如，如果传入的是Foo而不是*Foo，且Foo实现了接口)
    if val.Type().Implements(unmarshalerType) {
        if u, ok := val.Addr().Interface().(Unmarshaler); ok { // 需要获取地址才能转换为接口
            fmt.Printf("FromDbReflect: 成功通过reflect将 %v (Addr) 断言为Unmarshaler\n", val.Type())
            data := []byte(`{"name":"Reflected Foo (Addr)"}`)
            if err := u.Unmarshal(data); err != nil {
                fmt.Printf("FromDbReflect: Unmarshal error: %v\n", err)
            } else {
                fmt.Printf("FromDbReflect: Unmarshal successful, Foo.Name: %s\n", u.(*Foo).Name)
            }
            return
        }
    }

    fmt.Printf("FromDbReflect: 无法从 %T 中获取Unmarshaler接口\n", target)
}

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

    fmt.Println("--- 调用 FromDbReflect(ptrPtrF) ---")
    FromDbReflect(ptrPtrF)
    fmt.Printf("原始Foo对象f的Name: %s\n", f.Name) // 验证Unmarshal是否修改了原始对象

    fmt.Println("\n--- 调用 FromDbReflect(ptrF) ---")
    var f2 Foo
    FromDbReflect(&f2)
    fmt.Printf("原始Foo对象f2的Name: %s\n", f2.Name)

    fmt.Println("\n--- 调用 FromDbReflect(f3) (非指针) ---")
    var f3 Foo
    FromDbReflect(f3) // 传入非指针类型，需要特殊处理
    fmt.Printf("原始Foo对象f3的Name: %s\n", f3.Name)
}