首页 > Golang > Go教程

Golang代理模式实现访问控制与扩展

时间：2026-01-06 19:05:36 247浏览收藏

欢迎各位小伙伴来到golang学习网，相聚于此都是缘哈哈哈！今天我给大家带来《Golang代理模式实现访问控制与逻辑扩展》，这篇文章主要讲到等等知识，如果你对Golang相关的知识非常感兴趣或者正在自学，都可以关注我，我会持续更新相关文章！当然，有什么建议也欢迎在评论留言提出！一起学习！

Go中实现代理模式需定义统一接口（如UserService），真实对象（RealUserService）专注业务逻辑，代理对象通过组合实现相同接口并添加日志、权限等横切逻辑，调用方无感知。

如何使用Golang实现代理模式控制访问_在访问前后加入处理逻辑

在 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，调用方无需感知差异，符合里氏替换原则。

实现真实对象：专注核心业务逻辑

真实对象只做它该做的事，不掺杂横切关注点：

type RealUserService struct{}

func (r *RealUserService) GetUser(id int) (*User, error) {
    // 模拟数据库查询
    if id

实现代理对象：包装真实对象，在方法调用前后织入逻辑

代理结构体持有真实对象引用，并实现相同接口。每个方法中可自由添加前置（如鉴权、日志）、后置（如审计、缓存写入）或异常处理逻辑：

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

不复杂但容易忽略

终于介绍完啦！小伙伴们，这篇关于《Golang代理模式实现访问控制与扩展》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！

前往漫画官网入口并下载 ➜