在go语言中实现对象访问控制的代理模式，主要是通过中间层来间接操作目标对象。这样做的好处是可以在不修改原对象的前提下，增加权限校验、日志记录、缓存等额外逻辑。1. 权限控制：通过定义接口并由代理对象在调用前进行权限判断，限制对敏感方法的访问；2. 延迟加载：代理对象按需创建昂贵资源，节省系统启动时的开销；3. 日志与监控：在调用前后记录行为和性能指标，便于调试和生成监控数据；4. 缓存代理：通过缓存减少重复计算或请求，提升性能但需考虑缓存过期机制。这些代理模式的实现方式均体现了代理层增强对象功能而不改动其逻辑的核心思想，使代码更清晰且职责分明。
在Go语言中实现对象访问控制的代理模式，主要是通过中间层来间接操作目标对象。这样做的好处是可以在不修改原对象的前提下，增加额外逻辑，比如权限校验、日志记录、缓存等。
下面几种典型场景，都是代理模式的常见用法。
1. 权限控制：限制对敏感方法的访问
有些对象的方法只能在特定条件下被调用，例如只有管理员才能删除数据。这时候可以用代理包裹真实对象，在调用前做权限判断。
立即学习“go语言免费学习笔记（深入）”；
实现方式：
- 定义一个接口，包含需要控制的方法
- 真实对象实现该接口
- 代理对象也实现同一接口，内部持有真实对象，并在调用前加判断逻辑
type Resource interface {
Delete(id string) error
}
type RealResource struct{}
func (r *RealResource) Delete(id string) error {
fmt.Println("Deleting resource:", id)
return nil
}
type AuthProxy struct {
real *RealResource
user string
}
func (p *AuthProxy) Delete(id string) error {
if p.user != "admin" {
return fmt.Errorf("access denied")
}
return p.real.Delete(id)
}这样外部访问时使用
AuthProxy而不是
RealResource，就能统一做权限检查。
2. 延迟加载（懒加载）：按需创建昂贵资源
如果某个对象初始化成本很高，比如连接远程服务或加载大文件，可以使用代理先不创建它，直到第一次真正需要时才初始化。
适用情况：
- 初始化耗时较长
- 不一定每次都会用到这个对象
type HeavyObject interface {
Process() string
}
type RealHeavy struct{}
func (r *RealHeavy) Process() string {
time.Sleep(2 * time.Second) // 模拟耗时操作
return "Processed"
}
type LazyProxy struct {
real *RealHeavy
}
func (p *LazyProxy) Process() string {
if p.real == nil {
p.real = &RealHeavy{}
}
return p.real.Process()
}这种方式在系统启动时不会立即加载重型资源，节省了不必要的开销。
3. 日志与监控：记录访问行为和性能指标
有时候我们想统计某个对象被调用了多少次，或者每个方法执行时间，可以通过代理来包装这些行为。
做法：
- 在调用前后打印日志或记录时间戳
- 可以结合 Prometheus 等工具上报指标
type Service interface {
FetchData(id string) string
}
type RealService struct{}
func (s *RealService) FetchData(id string) string {
time.Sleep(500 * time.Millisecond)
return "data for " + id
}
type LoggingProxy struct {
service *RealService
}
func (p *LoggingProxy) FetchData(id string) string {
start := time.Now()
result := p.service.FetchData(id)
elapsed := time.Since(start)
log.Printf("Called FetchData(%q) in %v, result: %q", id, elapsed, result)
return result
}这种代理非常适合用于调试、性能分析或生成监控数据。
4. 缓存代理：减少重复计算或请求
当某个方法频繁被调用且结果可缓存时，可以用代理来做一层缓存处理，避免每次都走真实逻辑。
实现思路：
- 使用 map 或 sync.Map 存储已有的结果
- 每次调用前先查缓存
- 缓存命中则直接返回，未命中再调用真实对象并更新缓存
type CacheProxy struct {
service *RealService
cache map[string]string
}
func (p *CacheProxy) FetchData(id string) string {
if val, ok := p.cache[id]; ok {
return val
}
result := p.service.FetchData(id)
p.cache[id] = result
return result
}注意要根据业务需求考虑缓存过期机制，否则可能导致数据陈旧。
以上几种代理模式的实现方式在Golang中都非常实用。它们的核心思想都是通过“代理”这一层来增强原有对象的功能，而不需要改动其内部逻辑。
基本上就这些，代理模式并不复杂，但在实际项目中很容易被忽略。合理使用代理，可以让代码更清晰、职责更分明。
