零基础设计模式——结构型模式

第三部分：结构型模式 - 代理模式 (Proxy Pattern)

在学习了享元模式如何通过共享对象来优化资源使用后，我们来探讨结构型模式的最后一个模式——代理模式。代理模式为另一个对象提供一个替身或占位符以控制对这个对象的访问。

核心思想：为其他对象提供一种代理以控制对这个对象的访问。

代理模式 (Proxy Pattern)

“为其他对象提供一种代理以控制对这个对象的访问。” (Provide a surrogate or placeholder for another object to control access to it.)

想象一下，你想看一张非常大的高清图片，但加载它需要很长时间。或者，你可能需要访问一个远程服务器上的资源，网络延迟很高。或者，你可能需要对某个操作进行权限检查，只有特定用户才能执行。

代理模式通过引入一个代理对象来间接访问真实对象（也称为主题对象或服务对象）。客户端与代理对象交互，代理对象再根据需要与真实对象交互。

真实主题 (Real Subject)：实际执行任务的对象，如大图片加载器、远程服务接口、需要权限的操作。
代理 (Proxy)：控制对真实主题访问的替身。它可以实现与真实主题相同的接口，使得客户端可以无缝切换。

1. 目的 (Intent)

代理模式的主要目的：

控制访问：代理可以控制客户端对真实对象的访问权限、时机或方式。
提供间接层：在客户端和真实对象之间引入一个间接层，可以在这个层面上执行额外的操作，如延迟加载、缓存、日志记录、权限验证等。
简化复杂性：代理可以隐藏真实对象的复杂性，例如远程调用的网络细节。

2. 生活中的例子 (Real-world Analogy)

信用卡：
- 你的银行账户（真实主题）里有钱。
- 信用卡（代理）是你访问银行账户资金的一种方式。当你刷卡时，信用卡公司会验证你的身份、检查账户余额（控制访问），然后才允许交易。
经纪人/中介：
- 你想买卖股票（真实主题是股票交易所）。
- 你通过股票经纪人（代理）进行操作。经纪人会处理交易的细节，你不需要直接与交易所打交道。
- 房产中介（代理）帮助你买卖房屋（真实主题是房产本身和房主）。
门禁系统：
- 大楼的某个区域（真实主题）是受限的。
- 门禁卡或保安（代理）验证你的身份和权限，决定是否允许你进入。
明星的经纪人：
- 明星（真实主题）很忙。
- 经纪人（代理）处理明星的日程安排、商业洽谈等，过滤掉不必要的干扰，并代表明星处理事务。

3. 结构 (Structure)

代理模式通常包含以下角色：

Subject (主题接口)：定义了 RealSubject 和 Proxy 的共同接口。这样，在任何使用 RealSubject 的地方都可以使用 Proxy。
RealSubject (真实主题)：定义了 Proxy 所代表的真实实体。这是实际执行业务逻辑的对象。
Proxy (代理类)：
- 保存一个引用使得代理可以访问实体。若 RealSubject 和 Subject 的接口相同，Proxy 会引用 Subject。
- 提供一个与 Subject 的接口相同的接口，这样代理就可以用来替代实体。
- 控制对实体的存取，并可能负责创建和删除它。
- 其他功能依赖于代理的类型。
Client (客户端)：通过 Subject 接口与 RealSubject 或 Proxy 交互。

工作流程：

客户端请求操作时，它会调用 Proxy 对象的方法。
Proxy 对象可能会执行一些预处理操作（如权限检查、日志记录）。
如果需要，Proxy 会创建或获取 RealSubject 对象的引用，并将请求委托给 RealSubject。
RealSubject 执行实际的操作。
Proxy 可能会执行一些后处理操作（如结果缓存、日志记录），然后将结果返回给客户端。

4. 常见代理类型 (Types of Proxies)

根据代理的目的和实现方式，有几种常见的代理类型：

虚拟代理 (Virtual Proxy)：
- 目的：延迟加载昂贵的对象。当创建真实对象的开销很大时，虚拟代理会推迟真实对象的创建，直到客户端真正需要它为止。
- 例子：显示一个包含大量图片的文档，图片对象（真实主题）可以在实际滚动到屏幕上时才由虚拟代理创建和加载。
远程代理 (Remote Proxy)：
- 目的：为位于不同地址空间（如另一台机器上）的对象提供本地代表。远程代理负责处理网络通信的细节（如序列化、连接管理），使得客户端感觉像在调用本地对象一样。
- 例子：Java RMI (Remote Method Invocation) 中的 Stub 对象就是远程代理。
保护代理 (Protection Proxy)：
- 目的：控制对真实对象的访问权限。在调用真实对象的方法之前，保护代理会检查客户端是否具有相应的权限。
- 例子：根据用户角色控制对某些敏感操作的访问。
智能引用代理 (Smart Reference / Smart Proxy)：
- 目的：在访问对象时执行一些额外的操作，如引用计数、加锁以控制并发访问、对象加载时记录日志等。
- 例子：C++ 中的智能指针（如 std::shared_ptr）可以看作是一种智能引用代理，负责管理对象的生命周期。
缓存代理 (Caching Proxy)：
- 目的：为开销大的操作结果提供临时存储。当多个客户端请求相同的结果时，可以直接从缓存中返回，避免重复计算或请求。
- 例子：Web 代理服务器缓存常用网页；应用程序缓存数据库查询结果。
日志代理 (Logging Proxy)：
- 目的：在方法调用前后记录日志信息。

5. 适用场景 (When to Use)

当你需要延迟初始化一个开销很大的对象时（虚拟代理）。
当你需要控制对一个对象的访问权限时（保护代理）。
当你需要为一个远程对象提供本地代表时（远程代理）。
当你需要在访问对象时执行一些附加操作，如日志记录、缓存、事务管理等（智能引用代理、缓存代理、日志代理）。
当你希望为一个对象提供不同级别的访问权限时。

6. 优缺点 (Pros and Cons)

优点：

控制访问：代理模式的核心优势在于能够控制对真实对象的访问。
增强功能：可以在不修改真实对象代码的情况下，通过代理为其增加额外的功能（如延迟加载、权限控制、日志、缓存）。
降低耦合：客户端与真实对象解耦，客户端只与代理接口交互。
提高性能：通过虚拟代理延迟加载或缓存代理缓存结果，可以提高系统性能。
远程访问透明化：远程代理使得客户端可以像访问本地对象一样访问远程对象。

缺点：

增加系统复杂性：引入了额外的代理类，可能会增加系统的设计和实现的复杂度。
可能引入性能开销：由于请求需要通过代理转发，可能会增加一次间接调用，带来轻微的性能延迟。但通常这种开销被代理带来的好处（如延迟加载、缓存）所抵消或超过。
真实主题的接口依赖：代理类通常依赖于真实主题的接口，如果真实主题接口发生变化，代理类也可能需要修改。

7. 实现方式 (Implementations)

让我们以一个虚拟代理为例，实现一个图片加载器。真实图片对象加载开销大，我们希望在实际显示时才加载它。

主题接口 (Image - Subject)

// image.go (Subject interface)
package imaging// Image 主题接口
type Image interface {Display()GetFilename() string
}

// Image.java (Subject interface)
package com.example.imaging;// 主题接口
public interface Image {void display();String getFilename();
}

真实主题 (RealImage - RealSubject)

// real_image.go (RealSubject)
package imagingimport ("fmt""time"
)// RealImage 真实主题
type RealImage struct {filename string
}func NewRealImage(filename string) *RealImage {ri := &RealImage{filename: filename}ri.loadFromDisk() // 创建时即加载return ri
}func (ri *RealImage) GetFilename() string {return ri.filename
}func (ri *RealImage) loadFromDisk() {fmt.Printf("RealImage: Loading image '%s' from disk...\n", ri.filename)// 模拟耗时操作time.Sleep(2 * time.Second)fmt.Printf("RealImage: Image '%s' loaded.\n", ri.filename)
}func (ri *RealImage) Display() {fmt.Printf("RealImage: Displaying image '%s'\n", ri.filename)
}

// RealImage.java (RealSubject)
package com.example.imaging;// 真实主题
public class RealImage implements Image {private String filename;public RealImage(String filename) {this.filename = filename;loadFromDisk(); // 创建时即加载}@Overridepublic String getFilename() {return filename;}private void loadFromDisk() {System.out.printf("RealImage: Loading image '%s' from disk...%n", filename);try {// 模拟耗时操作Thread.sleep(2000);} catch (InterruptedException e) {Thread.currentThread().interrupt();System.err.println("Loading interrupted for " + filename);}System.out.printf("RealImage: Image '%s' loaded.%n", filename);}@Overridepublic void display() {System.out.printf("RealImage: Displaying image '%s'%n", filename);}
}

代理类 (ProxyImage - Proxy)

// proxy_image.go (Proxy)
package imagingimport "fmt"// ProxyImage 代理类 (虚拟代理)
type ProxyImage struct {filename  stringrealImage *RealImage // 指向真实对象的指针，延迟初始化
}func NewProxyImage(filename string) *ProxyImage {fmt.Printf("ProxyImage: Created proxy for image '%s'. Real image not loaded yet.\n", filename)return &ProxyImage{filename: filename, realImage: nil}
}func (pi *ProxyImage) GetFilename() string {return pi.filename
}func (pi *ProxyImage) Display() {if pi.realImage == nil { // 延迟加载fmt.Printf("ProxyImage: Real image '%s' needs to be displayed. Loading now...\n", pi.filename)pi.realImage = NewRealImage(pi.filename)}pi.realImage.Display() // 委托给真实对象
}

// ProxyImage.java (Proxy)
package com.example.imaging;// 代理类 (虚拟代理)
public class ProxyImage implements Image {private String filename;private RealImage realImage; // 指向真实对象的引用，延迟初始化public ProxyImage(String filename) {this.filename = filename;System.out.printf("ProxyImage: Created proxy for image '%s'. Real image not loaded yet.%n", filename);}@Overridepublic String getFilename() {return filename;}@Overridepublic void display() {if (realImage == null) { // 延迟加载System.out.printf("ProxyImage: Real image '%s' needs to be displayed. Loading now...%n", filename);realImage = new RealImage(filename);}realImage.display(); // 委托给真实对象}
}

客户端使用

// main.go (示例用法)
/*
package mainimport ("./imaging""fmt"
)func main() {fmt.Println("--- Client: Creating proxy images ---")image1 := imaging.NewProxyImage("photo1.jpg")image2 := imaging.NewProxyImage("document_scan.png")// 此时，真实图片尚未加载fmt.Printf("\nImage 1 Filename: %s\n", image1.GetFilename())fmt.Printf("Image 2 Filename: %s\n", image2.GetFilename())fmt.Println("\n--- Client: Requesting to display image1 ---")image1.Display() // 第一次调用 Display，会触发真实图片加载fmt.Println("\n--- Client: Requesting to display image1 again ---")image1.Display() // 第二次调用 Display，真实图片已加载，直接显示fmt.Println("\n--- Client: Requesting to display image2 ---")image2.Display() // 第一次调用 Display for image2，会触发加载
}
*/

// Main.java (示例用法)
/*
package com.example;import com.example.imaging.Image;
import com.example.imaging.ProxyImage;public class Main {public static void main(String[] args) {System.out.println("--- Client: Creating proxy images ---");Image image1 = new ProxyImage("photo1.jpg");Image image2 = new ProxyImage("document_scan.png");// 此时，真实图片尚未加载System.out.printf("%nImage 1 Filename: %s%n", image1.getFilename());System.out.printf("Image 2 Filename: %s%n", image2.getFilename());System.out.println("%n--- Client: Requesting to display image1 ---");image1.display(); // 第一次调用 display，会触发真实图片加载System.out.println("%n--- Client: Requesting to display image1 again ---");image1.display(); // 第二次调用 display，真实图片已加载，直接显示System.out.println("%n--- Client: Requesting to display image2 ---");image2.display(); // 第一次调用 display for image2，会触发加载}
}
*/

8. 与装饰器模式的区别

代理模式和装饰器模式在结构上非常相似（都包装了另一个对象并实现了相同的接口），但它们的意图截然不同：

代理模式 (Proxy)：
- 意图：控制对对象的访问。代理决定客户端是否、何时以及如何访问真实对象。
- 关注点：访问控制、生命周期管理（如虚拟代理）、通信（如远程代理）。
- 客户端感知：客户端可能不知道它正在与代理交互（例如，远程代理或保护代理对客户端是透明的），也可能知道（例如，客户端显式创建一个虚拟代理）。
- 谁创建：代理通常由系统或框架创建和管理，或者客户端在特定场景下创建（如虚拟代理）。
装饰器模式 (Decorator)：
- 意图：动态地向对象添加额外的职责或行为，而不改变其接口。
- 关注点：增强对象的功能。
- 客户端感知：客户端通常知道它正在使用一个装饰过的对象，并且通常负责构建装饰链。
- 谁创建：装饰器通常由客户端根据需要动态地组合和应用。