代理模式的核心思想是通过一个代理对象来包装真实的目标对象，所有对目标对象的方法调用都先经过代理对象，代理可以在调用前后添加自定义逻辑，从而实现对方法调用的控制。Golang作为一门支持接口和组合特性的语言，实现代理模式的方式和其他面向对象语言有一定区别，主要依托接口定义统一的行为规范。
代理模式的基础实现
首先我们需要定义一个统一的接口，让目标对象和代理对象都实现这个接口，这样调用方就不需要关心具体是调用目标对象还是代理对象的方法。
1. 定义业务接口
假设我们有一个用户服务的业务场景，需要控制用户查询方法的调用，先定义对应的接口：
// UserService 用户服务接口，定义统一的用户查询行为
type UserService interface {
GetUserInfo(userID int) string
}
2. 实现目标对象
目标对象是实际执行业务逻辑的对象，实现上面定义的接口：
// RealUserService 真实用户服务，实现UserService接口
type RealUserService struct{}
// GetUserInfo 真实查询用户信息的逻辑
func (r *RealUserService) GetUserInfo(userID int) string {
// 模拟查询数据库的操作
return fmt.Sprintf("用户ID: %d, 用户名: 测试用户", userID)
}
3. 实现代理对象
代理对象同样实现UserService接口，内部持有真实对象的引用，在调用真实对象方法前后添加控制逻辑：
// UserProxyService 用户服务代理，实现UserService接口
type UserProxyService struct {
realService UserService // 持有真实用户服务的引用
}
// NewUserProxyService 创建代理对象的工厂方法
func NewUserProxyService(real UserService) UserService {
return &UserProxyService{
realService: real,
}
}
// GetUserInfo 代理方法，在真实调用前后添加控制逻辑
func (p *UserProxyService) GetUserInfo(userID int) string {
// 调用前的控制逻辑：比如权限校验、参数校验
fmt.Println("代理前置逻辑：开始校验用户ID合法性")
if userID <= 0 {
return "用户ID不合法"
}
// 调用真实对象的方法
result := p.realService.GetUserInfo(userID)
// 调用后的控制逻辑：比如日志记录、性能统计
fmt.Println("代理后置逻辑：查询用户操作记录完成")
return result
}
4. 调用示例
使用代理对象来控制方法调用的完整示例：
package main
import "fmt"
// 此处省略上面定义的接口、RealUserService、UserProxyService代码
func main() {
// 创建真实用户服务对象
realService := &RealUserService{}
// 创建代理对象，包装真实对象
proxyService := NewUserProxyService(realService)
// 通过代理对象调用方法，会触发代理的控制逻辑
fmt.Println(proxyService.GetUserInfo(1))
fmt.Println(proxyService.GetUserInfo(-1))
}
运行上述代码会输出如下内容，可以看到代理的前置和后置逻辑都被执行了：
代理前置逻辑：开始校验用户ID合法性 代理后置逻辑：查询用户操作记录完成 用户ID: 1, 用户名: 测试用户 代理前置逻辑：开始校验用户ID合法性 用户ID不合法
动态代理的模拟实现
上面的实现是静态代理，每个接口都需要单独写对应的代理类，如果接口方法很多或者接口数量多，会产生大量重复代码。Golang没有原生的动态代理支持，但是可以通过反射来模拟实现通用代理，减少重复代码。
下面是一个通用的动态代理实现示例，支持对任意接口类型的方法调用添加统一的前置和后置逻辑：
package main
import (
"fmt"
"reflect"
)
// ProxyHandler 代理处理逻辑，用户可以自定义前置和后置操作
type ProxyHandler struct {
PreFunc func(args []reflect.Value) // 前置处理函数
PostFunc func(args []reflect.Value, results []reflect.Value) // 后置处理函数
}
// NewDynamicProxy 创建动态代理对象
// target: 真实目标对象，必须是接口类型的实例
// handler: 代理处理逻辑
func NewDynamicProxy(target interface{}, handler ProxyHandler) interface{} {
targetType := reflect.TypeOf(target)
targetValue := reflect.ValueOf(target)
// 创建代理的反射类型，和真实对象类型一致
proxyType := reflect.New(targetType).Elem()
// 遍历真实对象的所有方法，在代理对象中实现这些方法
for i := 0; i < targetType.NumMethod(); i++ {
method := targetType.Method(i)
methodIndex := i
// 为代理对象添加方法实现
proxyType.Method(i).Func = reflect.MakeFunc(method.Type, func(args []reflect.Value) []reflect.Value {
// 执行前置逻辑
if handler.PreFunc != nil {
handler.PreFunc(args)
}
// 调用真实对象的方法，第一个参数是真实对象实例，后面是方法参数
realArgs := make([]reflect.Value, len(args))
realArgs[0] = targetValue
copy(realArgs[1:], args[1:])
results := method.Func.Call(realArgs)
// 执行后置逻辑
if handler.PostFunc != nil {
handler.PostFunc(args, results)
}
return results
})
}
return proxyType.Interface()
}
使用上述动态代理的示例：
// 此处省略UserService接口和RealUserService的实现代码
func main() {
realService := &RealUserService{}
// 定义代理处理逻辑
handler := ProxyHandler{
PreFunc: func(args []reflect.Value) {
fmt.Println("动态代理前置：准备执行用户查询")
userID := args[1].Int()
if userID <= 0 {
fmt.Println("动态代理前置：用户ID不合法，终止调用")
}
},
PostFunc: func(args []reflect.Value, results []reflect.Value) {
fmt.Println("动态代理后置：用户查询执行完成")
},
}
// 创建动态代理对象
proxy := NewDynamicProxy(realService, handler).(UserService)
fmt.Println(proxy.GetUserInfo(2))
fmt.Println(proxy.GetUserInfo(0))
}
实现注意事项
- 代理对象和目标对象必须实现同一个接口，这样调用方才能无感知切换，符合面向接口编程的原则。
- 静态代理适合接口方法少、逻辑简单的场景，动态代理适合接口多、需要统一处理逻辑的场景，但是动态代理使用反射会带来一定的性能损耗，高频调用的场景需要谨慎使用。
- 代理的控制逻辑不要过于复杂，避免影响原有业务逻辑的可读性，如果需要添加非常多的横切逻辑，也可以考虑结合中间件或者AOP的思路来实现。
- 如果目标对象的方法有返回值，代理对象需要正确处理返回值，尤其是错误返回值，不要遗漏返回给调用方。
适用场景
代理模式在Golang中的常见适用场景包括：
- 方法调用权限控制，比如校验调用方是否有执行某个方法的权限。
- 日志记录，在方法调用前后记录调用参数、返回结果、耗时等信息。
- 缓存控制，对频繁调用的方法结果进行缓存，减少重复计算或者数据库查询。
- 远程调用包装，比如把本地接口调用包装成RPC调用，代理对象负责处理网络请求和响应的逻辑。