Go中“代理+单例”模式通过sync.Once实现线程安全懒汉单例，并用代理函数或DBProxy结构体封装访问逻辑，注入权限校验、限流、日志等控制行为，确保全局唯一实例且对外统一可控。

在 Go 中实现“代理 + 单例”模式，核心目标是：对外提供统一访问入口（代理），内部确保全局仅有一个实例（单例），同时可在此过程中加入访问控制（如权限校验、限流、日志、缓存等）。

单例：用 sync.Once 保证线程安全的唯一初始化

Go 推荐使用 sync.Once 实现懒汉式单例，避免竞态且无需锁整个获取过程。

关键点：

• 实例变量声明为包级私有（小写开头），防止外部直接构造
• 用 once.Do() 包裹初始化逻辑，确保只执行一次
• 返回指针（而非值），避免复制导致状态不一致

示例：

立即学习“go语言免费学习笔记（深入）”；

Golang Google Wire

在 Go 中使用 google/wire 实现编译时依赖注入——wire.NewSet、wire.Build、wire.Bind（接口→实现）、wire.Struct、wire.Value、wire.Interface

下载

type Database struct { /* ... */ }
var (
 instance *Database
 once sync.Once
)
func GetDatabase() *Database {
 once.Do(func() {
  instance = &Database{ /* 初始化 */ }
 })
 return instance
}

代理：封装单例访问，注入控制逻辑

代理不是独立类型，而是对单例访问的“包装函数”或“代理结构体”。它不替代单例，而是在调用前后插入控制行为。

常见做法是定义一个代理函数（或方法），内部调用单例，并在前后做检查或增强：

• 检查调用方是否有权限（例如通过 context.Value 或 token）
• 记录请求日志或耗时
• 添加熔断/限流（如使用 golang.org/x/time/rate）
• 返回结果前做脱敏或转换

示例（带简单访问控制）：

func QueryUser(ctx context.Context, id int) (*User, error) {
 // 访问控制：检查是否登录
 if userID := ctx.Value("user_id"); userID == nil {
  return nil, errors.New("unauthorized")
 }
 // 调用单例实例
 db := GetDatabase()
 return db.FindUser(id)
}

进阶：用结构体代理统一管理行为

当控制逻辑较复杂（如需配置限流器、日志器、重试策略），可定义代理结构体，持有单例引用及控制组件：

type DBProxy struct {
 db *Database
 limiter *rate.Limiter
 logger *log.Logger
}
func NewDBProxy() *DBProxy {
 return &DBProxy{
  db: GetDatabase(), // 复用单例
  limiter: rate.NewLimiter(rate.Every(time.Second), 10),
  logger: log.New(os.Stdout, "[DBProxy] ", 0),
 }
}
func (p *DBProxy) FindUser(id int) (*User, error) {
 if !p.limiter.Allow() {
  p.logger.Println("rate limited")
  return nil, errors.New("too many requests")
 }
 p.logger.Printf("querying user %d", id)
 return p.db.FindUser(id)
}

注意：避免常见陷阱

• 不要导出单例字段（如 var Instance *DB），否则破坏封装性；始终通过函数获取
• 不要在单例初始化中依赖其他未就绪的全局变量（易引发 init 循环）
• 代理层若需状态（如连接池、缓存），应与单例解耦，由代理自身管理
• 在测试中，可通过接口抽象 + 依赖注入替代硬编码单例调用，提升可测性