Golang反射如何获取函数返回值类型 演示Type().Out()方法的使用场景

package main

import (
    "fmt"
    "reflect"
)

// 定义几个示例函数
func processData(id int, name string) (bool, error) {
    if id < 0 {
        return false, fmt.Errorf("ID不能为负数：%d", id)
    }
    fmt.Printf("处理数据：ID=%d, Name=%s\n", id, name)
    return true, nil
}

func calculateSum(a, b int) int {
    return a + b
}

func sayHello() {
    fmt.Println("Hello, Go Reflection!")
}

func main() {
    // 示例1: 获取 processData 函数的返回值类型
    fmt.Println("--- processData 函数的返回值类型 ---")
    funcType1 := reflect.TypeOf(processData)
    if funcType1.Kind() == reflect.Func {
        fmt.Printf("函数 %q 有 %d 个返回值。\n", funcType1.Name(), funcType1.NumOut())
        for i := 0; i < funcType1.NumOut(); i++ {
            returnType := funcType1.Out(i)
            fmt.Printf("  第 %d 个返回值类型: %v (Kind: %v)\n", i+1, returnType, returnType.Kind())
        }
    } else {
        fmt.Println("processData 不是一个函数类型。")
    }

    fmt.Println("\n--- calculateSum 函数的返回值类型 ---")
    // 示例2: 获取 calculateSum 函数的返回值类型
    funcType2 := reflect.TypeOf(calculateSum)
    if funcType2.Kind() == reflect.Func {
        fmt.Printf("函数 %q 有 %d 个返回值。\n", funcType2.Name(), funcType2.NumOut())
        for i := 0; i < funcType2.NumOut(); i++ {
            returnType := funcType2.Out(i)
            fmt.Printf("  第 %d 个返回值类型: %v (Kind: %v)\n", i+1, returnType, returnType.Kind())
        }
    } else {
        fmt.Println("calculateSum 不是一个函数类型。")
    }

    fmt.Println("\n--- sayHello 函数的返回值类型 ---")
    // 示例3: 获取 sayHello 函数的返回值类型 (无返回值)
    funcType3 := reflect.TypeOf(sayHello)
    if funcType3.Kind() == reflect.Func {
        fmt.Printf("函数 %q 有 %d 个返回值。\n", funcType3.Name(), funcType3.NumOut())
        // 对于无返回值函数，NumOut() 为 0，循环不会执行
        for i := 0; i < funcType3.NumOut(); i++ {
            returnType := funcType3.Out(i)
            fmt.Printf("  第 %d 个返回值类型: %v (Kind: %v)\n", i+1, returnType, returnType.Kind())
        }
    } else {
        fmt.Println("sayHello 不是一个函数类型。")
    }

    fmt.Println("\n--- 尝试获取非函数类型的返回值 ---")
    // 示例4: 尝试对非函数类型使用 Out() 方法 (会引发 panic)
    var myInt int
    intType := reflect.TypeOf(myInt)
    // intType.Out(0) // 这一行如果执行会引发 panic: reflect: Out of non-func type int
    if intType.Kind() != reflect.Func {
        fmt.Printf("%v 类型不是函数，不能直接调用 Out()。\n", intType)
    }
}

package main

import (
    "context"
    "fmt"
    "reflect"
)

// 定义一个通用的事件接口
type Event interface {
    EventType() string
}

// 示例事件结构体
type UserCreatedEvent struct {
    UserID   string
    Username string
}

func (e UserCreatedEvent) EventType() string { return "UserCreated" }

type OrderPlacedEvent struct {
    OrderID string
    Amount  float64
}

func (e OrderPlacedEvent) EventType() string { return "OrderPlaced" }

// 模拟事件处理器注册器
type EventHandlerRegistry struct {
    handlers map[string]reflect.Value // 存储事件类型到处理函数的映射
}

func NewEventHandlerRegistry() *EventHandlerRegistry {
    return &EventHandlerRegistry{
        handlers: make(map[string]reflect.Value),
    }
}

// RegisterHandler 注册事件处理器
// handler 必须是一个函数，签名类似 func(ctx context.Context, event EventType) error
func (r *EventHandlerRegistry) RegisterHandler(handler interface{}) error {
    handlerType := reflect.TypeOf(handler)

    if handlerType.Kind() != reflect.Func {
        return fmt.Errorf("handler 必须是一个函数")
    }
    if handlerType.NumIn() != 2 || handlerType.NumOut() != 1 {
        return fmt.Errorf("handler 函数签名不符合要求: func(ctx context.Context, event EventType) error")
    }

    // 检查第一个参数是否为 context.Context
    if handlerType.In(0) != reflect.TypeOf((*context.Context)(nil)).Elem() {
        return fmt.Errorf("handler 第一个参数必须是 context.Context")
    }

    // 使用 Type().In() 获取第二个参数（事件类型）
    eventType := handlerType.In(1)
    // 使用 Type().Out() 获取返回值类型，并检查是否为 error
    returnType := handlerType.Out(0)

    if returnType != reflect.TypeOf((*error)(nil)).Elem() {
        return fmt.Errorf("handler 返回值必须是 error 类型")
    }

    // 动态创建事件实例，用于获取事件类型名
    if eventType.Kind() != reflect.Struct {
        return fmt.Errorf("handler 第二个参数必须是结构体类型")
    }
    eventInstance := reflect.New(eventType).Interface()
    event, ok := eventInstance.(Event)
    if !ok {
        return fmt.Errorf("handler 第二个参数结构体必须实现 Event 接口")
    }

    r.handlers[event.EventType()] = reflect.ValueOf(handler)
    fmt.Printf("成功注册事件类型 %q 的处理器。\n", event.EventType())
    return nil
}

// DispatchEvent 分发事件
func (r *EventHandlerRegistry) DispatchEvent(ctx context.Context, event Event) error {
    handlerValue, ok := r.handlers[event.EventType()]
    if !ok {
        return fmt.Errorf("未找到事件 %q 的处理器", event.EventType())
    }

    // 准备参数并调用处理函数
    inputs := []reflect.Value{reflect.ValueOf(ctx), reflect.ValueOf(event)}
    results := handlerValue.Call(inputs)

    if len(results) > 0 && !results[0].IsNil() {
        return results[0].Interface().(error)
    }
    return nil
}

// 具体的事件处理器
func handleUserCreated(ctx context.Context, event UserCreatedEvent) error {
    fmt.Printf("[%s] 处理 UserCreated 事件：UserID=%s, Username=%s\n", ctx.Value("trace_id"), event.UserID, event.Username)
    // 模拟处理逻辑，可能返回错误
    if event.UserID == "error_user" {
        return fmt.Errorf("处理用户 %s 失败", event.UserID)
    }
    return nil
}

func handleOrderPlaced(ctx context.Context, event OrderPlacedEvent) error {
    fmt.Printf("[%s] 处理 OrderPlaced 事件：OrderID=%s, Amount=%.2f\n", ctx.Value("trace_id"), event.OrderID, event.Amount)
    return nil
}

func main() {
    registry := NewEventHandlerRegistry()

    // 注册处理器
    _ = registry.RegisterHandler(handleUserCreated)
    _ = registry.RegisterHandler(handleOrderPlaced)

    // 创建上下文
    ctx := context.WithValue(context.Background(), "trace_id", "abc-123")

    // 分发事件
    fmt.Println("\n--- 分发事件 ---")
    userEvent1 := UserCreatedEvent{UserID: "1001", Username: "Alice"}
    err := registry.DispatchEvent(ctx, userEvent1)
    if err != nil {
        fmt.Printf("分发 UserCreatedEvent 失败: %v\n", err)
    }

    userEvent2 := UserCreatedEvent{UserID: "error_user", Username: "Bob"}
    err = registry.DispatchEvent(ctx, userEvent2)
    if err != nil {
        fmt.Printf("分发 UserCreatedEvent 失败: %v\n", err)
    }

    orderEvent := OrderPlacedEvent{OrderID: "ORD-001", Amount: 99.99}
    err = registry.DispatchEvent(ctx, orderEvent)
    if err != nil {
        fmt.Printf("分发 OrderPlacedEvent 失败: %v\n", err)
    }
}