代理模式（Proxy Pattern）

一、代理模式简介

1. 定义

代理模式（Proxy Pattern），即给目标对象提供一个代理对象，并由代理对象控制对于目标对象的访问，即客户不直接操控目标对象，而是通过代理对象间接地操控代理对象。这种类型的设计模式属于结构型模式。

2. 模式组成

• 抽象接口，声明目标对象和代理对象的共同接口，对应代理接口（Subject）；
• 目标对象，客户最终要引用的对象，对应委托类（RealSubject）；
• 代理对象，内部含有目标对象的引用，可以操作目标对象，同时代理对象可以在执行目标对象操作时，附加其他的操作，对应代理类（ProxySubject）。

3. 分类

• 静态代理
• 动态代理

二、静态代理

1. 具体实现

所谓静态代理，就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在程序运行前就确定了。

/**
 * 抽象接口
 */
public interface Subject {
    public void doSomething();
}
/**
 * 目标对象
 */
public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("目标对象执行一些操作");
    }
}
/**
 * 静态代理对象
 */
public class StaticProxy implements Subject {

    //创建目标对象
    private RealSubject realSubject = new RealSubject();

    @Override
    public void doSomething() {

        // 准备工作
        before();

        // 调用目标对象执行相关操作
        realSubject.doSomething();

        // 收尾工作
        after();

    }

    private void before() {
        System.out.println("**** 静态代理 准备工作 ****");
    }

    private void after() {
        System.out.println("**** 静态代理 收尾工作 ****");
    }
}

对于静态代理的使用很简单，大致可以像这样进行调用：

private void testStaticProxy() {
        Subject staticProxy = new StaticProxy();
        staticProxy.doSomething();
    }

输出结果：

**** 静态代理 准备工作 ****
目标对象执行一些操作
**** 静态代理 收尾工作 ****

2. 优缺点

• 优点
  （1）降低了耦合度
  （2）代理对象作为客户端和目标对象之间的中介，起到了保护目标对象的作用
• 缺点
  （1）代理对象的一个接口只服务于一种类型的目标对象，如果要服务多类型的目标对象，则需要为每种目标对象都实现一个静态代理对象
  （2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法，增加了代码的复杂度。

三、动态代理

动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。

1. 相关知识介绍

1.1 Proxy类

Proxy类是Java动态代理机制生成的所有动态代理类的父类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。其主要静态方法如下：

// 获取指定代理对象所关联的调用处理器  
static InvocationHandler getInvocationHandler(Object proxy)   
  
// 获取关联于指定类加载器和一组接口的动态代理类的类对象  
static Class getProxyClass(ClassLoader loader, Class[] interfaces)   
  
// 判断指定类对象是否是一个动态代理类  
static boolean isProxyClass(Class cl)   
  
// 为指定类加载器、一组接口及调用处理器生成动态代理类实例  
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

我们具体关注一下newProxyInstance这个方法，其最终返回一个动态代理类实例，看一下里面的参数具体含义：

• ClassLoader loader：指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器；
• Class[] interfaces：获取目标对象的实现接口；
• InvocationHandler h：调用处理器类（即InvocationHandler）实例，调用目标方法的时候可以转而执行InvocationHandler类的invoke方法。

动态代理类对象创建过程：

• 实现InvocationHandler接口，创建调用处理器；
• 给Proxy类提供ClassLoader和代理接口类型数组创建动态代理类；
• 以调用处理器类型为参数，利用反射机制得到动态代理类的构造函数；
• 以调用处理器对象为参数，利用动态代理类的构造函数创建动态代理类对象。

public static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h) throws IllegalArgumentException {
        // 仅贴出核心代码

        // 通过为Proxy类指定类加载器对象和一组接口，从而创建动态代理类
        Class cl = getProxyClass(loader, interfaces);

        // 通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
        Constructor cons = cl.getConstructor(constructorParams);

        // 通过动态代理类的构造函数创建代理类实例（传入调用处理器对象）
        return (Object) cons.newInstance(new Object[]{h});
    }

1.2 InvocationHandler接口

InvocationHandler接口是调用处理器接口，它只定义了一个invoke方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。每次生成动态代理类对象时都要指定一个对应的调用处理器对象。当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke()方法来进行调用。

public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

看一下里面的参数具体含义：

• Object proxy：代理类实例；
• Method method：目标对象被调用的方法；
• Object[] args：调用方法的参数。

2. 具体实现

/**
 * 抽象接口
 */
public interface Subject {
    public void doSomething();
}
/**
 * 目标对象
 */
public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("目标对象执行一些操作");
    }
}
/**
 * 动态代理
 */
public class DynamicProxy implements InvocationHandler {

    private Object target;

    public DynamicProxy(Object target) {
        this.target = target;
    }

    public Object newProxyInstance() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 准备工作
        before();

        // 通过Java反射机制调用目标对象方法
        Object result = method.invoke(target, args);

        // 收尾工作
        after();
        return result;
    }

    private void before() {
        System.out.println("**** 动态代理 准备工作 ****");
    }

    private void after() {
        System.out.println("**** 动态代理 收尾工作 ****");
    }
}

对于动态代理的使用同样很简单，大致可以像这样进行调用：

private void testDynamicProxy() {
        Subject realSubject = new RealSubject();
        DynamicProxy dynamicProxy = new DynamicProxy(realSubject);
        Subject proxySubject = (Subject) dynamicProxy.newProxyInstance();
        proxySubject.doSomething();
    }

输出结果：

**** 动态代理 准备工作 ****
目标对象执行一些操作
**** 动态代理 收尾工作 ****

3. Java动态代理到底做了什么？

其实动态代理是在运行时候为我们生成了一个代理类，大致如下：

public final class $Proxy0 extends Proxy implements Subject {

        //代理类的构造函数，其参数正是是InvocationHandler实例，Proxy.newInstance方法就是通过通过这个构造函数来创建代理实例的
        public $Proxy0(InvocationHandler invocationhandler) {
            super(invocationhandler);
        }

        public final void doSomething() {
            try {
                // h参数即在Proxy.newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h)传入的第3个参数InvocationHandler对象
                super.h.invoke(this, m3, (Object[])null);
            } catch (RuntimeException | Error var2) {
                throw var2;
            } catch (Throwable var3) {
                throw new UndeclaredThrowableException(var3);
            }
        }
    }

从中可以看到，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke()方法来进行调用。
同时，我们看到这个类实际上实现了Subject，继承了Proxy类，因此JDK动态代理只能代理接口，因为其已经继承了Proxy类（单继承）。

4. 优缺点

• 优点
  Java动态代理可以避免静态代理带来的代码冗余的问题
• 缺点
  Java动态代理只能针对接口创建代理，不能针对类创建代理。