代理模式的核心思想是为某个对象提供一个代理对象，由代理对象控制对原对象的访问，这样可以在访问前后添加额外的处理逻辑，同时不影响原对象的核心功能。在Golang中，代理模式的实现通常依赖接口抽象，让代理对象和原对象实现同一个接口，客户端通过代理对象间接调用原对象的方法。
代理模式的核心角色
一个完整的代理模式实现包含三个核心角色：
- 抽象主题接口：定义目标对象和代理对象共同需要实现的方法，是两者的统一行为规范。
- 真实主题对象：实现抽象主题接口，包含核心的业务逻辑，是被代理的目标对象。
- 代理对象：同样实现抽象主题接口，内部持有真实主题对象的引用，在调用真实对象方法前后可以添加额外的控制逻辑。
Golang静态代理实现示例
静态代理是在编译期就确定代理类和真实类的对应关系，下面以文件访问场景为例，实现权限校验的代理逻辑：只有拥有读权限的用户才能访问文件内容。
首先定义抽象主题接口，规范文件操作的方法：
// 定义文件操作接口，抽象主题
type FileOperator interface {
ReadFile() string
}
接着实现真实主题对象，也就是实际的文件读取逻辑：
// 真实文件操作对象，实现FileOperator接口
type RealFileOperator struct {
fileName string
}
func NewRealFileOperator(name string) *RealFileOperator {
return &RealFileOperator{
fileName: name,
}
}
func (r *RealFileOperator) ReadFile() string {
// 模拟文件读取逻辑
return "这是文件" + r.fileName + "的内容"
}
然后实现代理对象，在读取文件前添加权限校验逻辑：
// 代理对象，实现FileOperator接口，控制文件访问权限
type FileProxy struct {
realOperator FileOperator
hasPermission bool
}
func NewFileProxy(real FileOperator, permission bool) *FileProxy {
return &FileProxy{
realOperator: real,
hasPermission: permission,
}
}
func (p *FileProxy) ReadFile() string {
// 访问前校验权限
if !p.hasPermission {
return "没有访问权限，无法读取文件"
}
// 有权限则调用真实对象的方法
return p.realOperator.ReadFile()
}
最后编写测试代码验证代理效果：
package main
import "fmt"
func main() {
// 创建真实文件操作对象
realOp := NewRealFileOperator("test.txt")
// 创建无权限的代理对象
noPermProxy := NewFileProxy(realOp, false)
fmt.Println("无权限访问结果：", noPermProxy.ReadFile())
// 创建有权限的代理对象
hasPermProxy := NewFileProxy(realOp, true)
fmt.Println("有权限访问结果：", hasPermProxy.ReadFile())
}
运行上述代码，输出结果如下：
无权限访问结果：没有访问权限，无法读取文件 有权限访问结果：这是文件test.txt的内容
动态代理的实现思路
Golang没有像Java那样原生的动态代理机制，但可以通过反射实现类似的效果，在运行时动态生成代理逻辑。动态代理的优势是不需要为每个真实对象都编写对应的代理类，适合需要统一添加通用逻辑的场景，比如所有接口调用都需要添加日志、耗时统计等。
下面通过反射实现一个通用的动态代理工具，支持在方法调用前后添加自定义处理逻辑：
package main
import (
"fmt"
"reflect"
)
// 定义前置处理逻辑类型
type BeforeFunc func(args []reflect.Value)
// 定义后置处理逻辑类型
type AfterFunc func(result []reflect.Value)
// 创建动态代理对象
func CreateProxy(target interface{}, before BeforeFunc, after AfterFunc) interface{} {
targetType := reflect.TypeOf(target)
targetValue := reflect.ValueOf(target)
// 创建代理对象，实现和目标对象相同的接口
proxy := reflect.New(targetType).Elem()
// 遍历目标对象的所有方法，为代理对象实现相同的方法
for i := 0; i < targetType.NumMethod(); i++ {
method := targetType.Method(i)
methodName := method.Name
methodType := method.Type
// 为代理对象绑定方法
proxy.Method(i).Set(reflect.MakeFunc(methodType, func(args []reflect.Value) []reflect.Value {
// 执行前置逻辑
if before != nil {
before(args)
}
// 调用真实对象的方法
results := targetValue.MethodByName(methodName).Call(args)
// 执行后置逻辑
if after != nil {
after(results)
}
return results
}))
}
return proxy.Interface()
}
使用该动态代理工具，我们可以为任意实现了接口的对象添加通用逻辑，比如统计方法执行时间：
package main
import (
"fmt"
"time"
)
// 定义测试接口
type UserService interface {
GetUserInfo(id int) string
}
// 真实实现
type RealUserService struct{}
func (r *RealUserService) GetUserInfo(id int) string {
time.Sleep(time.Millisecond * 100) // 模拟耗时操作
return fmt.Sprintf("用户ID：%d，用户名：张三", id)
}
func main() {
realService := &RealUserService{}
// 定义前置和后置逻辑
before := func(args []reflect.Value) {
fmt.Println("开始调用GetUserInfo方法，参数：", args[0].Int())
}
after := func(result []reflect.Value) {
fmt.Println("GetUserInfo方法调用完成，返回结果：", result[0].String())
}
// 创建动态代理
proxyService := CreateProxy(realService, before, after).(UserService)
// 通过代理调用方法
fmt.Println(proxyService.GetUserInfo(1001))
}
代理模式的使用场景
在Golang开发中，代理模式适合以下场景：
- 需要控制对象的访问权限，比如不同角色有不同的操作权限。
- 需要在方法调用前后添加通用逻辑，比如日志记录、性能统计、事务控制等。
- 实现延迟加载，比如大对象在真正使用时才初始化，减少启动时的资源消耗。
- 远程代理，比如调用远程服务时，代理对象封装网络通信逻辑，对客户端透明。
注意事项
使用代理模式时需要注意，代理对象和真实对象需要实现同一个接口，否则客户端无法通过统一的接口调用。另外，过多的代理层会增加系统的复杂度，建议只在需要额外控制逻辑的场景下使用，不要过度设计。静态代理适合代理类较少的场景，动态代理适合需要统一处理多个对象的场景，开发者可以根据实际需求选择合适的实现方式。