代理模式的核心思想是引入一个代理对象，代理对象和被代理的真实业务对象实现相同的接口，客户端只需要和代理对象交互，代理对象在调用真实对象的业务方法前后可以添加额外的控制逻辑，比如权限校验、访问频率限制等，从而实现访问控制的目的。在Golang中，借助接口和结构体嵌入的特性，可以很方便地实现代理模式。
代理模式实现访问控制的核心思路
要实现基于代理模式的访问控制，需要遵循以下几个步骤：
- 定义统一的业务接口，明确需要被代理的核心业务方法
- 实现真实的业务结构体，完成接口中定义的具体业务逻辑
- 实现代理结构体，同样实现业务接口，内部持有真实业务结构体的实例
- 在代理结构体的接口方法中，先执行访问控制逻辑，校验通过后再调用真实结构体的对应方法
Golang代理模式访问控制完整示例
下面以一个简单的文件访问场景为例，真实业务是读取文件内容，代理对象需要校验当前用户是否有读取权限，只有有权限的用户才能执行读取操作。
1. 定义业务接口
首先定义文件操作的统一接口，包含读取文件的方法：
package main
import "fmt"
// 文件操作接口，定义核心业务方法
type FileOperator interface {
ReadFile(filename string) string
}
2. 实现真实业务结构体
实现真实读取文件的结构体，完成实际的文件读取逻辑：
// 真实文件操作结构体，实现FileOperator接口
type RealFileOperator struct{}
// ReadFile 真实读取文件的方法，这里简化为返回固定内容
func (r *RealFileOperator) ReadFile(filename string) string {
return fmt.Sprintf("文件%s的内容：这是测试文件内容", filename)
}
3. 实现代理结构体
代理结构体同样实现FileOperator接口，内部持有真实业务实例，在ReadFile方法中添加权限校验逻辑：
// 文件操作代理结构体，实现访问控制
type FileOperatorProxy struct {
realOperator *RealFileOperator
// 有权限的用户列表
allowedUsers map[string]bool
}
// NewFileOperatorProxy 创建代理实例，初始化有权限的用户
func NewFileOperatorProxy() *FileOperatorProxy {
return &FileOperatorProxy{
realOperator: &RealFileOperator{},
allowedUsers: map[string]bool{
"admin": true,
"user1": true,
},
}
}
// ReadFile 代理的读取文件方法，先校验权限
func (p *FileOperatorProxy) ReadFile(filename string) string {
// 模拟获取当前用户，实际场景可以从上下文获取
currentUser := "admin"
// 访问控制逻辑：校验用户是否有权限
if _, ok := p.allowedUsers[currentUser]; !ok {
return fmt.Sprintf("用户%s没有权限读取文件%s", currentUser, filename)
}
// 权限校验通过，调用真实对象的方法
return p.realOperator.ReadFile(filename)
}
4. 客户端调用测试
客户端只需要和代理对象交互，不需要知道真实业务对象的存在，访问控制逻辑完全由代理处理：
func main() {
// 创建代理对象
proxy := NewFileOperatorProxy()
// 通过代理调用读取文件方法
result := proxy.ReadFile("test.txt")
fmt.Println(result)
}
代理模式访问控制的优势
使用代理模式实现访问控制有以下明显优势：
- 职责分离：访问控制逻辑和真实业务逻辑解耦，真实业务结构体只需要关注核心业务，不需要处理权限相关的逻辑
- 扩展性强：如果需要修改访问控制规则，只需要修改代理结构体的逻辑，不需要改动真实业务代码，符合开闭原则
- 兼容性好：代理和真实对象实现相同接口，客户端调用方式完全不变，对现有代码的影响很小
适用场景
这种实现方式适合以下场景：
- 需要在业务方法执行前后添加统一的访问控制、日志、监控等逻辑
- 真实业务对象不需要暴露给客户端，需要隐藏实现细节
- 不同用户或不同场景需要不同的访问控制策略，可以通过不同的代理实现来适配
需要注意，如果访问控制逻辑非常复杂或者需要动态变更，也可以结合配置中心等方式优化代理的实现，避免代理逻辑过于臃肿。
其他访问控制场景扩展
除了权限校验，代理模式还可以实现其他访问控制相关的逻辑，比如访问频率限制：
package main
import (
"fmt"
"sync"
"time"
)
// 接口定义
type ApiCaller interface {
CallApi(apiPath string) string
}
// 真实API调用结构体
type RealApiCaller struct{}
func (r *RealApiCaller) CallApi(apiPath string) string {
return fmt.Sprintf("调用API%s成功，返回数据", apiPath)
}
// 频率限制代理结构体
type RateLimitProxy struct {
realCaller *RealApiCaller
// 记录每个用户的调用次数
callCount map[string]int
// 锁保证并发安全
mu sync.Mutex
// 限制每分钟最多调用5次
maxCallPerMin int
}
func NewRateLimitProxy() *RateLimitProxy {
return &RateLimitProxy{
realCaller: &RealApiCaller{},
callCount: make(map[string]int),
maxCallPerMin: 5,
}
}
func (p *RateLimitProxy) CallApi(apiPath string) string {
currentUser := "user1"
p.mu.Lock()
defer p.mu.Unlock()
// 模拟每分钟重置计数，实际场景可以用时间窗口实现
now := time.Now().Minute()
key := fmt.Sprintf("%s_%d", currentUser, now)
if p.callCount[key] >= p.maxCallPerMin {
return fmt.Sprintf("用户%s调用频率过高，请稍后再试", currentUser)
}
p.callCount[key]++
return p.realCaller.CallApi(apiPath)
}
这个示例通过代理实现了API调用频率限制，同样不需要修改真实API调用的逻辑，只需要在代理层添加控制规则即可。