设计模式- 代理模式（Proxy Pattern）结构|原理|优缺点|场景|示例

结构型（7种） 适配器模式装饰器模式代理模式外观模式桥接模式组合模式享元模式

行为型（11种） 策略模式模板方法模式观察者模式迭代器模式责任链模式命令模式备忘录模式状态模式访问者模式中介者模式

代理模式（Proxy Pattern）是一种结构型设计模式，它为其他对象（被代理对象）提供一个代理对象，并由代理对象控制对被代理对象的访问。代理模式通过引入代理对象来间接访问目标对象，从而实现对目标对象的增强、控制访问权限、远程访问等功能。代理模式的关键在于代理类与目标类具有相同的接口，客户端可以透明地使用代理对象代替目标对象。

模式结构

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

抽象主题（Subject）：定义了目标对象和代理对象共有的接口，这样在任何使用目标对象的地方都可以使用代理对象。

真实主题（Real Subject）：也称为被代理对象，实现了抽象主题接口，包含具体业务逻辑。

代理（Proxy）：也实现了抽象主题接口，其内部持有真实主题的引用。代理对象在实现接口方法时，可以选择调用真实主题的方法，也可以在调用前后添加额外的操作，如预处理、后处理、访问控制、日志记录等。

工作原理

客户端：通过代理对象来调用目标对象的方法，对客户端而言，代理对象与真实主题对象在接口上是透明的，客户端无需关心具体使用的是哪个对象。
代理：实现了与真实主题相同的接口，内部持有真实主题的引用。代理对象在接收到客户端请求时，可以选择直接调用真实主题的方法，也可以在调用前后添加额外的操作。
真实主题：实现了抽象主题接口，包含具体的业务逻辑。在代理模式中，真实主题通常不直接暴露给客户端，而是通过代理对象间接访问。

代理模式的分类

静态代理：代理类在编译时就确定，由程序员创建代理类或使用工具生成。静态代理的优点是直观、简单，缺点是需要为每个具体主题都创建一个对应的代理类，增加了代码量和维护成本。

动态代理：代理类在运行时动态生成，如Java中的JDK动态代理和CGLIB库。动态代理的优点是可以减少代码量，只需要编写一个通用的代理类生成器，适用于需要为大量类生成代理的情况。

优缺点

优点

职责清晰：代理对象与真实主题对象职责明确，代理对象负责控制访问、增强功能等，真实主题对象专注于业务逻辑。
扩展性好：通过代理模式可以方便地添加新的功能，如访问控制、日志记录等，而无需修改真实主题。
保护真实主题：通过代理对象可以隐藏真实主题的实现细节，提供额外的安全性和控制。

缺点

增加复杂性：引入代理对象会使系统变得更复杂，增加了额外的类和对象关系。
性能损耗：代理模式可能会带来一定的性能损耗，尤其是在代理对象执行额外操作的情况下。

适用场景

需要为对象增加额外功能：如添加日志、事务管理、访问控制等，而又不想修改对象本身。
需要对对象的访问进行控制：如远程访问、延迟加载、资源优化等。
需要隐藏对象的复杂性：通过代理对象对外提供简洁的接口，隐藏真实主题的复杂实现。

代码示例（以Java为例，展示静态代理）

// 抽象主题（接口）
interface Image {
    void display();
}

// 真实主题（被代理对象）
class RealImage implements Image {
    private String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk(fileName);
    }

    private void loadFromDisk(String fileName) {
        System.out.println("Loading image from disk: " + fileName);
    }

    @Override
    public void display() {
        System.out.println("Displaying image: " + fileName);
    }
}

// 代理
class ProxyImage implements Image {
    private RealImage realImage;
    private String fileName;

    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName);
        }
        realImage.display();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Image proxyImage = new ProxyImage("large-image.jpg");
        proxyImage.display();  // 输出：Loading image from disk: large-image.jpg, Displaying image: large-image.jpg

        System.out.println("\nDisplaying image again:");
        proxyImage.display();  // 输出：Displaying image: large-image.jpg
    }
}

在这个Java示例中：

Image接口作为抽象主题，定义了显示图像的方法。
RealImage类是需要被代理的真实主题，实现了Image接口，包含了从磁盘加载图像和显示图像的业务逻辑。
ProxyImage类作为代理，实现了Image接口，内部持有RealImage对象的引用。ProxyImage在实现display()方法时，首先检查RealImage对象是否已经加载，如果没有则先加载图像，然后调用RealImage的display()方法显示图像。这样实现了延迟加载的功能，只有在真正需要显示图像时才从磁盘加载，提高了性能。

客户端代码创建ProxyImage对象，并通过代理对象调用display()方法，实现了对真实主题对象的延迟加载。客户端无需关心代理对象的实现细节，只需面向Image接口编程。

代码示例（以Python为例）

# 抽象主题（接口）
class Image:
    def display(self):
        raise NotImplementedError("Subclasses must implement this method")

# 真实主题（被代理对象）
class RealImage(Image):
    def __init__(self, filename):
        self.filename = filename
        self.load_from_disk()

    def load_from_disk(self):
        print(f"Loading image from disk: {self.filename}")

    def display(self):
        print(f"Displaying image: {self.filename}")

# 代理
class ProxyImage(Image):
    def __init__(self, filename):
        self.filename = filename
        self.real_image = None

    def display(self):
        if not self.real_image:
            self.real_image = RealImage(self.filename)
        self.real_image.display()

# 客户端代码
def main():
    proxy_image = ProxyImage("large-image.jpg")
    proxy_image.display()  # 输出：Loading image from disk: large-image.jpg, Displaying image: large-image.jpg

    print("\nDisplaying image again:")
    proxy_image.display()  # 输出：Displaying image: large-image.jpg

if __name__ == "__main__":
    main()

在这个Python示例中：

Image类作为抽象主题，定义了显示图像的display()方法。
RealImage类是需要被代理的真实主题，继承自Image类，包含了从磁盘加载图像和显示图像的业务逻辑。
ProxyImage类作为代理，同样继承自Image类，内部持有RealImage对象的引用。ProxyImage在实现display()方法时，首先检查RealImage对象是否已经加载，如果没有则先加载图像，然后调用RealImage的display()方法显示图像。这样实现了延迟加载的功能，只有在真正需要显示图像时才从磁盘加载，提高了性能。