Go中实现代理模式需定义统一接口（如UserService），真实对象（RealUserService）专注业务逻辑，代理对象通过组合实现相同接口并添加日志、权限等横切逻辑，调用方无感知。
在 Go 中实现代理模式，核心是通过一个代理对象来控制对真实对象的访问，并在访问前后插入自定义逻辑（如日志、权限校验、缓存、重试等）。Go 没有原生的类继承和接口强制实现机制，但凭借接口（interface）和组合（composition），可以简洁、灵活地实现代理模式。
定义统一接口：让真实对象与代理对象可互换
代理模式的前提是“真实对象”和“代理对象”对外提供相同行为。Go 中用接口抽象这一契约：
// 定义业务能力接口（例如：用户服务）
type UserService interface {
GetUser(id int) (*User, error)
CreateUser(name string) (int, error)
}
type User struct {
ID int
Name string
}
只要真实服务和代理都实现 UserService，调用方无需感知差异，符合里氏替换原则。
实现真实对象：专注核心业务逻辑
真实对象只做它该做的事，不掺杂横切关注点：
立即学习“go语言免费学习笔记（深入）”；
Golang Uber Dig
下载
使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等
type RealUserService struct{}
func (r *RealUserService) GetUser(id int) (*User, error) {
// 模拟数据库查询
if id <= 0 {
return nil, fmt.Errorf("invalid id")
}
return &User{ID: id, Name: "Alice"}, nil
}
func (r *RealUserService) CreateUser(name string) (int, error) {
// 模拟创建并返回 ID
return 123, nil
}
实现代理对象：包装真实对象，在方法调用前后织入逻辑
代理结构体持有真实对象引用，并实现相同接口。每个方法中可自由添加前置（如鉴权、日志）、后置（如审计、缓存写入）或异常处理逻辑：
type UserServiceProxy struct {
realService UserService
logger *log.Logger
}
func NewUserServiceProxy(real UserService, logger *log.Logger) *UserServiceProxy {
return &UserServiceProxy{
realService: real,
logger: logger,
}
}
func (p *UserServiceProxy) GetUser(id int) (*User, error) {
p.logger.Printf("[BEFORE] GetUser called with id=%d", id)
user, err := p.realService.GetUser(id) // 调用真实对象
if err != nil {
p.logger.Printf("[AFTER-ERROR] GetUser failed: %v", err)
return nil, err
}
p.logger.Printf("[AFTER] GetUser succeeded, found user: %+v", user)
return user, nil
}
func (p *UserServiceProxy) CreateUser(name string) (int, error) {
p.logger.Printf("[BEFORE] CreateUser called with name=%q", name)
id, err := p.realService.CreateUser(name)
if err == nil {
p.logger.Printf("[AFTER] CreateUser succeeded, assigned ID=%d", id)
} else {
p.logger.Printf("[AFTER-ERROR] CreateUser failed: %v", err)
}
return id, err
}
关键点：
- 代理不修改真实逻辑，仅“包裹”调用流程
- 前置/后置逻辑与业务解耦，便于复用（比如提取为通用装饰器函数）
- 错误路径也需覆盖，避免遗漏可观测性
使用方式：透明替换，零侵入接入
客户端代码完全不用改，只需把真实对象换成代理实例：
func main() {
real := &RealUserService{}
logger := log.New(os.Stdout, "[PROXY] ", log.LstdFlags)
proxy := NewUserServiceProxy(real, logger)
// 调用方无感知 —— 仍用 UserService 接口
user, _ := proxy.GetUser(42)
fmt.Printf("Retrieved: %+v\n", user)
id, _ := proxy.CreateUser("Bob")
fmt.Printf("Created with ID: %d\n", id)
}
输出示例：
[PROXY] [BEFORE] GetUser called with id=42
[PROXY] [AFTER] GetUser succeeded, found user: &{ID:42 Name:Alice}
Retrieved: &{ID:42 Name:Alice}
[PROXY] [BEFORE] CreateUser called with name="Bob"
[PROXY] [AFTER] CreateUser succeeded, assigned ID=123
Created with ID: 123
不复杂但容易忽略
