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

                                     设计模式（分类）        设计模式（六大原则）   

    创建型（5种）        工厂方法         抽象工厂模式        单例模式        建造者模式        原型模式

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

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

---

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

模式结构

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

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

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

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

工作原理

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

代理模式的分类

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

2. 动态代理：代理类在运行时动态生成，如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()方法显示图像。这样实现了延迟加载的功能，只有在真正需要显示图像时才从磁盘加载，提高了性能。

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