> 没有什么问题是加一层代理层不能解决的，如果有，那就再加一层
# 前言
代理模式（Proxy Pattern）是一种**结构型设计模式**，它为我们提供了一个对象的**替身或占位符**，以控制对这个原始对象的访问。

举个例子

我们在工作中需要一个重要的合作伙伴（服务对象）来完成某项任务。但直接联系他可能不太方便——他可能很忙，或者我们需要在联系他之前做一些准备工作（比如检查权限、记录日志）。

这时，一位能干的“助理”（代理对象）就非常有用。这位助理对外提供和合作伙伴完全相同的服务接口，所有请求都先经过他。

他可以在将请求转交给合作伙伴**之前或之后**，执行一些额外的控制逻辑，例如权限验证、请求缓存或日志记录，而合作伙伴（服务对象）和请求方（客户端）都无需知晓这些细节。

这就是代理模式的核心思想：**通过一个中间层，在不改变原始对象的前提下，增强或控制对它的访问**。
![代理设计模式比喻图.png](https://developer.qcloudimg.com/http-save/yehe-1367556/a8d37036f76d94385716f199cc40286c.png)
# 问题
1. **对象创建开销巨大**：有些服务对象（例如连接数据库、加载大文件）初始化非常耗时耗资源。如果这个对象并非每次都会用到，在程序启动时就初始化它，会造成不必要的资源浪费和启动延迟。
2. **需要控制访问权限**：某些对象包含敏感操作或数据，我们希望对谁能访问、在什么条件下访问进行精细控制。如果让客户端直接访问，安全逻辑就会分散在代码各处，难以维护。
3. **对象位于远程服务器**：当服务对象运行在另一个地址空间（如远程服务器、另一个进程）时，客户端需要处理复杂的网络通信、数据序列化等问题，这会使核心业务代码变得臃肿。
4. **需要添加额外功能**：我们想在访问一个对象时，自动记录日志、监控性能、缓存结果或进行延迟初始化。如果直接修改服务对象，就违反了“开闭原则”，并且可能让这个类的职责变得不单一。

这些问题都有一个共同点：**我们希望在访问一个对象时，插入一些额外的控制层或功能层，但又不想（或不能）直接修改这个对象本身**。

# 解决方案
代理模式提出了一个优雅的解决方案：**引入一个代理类，让它充当服务对象的“中介”或“门卫”**。

这个代理类实现了与服务对象相同的接口，因此客户端可以“无感”地将代理当作真实对象来使用。当客户端通过代理调用方法时，代理并不会立即将请求转发给真实对象，而是可以：
- 在转发前，进行一些预处理（如检查缓存、验证权限）。
- 将请求转发给真实对象。
- 在转发后，进行一些后处理（如记录日志、清理资源）。
![Gemini_Generated_Image_otwdc5otwdc5otwd.png](https://developer.qcloudimg.com/http-save/yehe-1367556/d5a290a8e8d5eebcb318924d08b37929.png)
# 使用场景
1. **延迟初始化（虚拟代理）**：当一个重量级对象（如高清图片、复杂文档）的使用频率不高时，可以用代理来推迟其创建过程，直到真正需要时才实例化，从而提升应用启动速度。

2. **访问控制（保护代理）**：当你需要根据不同权限控制对核心对象的访问时。例如，代理可以检查客户端凭证，只有管理员才能调用删除方法。

3. **本地执行远程服务（远程代理）**：当服务对象位于远程服务器时（如远程API、数据库），代理可以处理所有网络通信的复杂性（序列化、发送请求、处理响应），让客户端像调用本地对象一样简单。

4. **记录日志请求（日志记录代理）**：代理可以记录每个方法调用的参数、结果和执行时间，用于调试或审计，而无需修改业务代码。

5. **缓存请求结果（缓存代理）**：对于耗时且结果不常变化的操作（如复杂的数据库查询），代理可以将结果缓存起来。对于相同的后续请求，直接返回缓存结果，大幅提升性能。

6. **智能引用**：代理可以在没有客户端使用某个重量级对象时，自动将其销毁以释放资源；或者跟踪对象被修改的次数，实现写时复制（Copy-on-Write）等高级功能。

# 实现步骤
![代理设计模式图解.png](https://developer.qcloudimg.com/http-save/yehe-1367556/5fbfbd0ffcb5c64cd492e29ee1e1efd9.png)
以Go语言为例，实现一个简单的缓存代理。假设我们有一个视频库接口，获取视频信息是一个耗时的操作。
1. **定义服务接口**：这是代理和真实服务都必须遵守的契约。
```
// thirdPartyTVLib.go - 服务接口
package main

type ThirdPartyTVLib interface {
    GetVideoInfo(id int) string
}
```

2. **创建真实服务**：实现核心业务逻辑。
```
// thirdPartyTVClass.go - 真实服务
package main

type ThirdPartyTVClass struct{}

func (t *ThirdPartyTVClass) GetVideoInfo(id int) string {
    // 模拟一个耗时的网络请求
    // fmt.Println("从远程服务器获取视频信息，ID:", id)
    return fmt.Sprintf("视频 %d 的详细信息", id)
}
```
3. **创建代理类**：代理也实现相同的接口，并持有对真实服务的引用。
```
// cachedTVClass.go - 代理（缓存代理）
package main

type CachedTVClass struct {
    service ThirdPartyTVLib      // 持有真实服务的引用
    cache   map[int]string       // 本地缓存
}

func NewCachedTVClass(service ThirdPartyTVLib) *CachedTVClass {
    return &CachedTVClass{
        service: service,
        cache:   make(map[int]string),
    }
}

func (c *CachedTVClass) GetVideoInfo(id int) string {
    // 1. 先检查缓存
    if info, ok := c.cache[id]; ok {
        fmt.Printf("【代理】从缓存返回视频 %d 的信息\n", id)
        return info
    }
    // 2. 缓存未命中，调用真实服务
    fmt.Printf("【代理】缓存未命中，请求真实服务获取视频 %d 的信息\n", id)
    info := c.service.GetVideoInfo(id)
    // 3. 将结果存入缓存
    c.cache[id] = info
    return info
}
```

4. **客户端代码**：客户端通过接口与对象交互，无需关心背后是代理还是真实服务。
```
// main.go - 客户端
package main

func main() {
    // 创建真实服务
    realService := &ThirdPartyTVClass{}
    
    // 创建代理，并将真实服务注入
    proxy := NewCachedTVClass(realService)
    
    // 客户端通过代理访问服务
    fmt.Println("第一次请求视频 101:")
    fmt.Println(proxy.GetVideoInfo(101)) // 会调用真实服务并缓存
    
    fmt.Println("\n第二次请求视频 101:")
    fmt.Println(proxy.GetVideoInfo(101)) // 直接从缓存返回
    
    fmt.Println("\n请求视频 202:")
    fmt.Println(proxy.GetVideoInfo(202)) // 缓存未命中，再次调用真实服务
}
```
# 优缺点
## **优点：**
- **职责清晰，符合单一职责原则**：你可以在不修改服务或客户端的情况下，通过代理增加新功能（如缓存、安全控制），使得服务类可以专注于核心业务逻辑。
- **开闭原则**：你可以引入新的代理而不改变现有代码。
- **服务对象的生命周期可控**：代理可以管理重量级服务对象的创建和销毁，例如实现延迟初始化或资源自动回收。
- **本地透明性**：无论服务对象是本地还是远程，对客户端来说接口都是一致的，简化了客户端代码。
## **缺点：**
- **可能增加响应延迟**：由于代理增加了中间层，可能会引入额外的处理时间，特别是在代理逻辑复杂时。
- **使代码结构复杂化**：需要引入额外的类和接口，对于简单场景可能显得有些“杀鸡用牛刀”。
- **服务响应可能变慢**：如果代理是远程代理，网络通信本身就会带来延迟。
# 总结

通过引入这一间接层，我们实现了**关注点分离**：服务对象可以纯粹地关注业务，而将安全、缓存、日志、生命周期管理等“横切关注点”交给代理来处理。

当你在代码中发现需要对某个对象的访问进行增强或限制时，不妨考虑引入一个代理。

代理模式（Proxy Pattern）是一种结构型设计模式，它为我们提供了一个对象的替身或占位符，以控制对这个原始对象的访问。

代理设计模式-使用go语言实现

十倍工程师

编程语言

架构设计

后端

代理模式是一种结构型设计模式，通过中间层控制对原始对象的访问，实现延迟初始化、权限控制、远程调用等功能。它遵循开闭原则，能有效分离核心业务与横切关注点，提升代码可维护性。适用于缓存、日志、安全等场景，但可能增加系统复杂度。

数据库

服务器

4核4G3M云服务器 新用户低至38元/年！

2026新春采购季

tencentdb-catalog

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

代理设计模式-使用go语言实现-腾讯云开发者社区-腾讯云

代理设计模式-使用go语言实现

代理设计模式-使用go语言实现

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐