Go通用拦截器核心是运行时识别方法签名、动态调用与统一处理，需满足导出方法、指针接收者，并用reflect.Value.MethodByName安全调用，配合Call执行、panic捕获及日志/耗时/错误包装。
用 Go 反射写通用拦截器，核心不是“硬编码类型”，而是“在运行时识别方法签名 + 动态调用 + 统一处理逻辑”。关键在于绕过编译期类型约束，让一个拦截器能适配任意结构体的方法。
拦截目标：必须是导出方法 + 接收者为指针
Go 反射只能操作导出（首字母大写）的字段和方法；且要修改原对象状态，接收者必须是指针类型。否则 reflect.Value.Call 会 panic。
- ✅ 正确：
func (u *User) UpdateName(name string) error - ❌ 无效：
func (u User) UpdateName(name string) error（值接收者无法被反射修改） - ❌ 不可见：
func (u *User) updateName(name string)（小写方法不可反射访问）
用 reflect.Value.MethodByName 定位并安全调用
不拼函数名、不写 switch，直接通过字符串找方法。配合 reflect.Value.Call 执行，并捕获 panic 或返回值做统一处理。
- 先用
reflect.ValueOf(obj).MethodByName("MethodName")获取可调用值 - 构造参数切片：
[]reflect.Value{reflect.ValueOf("alice"), reflect.Value.Of(123)} - 调用：
method.Call(args)，返回[]reflect.Value（含返回值） - 检查是否 panic：
if len(results) > 0 && !results[0].IsNil()（假设第一个返回值是 error）
通用拦截逻辑：日志 + 耗时 + 错误统一包装
把重复代码抽成函数，传入目标对象、方法名、参数，返回结果和 error。例如：
立即学习“go语言免费学习笔记（深入）”；
func Intercept(obj interface{}, method string, args ...interface{}) (result []interface{}, err error) {
v := reflect.ValueOf(obj)
if v.Kind() != reflect.Ptr {
return nil, errors.New("obj must be pointer")
}
m := v.MethodByName(method)
if !m.IsValid() {
return nil, fmt.Errorf("method %s not found", method)
}
in := make([]reflect.Value, len(args))
for i, arg := range args {
in[i] = reflect.ValueOf(arg)
}
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("panic: %v", r)
}
}()
start := time.Now()
results := m.Call(in)
cost := time.Since(start)
// 统一日志
log.Printf("[INTERCEPT] %s.%s(%v) => %v, cost=%v",
reflect.TypeOf(obj).Elem().Name(), method, args, results, cost)
// 提取 error（假设最后一个返回值是 error）
if len(results) > 0 {
if e := results[len(results)-1]; e.Kind() == reflect.Interface && !e.IsNil() {
err = e.Interface().(error)
}
}
// 转回 interface{} 切片
result = make([]interface{}, len(results)-1)
for i, r := range results[:len(results)-1] {
result[i] = r.Interface()
}
return
}
进阶：结合 interface{} 和泛型（Go 1.18+）更安全
纯反射易出错，推荐用泛型约束 + 少量反射兜底。例如定义拦截器接口：
type Interceptor[T any] interface { Before(*T, string, []any) error; After(*T, string, []any, []any, error) }- 主逻辑用泛型保证类型安全，仅在调用具体方法时用反射（如
reflect.ValueOf(t).MethodByName(name)） - 这样既保留编译期检查，又不失灵活性
基本上就这些。反射不是银弹，但对通用拦截这类“类型不确定但结构一致”的场景，它是最直接的解法。别怕 reflect.Value，只要守住指针、导出、参数匹配这三条线，就能稳住。
