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();
    }
}

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

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

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

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

java在java.lang.reflect包中有自己的代理实现方式，通过相关api可以动态创建一个代理类。

通过代理类去调用被代理的方法。

因为实际代理类是在运行时创建的，所以把java的这个技术叫做动态代理。

Java为我们动态创建了Proxy。我们通过实现InvocationHandler接口告诉Proxy去做什么。