GPT带我学-设计模式-代理模式

什么是代理模式

图片来源：代理模式
代理模式（Proxy Pattern）是设计模式中的一种结构型模式，它为其他对象提供一种代理以控制对这个对象的访问。

代理模式有三个主要角色：抽象主题（Subject）、真实主题（Real Subject）和代理（Proxy）。

抽象主题（Subject）：定义了真实主题与代理之间的共同接口，这样真实主题和代理可以互相替换使用。

真实主题（Real Subject）：指实际要被代理的对象。

代理（Proxy）：提供了一个与真实主题相同的接口，它内部持有一个真实主题的引用，并在真实主题的实例化或执行某些操作前后进行控制或扩展。

代理模式的主要目的是在不改变真实主题的情况下，为其提供一个代理类来进行访问控制或增强功能。代理模式可以实现懒加载，即在真正需要使用真实主题的时候才进行实例化，从而节省资源和提高性能。代理模式还能提供额外的功能，例如在调用真实主题的方法前后进行日志记录、安全控制、事务管理等。

代理模式可以分为静态代理和动态代理。静态代理是通过手动编写代理类来实现的，而动态代理则是在运行时动态生成代理类。动态代理通常使用Java的反射机制来实现，可以减少冗余代码，并且对真实主题的访问完全透明。

总之，代理模式提供了一种间接访问对象的方式，可以控制对象的访问、增强对象的功能，并且可以在不改变真实对象的情况下进行扩展。

代理模式有几种形式

在设计模式中，代理模式有两种常见的形式：

静态代理（Static Proxy）：静态代理需要手动编写代理类，代理类和真实主题类实现相同的接口或继承相同的父类，并在代理类中持有一个真实主题类的引用。静态代理在编译时就确定了代理对象和真实对象的关系。

动态代理（Dynamic Proxy）：动态代理在运行时动态生成代理类，不需要手动编写代理类。Java中的动态代理通常使用Java反射机制实现，可以通过Proxy类和InvocationHandler接口来创建动态代理对象。动态代理可以代理接口或类，适用于需要代理多个不同类型对象的场景。

在静态代理和动态代理中，代理类都是通过调用真实主题类的方法，并在方法前后加上一些额外的逻辑（如日志记录、权限验证等）来控制或增强真实主题的功能。

除了静态代理和动态代理，还有一些其他的代理变体形式，如远程代理、虚拟代理、保护代理等，这些形式根据具体的应用场景和需求进行使用。

请举一个具体的静态代理例子

假设有一个接口 Subject，定义了一个抽象主题的操作方法 request()。现在我们需要用静态代理来实现在真实主题的执行前后进行日志记录。

首先，定义一个 Subject 接口：

public interface Subject {
    void request();
}

接下来，创建真实主题类 RealSubject，实现 Subject 接口：

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("真实主题执行请求");
    }
}

然后，创建一个代理类 ProxySubject，实现 Subject 接口，并在 request() 方法的前后添加日志记录的逻辑：

public class ProxySubject implements Subject {
    private RealSubject realSubject;

    public ProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void request() {
        System.out.println("代理主题执行请求之前的日志记录");
        
        // 调用真实主题的方法
        realSubject.request();
        
        System.out.println("代理主题执行请求之后的日志记录");
    }
}

最后，我们可以通过以下代码来使用静态代理：

public class Main {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        ProxySubject proxy = new ProxySubject(realSubject);
        proxy.request();
    }
}

运行程序，输出结果如下：

代理主题执行请求之前的日志记录
真实主题执行请求
代理主题执行请求之后的日志记录

可以看到，通过静态代理模式，我们在真实主题的执行前后添加了日志记录的逻辑，实现了对真实主题的控制和功能增强，而不需要修改真实主题类的代码。这是静态代理模式的一种常见应用场景。

同样的例子怎么改成动态代理模式呢

要将上述示例改为动态代理模式，需使用Java的动态代理实现。首先，需要借助 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口。

首先，定义 Subject 接口和 RealSubject 真实主题类，与上述示例相同。

接下来，创建一个实现 InvocationHandler 接口的代理处理器类 ProxyHandler，用于在真实主题的方法执行前后添加日志记录的逻辑。在 invoke() 方法中，可以定义增强的逻辑以及调用真实主题的方法。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class ProxyHandler implements InvocationHandler {
    private Object realSubject;

    public ProxyHandler(Object realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理主题执行请求之前的日志记录");

        // 调用真实主题的方法
        Object result = method.invoke(realSubject, args);

        System.out.println("代理主题执行请求之后的日志记录");

        return result;
    }
}

最后，可以通过以下代码来使用动态代理：

import java.lang.reflect.Proxy;

public class Main {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        InvocationHandler handler = new ProxyHandler(realSubject);
        
        // 创建动态代理对象
        Subject proxySubject = (Subject) Proxy.newProxyInstance(
            realSubject.getClass().getClassLoader(),
            realSubject.getClass().getInterfaces(),
            handler
        );
        
        proxySubject.request();
    }
}

运行程序，输出结果与静态代理的例子相同：

代理主题执行请求之前的日志记录
真实主题执行请求
代理主题执行请求之后的日志记录

可以看到，通过动态代理模式，我们实现了在真实主题的执行前后添加日志记录的逻辑，而不需要直接操作代理类，使代理对象动态生成，并且能够透明地调用真实主题的方法。这是动态代理模式的一种常见应用场景。

请给出具体的代理模式控制对象的访问例子

以下是一个示例，说明如何使用代理模式来控制对象的访问：

假设我们有一个FileParser类，用于读取和解析文件。由于该类涉及到磁盘IO等敏感操作，因此我们想对其进行保护，只允许授权用户来访问该类的方法。

为了实现这一目标，我们可以创建一个名为FileParserProxy的代理类，该类与FileParser实现相同的接口（例如Parser接口），并保存一个指向FileParser对象的引用。在代理类中，我们可以添加一些额外的逻辑来限制对真实对象的访问，例如验证授权信息、记录日志等。

// 定义一个解析器接口
public interface Parser {
    String parse(String fileName);
}

// 真实的文件解析器
public class FileParser implements Parser {
    @Override
    public String parse(String fileName) {
        // 读取和解析文件内容的具体实现
        return "parsed file content";
    }
}

// 文件解析器的代理
public class FileParserProxy implements Parser {

    // 这里保存了一个指向真实对象的引用
    private final FileParser parser;

    // 在构造函数中初始化真实对象的引用
    public FileParserProxy(FileParser parser) {
        this.parser = parser;
    }

    // 实现接口的方法，可以在执行前后添加额外逻辑
    @Override
    public String parse(String fileName) {
        // 验证授权信息，如果不合法则返回错误信息
        if (!isValidUser()) {
            return "Unauthorized access to file: " + fileName;
        }

        // 记录日志
        log("Parsing file: " + fileName);

        // 调用真实对象的方法
        return parser.parse(fileName);
    }

    // 模拟授权验证的方法
    private boolean isValidUser() {
        // 这里假设当前用户已经通过了授权验证
        return true;
    }

    // 模拟记录日志的方法
    private void log(String message) {
        System.out.println("LOG: " + message);
    }
}

通过代理模式控制对象的访问，其实质还是在调用实际对象的方法前进行额外的逻辑校验。

补充说明（《Head First设计模式》）

java在java.lang.reflect包中有自己的代理实现方式，通过相关api可以动态创建一个代理类。
通过代理类去调用被代理的方法。
因为实际代理类是在运行时创建的，所以把java的这个技术叫做动态代理。
Java为我们动态创建了Proxy。我们通过实现InvocationHandler接口告诉Proxy去做什么。