Go可通过反射模拟动态代理，在方法调用前后插入逻辑，结合接口实现透明代理，并利用反射遍历方法集实现通用调用钩子，适用于日志、监控等场景。
在Go语言中，没有像Java那样的原生动态代理机制，但可以通过反射（reflect包）模拟实现类似功能。虽然Go更倾向于组合和接口而非运行时动态代理，但在某些场景下（如AOP式日志、权限检查、性能监控），通过反射构建动态代理仍具有实用价值。
理解Go反射的基本能力
Go的reflect包允许程序在运行时 inspect 和 manipulate 变量的类型与值。要实现动态代理，核心依赖两个类型：
- reflect.Type：获取对象的类型信息
- reflect.Value：操作对象的实际值
特别是当目标是一个接口或结构体指针时，可通过反射调用其方法，并插入前置或后置逻辑。
使用reflect.Method进行方法拦截
动态代理的关键是“拦截方法调用”。虽然Go不支持直接重写方法，但可以封装原始对象，在调用时通过反射转发请求。
立即学习“go语言免费学习笔记（深入）”；
示例：为任意对象创建代理，在每次方法调用前后打印日志：
func MakeProxy(target interface{}) interface{} {return &DynamicProxy{target: reflect.ValueOf(target)}
}
type DynamicProxy struct {
target reflect.Value
}
func (p *DynamicProxy) Call(methodName string, args ...interface{}) []reflect.Value {
method := p.target.MethodByName(methodName)
if !method.IsValid() {
panic("method not found")
}
in := make([]reflect.Value, len(args))
for i, arg := range args {
in[i] = reflect.ValueOf(arg)
}
fmt.Println("Before calling:", methodName)
results := method.Call(in)
fmt.Println("After calling:", methodName)
return results
}
这种方式将调用过程显式暴露为Call方法，实现了基本的代理控制。
结合接口生成透明代理
为了让代理更“透明”，可以让代理对象实现与目标相同的接口。这需要预先定义接口，并让代理内部持有真实对象。
例如：
type Service interface {DoTask(data string) error
}
type RealService struct{}
func (r *RealService) DoTask(data string) error {
fmt.Println("Processing:", data)
return nil
}
type LoggingProxy struct {
service Service
}
func (p *LoggingProxy) DoTask(data string) error {
fmt.Println("Log: starting task")
err := p.service.DoTask(data)
fmt.Println("Log: task completed")
return err
}
这里虽未直接使用反射调用，但可在构造LoggingProxy时，利用反射验证service是否实现了对应接口，增强灵活性。
高级技巧：自动方法转发
若想对多个方法统一处理，可用反射遍历目标类型的方法集，并自动生成转发逻辑。
注意：这种方法受限于Go的类型系统，无法真正“动态”生成新类型，但可在运行时动态调用。
常见做法是封装一个通用调用器：
func InvokeWithHook(obj interface{}, method string, args []interface{},before, after func()) []reflect.Value {
v := reflect.ValueOf(obj)
m := v.MethodByName(method)
if !m.IsValid() {
panic("method not found")
}
in := make([]reflect.Value, len(args))
for i := range args {
in[i] = reflect.ValueOf(args[i])
}
before()
result := m.Call(in)
after()
return result
}
这样就能在不修改原对象的前提下，实现带钩子的动态调用。
基本上就这些。Go的反射虽不如其他语言灵活，但配合接口和组合，足以实现轻量级动态代理模式。关键在于明确代理边界，避免过度复杂化设计。
