一、代理模式简介
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动态代理只能针对接口创建代理，不能针对类创建代理。
