Golang反射如何实现类型别名处理 详解Unwrap方法的调用时机

package main

import (
    "fmt"
    "reflect"
)

type MyString = string // 类型别名
type MyInt int         // 新定义类型

func main() {
    var ms MyString = "hello"
    var mi MyInt = 123

    fmt.Printf("MyString Type: %v, Kind: %v, Name: %v\n", reflect.TypeOf(ms), reflect.TypeOf(ms).Kind(), reflect.TypeOf(ms).Name())
    fmt.Printf("MyInt Type: %v, Kind: %v, Name: %v\n", reflect.TypeOf(mi), reflect.TypeOf(mi).Kind(), reflect.TypeOf(mi).Name())
}

MyString Type: string, Kind: string, Name: MyString
MyInt Type: main.MyInt, Kind: int, Name: MyInt

package main

import (
    "fmt"
    "reflect"
)

type AliasInt = int       // 类型别名
type NewInt int           // 新定义类型
type AliasStruct = struct{} // 结构体别名
type NewStruct struct{}   // 新定义结构体

func main() {
    var ai AliasInt
    var ni NewInt
    var as AliasStruct
    var ns NewStruct

    fmt.Println("--- AliasInt ---")
    t := reflect.TypeOf(ai)
    fmt.Printf("Type: %v, Kind: %v, Name: %v, String: %v\n", t, t.Kind(), t.Name(), t.String())
    fmt.Printf("AssignableTo int: %v\n", t.AssignableTo(reflect.TypeOf(0))) // 别名可以赋值给原类型

    fmt.Println("\n--- NewInt ---")
    t = reflect.TypeOf(ni)
    fmt.Printf("Type: %v, Kind: %v, Name: %v, String: %v\n", t, t.Kind(), t.Name(), t.String())
    fmt.Printf("AssignableTo int: %v\n", t.AssignableTo(reflect.TypeOf(0))) // 新类型不能直接赋值给原类型

    fmt.Println("\n--- AliasStruct ---")
    t = reflect.TypeOf(as)
    fmt.Printf("Type: %v, Kind: %v, Name: %v, String: %v\n", t, t.Kind(), t.Name(), t.String())

    fmt.Println("\n--- NewStruct ---")
    t = reflect.TypeOf(ns)
    fmt.Printf("Type: %v, Kind: %v, Name: %v, String: %v\n", t, t.Kind(), t.Name(), t.String())
}

type Wrapper interface {
    Unwrap() error
}

package main

import (
    "errors"
    "fmt"
    "reflect"
)

// MyCustomError 实现了 Unwrap 方法，包装了一个底层错误
type MyCustomError struct {
    Msg   string
    Cause error
}

func (e *MyCustomError) Error() string {
    return fmt.Sprintf("MyCustomError: %s (caused by: %v)", e.Msg, e.Cause)
}

func (e *MyCustomError) Unwrap() error {
    return e.Cause
}

func main() {
    innerErr := errors.New("something went wrong at database layer")
    wrappedErr := &MyCustomError{Msg: "failed to process request", Cause: innerErr}

    // 1. 使用 errors.Unwrap 是最常见的做法
    fmt.Println("--- Using errors.Unwrap ---")
    unwrapped := errors.Unwrap(wrappedErr)
    if unwrapped != nil {
        fmt.Printf("errors.Unwrap result: %v\n", unwrapped)
    }

    // 2. 使用反射动态检查并调用 Unwrap
    fmt.Println("\n--- Using Reflection for Unwrap ---")
    errVal := reflect.ValueOf(wrappedErr)

    // 确保是接口或指针，可以获取方法
    if errVal.Kind() == reflect.Ptr && !errVal.IsNil() {
        // 尝试获取 Unwrap 方法
        unwrapMethod := errVal.MethodByName("Unwrap")
        if unwrapMethod.IsValid() && unwrapMethod.Type().NumIn() == 0 && unwrapMethod.Type().NumOut() == 1 && unwrapMethod.Type().Out(0) == reflect.TypeOf((*error)(nil)).Elem() {
            // 调用 Unwrap 方法
            results := unwrapMethod.Call([]reflect.Value{})
            if len(results) > 0 && !results[0].IsNil() {
                fmt.Printf("Reflection Unwrap result: %v\n", results[0].Interface().(error))
            } else {
                fmt.Println("Reflection Unwrap returned nil or no result.")
            }
        } else {
            fmt.Println("Type does not have a valid Unwrap() error method via reflection.")
        }
    } else {
        fmt.Println("Value is not a pointer or is nil, cannot check methods.")
    }

    // 尝试一个没有 Unwrap 的错误
    fmt.Println("\n--- Reflection on a simple error ---")
    simpleErr := errors.New("just a simple error")
    errVal = reflect.ValueOf(simpleErr)
    if errVal.Kind() == reflect.Ptr && !errVal.IsNil() { // errors.New 返回的是 *errors.errorString
        unwrapMethod := errVal.MethodByName("Unwrap")
        if unwrapMethod.IsValid() { // 这里会是 false，因为 errors.errorString 没有 Unwrap 方法
            fmt.Println("Found Unwrap method on simple error (should not happen).")
        } else {
            fmt.Println("Simple error does not have an Unwrap method (as expected).")
        }
    } else {
        // 对于 errors.New 返回的非指针值，需要特殊处理，或者直接用接口类型检查
        // 比如：errors.Is(simpleErr, targetErr)
        fmt.Println("Simple error is not a pointer, or nil. Cannot reflect methods directly on non-pointer values.")
        // 更通用的做法是检查接口实现
        if reflect.TypeOf(simpleErr).Implements(reflect.TypeOf((*interface{ Unwrap() error })(nil)).Elem()) {
            fmt.Println("Simple error implements Unwrap (should not happen).")
        } else {
            fmt.Println("Simple error does not implement Unwrap (as expected).")
        }
    }
}