Golang反射实现通用接口代理函数

package main

import (
    "fmt"
    "reflect"
)

// 通用代理函数：包装一个接口实例，返回一个具有相同方法集的新实例
func MakeProxy(target interface{}) interface{} {
    v := reflect.ValueOf(target)
    t := reflect.TypeOf(target)

    // 创建一个新的结构体类型来承载代理方法
    proxyStruct := reflect.New(reflect.StructOf([]reflect.StructField{})).Elem()
    proxyPtr := reflect.New(proxyStruct.Type())

    // 设置代理的方法集
    proxy := proxyPtr.Elem()
    proxy.Set(reflect.New(v.Type()).Elem())

    // 使用闭包绑定原始值
    rv := v
    typ := t

    // 遍历所有方法
    for i := 0; i < typ.NumMethod(); i++ {
        method := typ.Method(i)
        proxy.Field(0).Set(reflect.MakeFunc(method.Type, func(args []reflect.Value) (results []reflect.Value) {
            fmt.Printf("前置: 调用方法 %s\n", method.Name)

            // 实际调用原方法
            ret := rv.MethodByName(method.Name).Call(args[1:]) // args[0] 是 receiver

            fmt.Printf("后置: 方法 %s 执行完成\n", method.Name)
            return ret
        }))
    }

    return proxy.Interface()
}

type UserService interface {
    GetUser(id int) (string, error)
    SaveUser(name string) error
}

type userService struct{}

func (u *userService) GetUser(id int) (string, error) {
    return fmt.Sprintf("User-%d", id), nil
}

func (u *userService) SaveUser(name string) error {
    fmt.Printf("保存用户: %s\n", name)
    return nil
}

func main() {
    var service UserService = &userService{}

    // 创建代理
    proxy := MakeProxy(service).(UserService)

    // 调用方法观察输出
    name, _ := proxy.GetUser(1001)
    fmt.Println("结果:", name)

    proxy.SaveUser("Alice")
}

func MakeProxy[T any](target T) T {
    // 实现逻辑类似，但返回具体类型 T
    ...
}