原理：
- 设计动态代理类（DymanicProxy）时，不需要显式实现与目标对象类（RealSubject）相同的接口，而是将这种实现推迟到程序运行时由JVM来实现。（即在使用时再创建动态代理类和实例）
- 通过Java反射机制method.invoke()，通过调用动态代理类对象方法，从而自动调用目标对象的方法
优点：
只需要1个动态代理类就可以解决创建多个静态代理的问题，避免重复，多余代码
缺点：
- 效率低
相比静态代理中直接调用目标对象（真实对象）方法，动态代理则需要通过Java反射机制从而间接调用目标对象方法
- 应用场景局限
因为Java的单继承特性（每个代理类都继承了Proxy类），即只能针对接口创建代理类，不能针对类创建代理类
注：即只能动态代理实现了接口的类，该类可以extends Buy，但是后面必须implements某个接口，代理的实例也是接口的实例。
实例：对礼物进行包装
步骤1：声明处理器类（关键）
//声明处理器类
class DynamicProxy implements InvocationHandler {
private Object proxyObject;
//生成动态代理对象
public Object newProxyInstance(Object subject){
this.proxyObject = subject;
return Proxy.newProxyInstance(subject.getClass().getClassLoader(),subject.getClass().getInterfaces(),this);
}
//动态代理对象调用目标对象任何方法前，都会调用处理器类的invoke方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
//做额外操作
System.out.println("包装礼物");
result = method.invoke(proxyObject,args);
return result;
}
}
步骤2：声明目标对象类的抽象接口
interface SubjectBuy{
void buyGift();
}
步骤3：声明目标对象类Buy1和Buy2
class Buy1 extends Buy implements SubjectBuy {
@Override
public void buyGift() {
System.out.println("我要买mac");
}
}
class Buy2 implements SubjectBuy {
@Override
public void buyGift() {
System.out.println("我要买手表");
}
}
class Buy{
public void buy(){
System.out.println("我要买买买");
}
}
步骤4：通过动态代理对象，调用目标对象的方法
public class DynamicProxyDemo {
public static void main(String[] args){
DynamicProxy dynamicProxy = new DynamicProxy();
Buy1 buy1 = new Buy1();
SubjectBuy subjectBuy = (SubjectBuy) (dynamicProxy.newProxyInstance(buy1));
subjectBuy.buyGift();
Buy2 buy2 = new Buy2();
SubjectBuy subjectBuy2 = (SubjectBuy)dynamicProxy.newProxyInstance(buy2);
subjectBuy2.buyGift();
}
}
步骤4中注意点：首先接口是特殊的类，newProxyInstance返回的object只能向上转型为接口的对象。因为该object本身是有subject.getClass().getInterfaces()所具有的接口生成的。
源码分析
一、如何创建动态代理类及其实例对象
方法：Proxy.newProxyInstance(subject.getClass().getClassLoader(),subject.getClass().getInterfaces(),this)
解析：Proxy.newProxyInstance（）作用：根据指定的类装载器、一组接口 & 调用处理器 生成动态代理类实例，并最终返回
//作用：根据指定的类装载器、一组接口 & 调用处理器 生成动态代理类及其对象实例，并最终返回
public static Object newProxyInstance(ClassLoader loader, Class>[]interfaces,InvocationHandler h) throws IllegalArgumentException {
// 参数说明：
// 参数1：指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
// 参数2：指定目标对象的实现接口
// 即要给目标对象提供一组什么接口。若提供了一组接口给它，那么该代理对象就默认实现了该接口，这样就能调用这组接口中的方法
// 参数3：指定InvocationHandler对象。即动态代理对象在调用方法时，会关联到哪个InvocationHandler对象
...
// 仅贴出核心代码
// 1. 通过 为Proxy类指定类加载器对象 & 一组interface，从而创建动态代理类
// >>关注3
Class cl = getProxyClass(loader, interfaces);
// 2. 通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
Constructor cons = cl.getConstructor(constructorParams);
// 3. 通过动态代理类的构造函数 创建 代理类实例（传入调用处理器对象
return (Object) cons.newInstance(new Object[] { h });
// 特别注意
// 1. 动态代理类继承 Proxy 类 & 并实现了在Proxy.newProxyInstance()中提供的一系列接口（接口数组）
// 2. Proxy 类中有一个映射表
// 映射关系为：(,(,) )
// 即：1级key = 类加载器，根据1级key 得到 2级key = 接口数组
// 因此：1类加载器对象 + 1接口数组 = 确定了一个代理类实例
...
}
总结：通过调用处理器类对象的Proxy.newProxyInstance()创建动态代理类及其实例对象（需传入目标类对象）
具体过程：
1.通过为Proxy类指定类加载器和一组接口，从而创建动态代理类的字节码，再根据字节码创建动态代理类
代码：Class cl = getProxyClass(loader, interfaces);
- 通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
代码：Constructor cons = cl.getConstructor(constructorParams);
3.通过动态代理类的构造函数创建代理类实例（传入调用处理器对象）
代码：(Object) cons.newInstance(new Object[] { h })
如何通过调用动态代理对象方法，从而调用目标对象方法？
Proxy.newProxyInstance()生成了一个动态代理类 及其实例。
该动态代理类记为 ：
Proxy0源码：
// 继承：Java 动态代理机制的主类：java.lang.reflect.Proxy
// 实现：与目标对象一样的接口（即上文例子的Subject接口）
public final class $Proxy0 extends Proxy implements Subject {
// 构造函数
public ProxySubject(InvocationHandler invocationhandler)
{
super(invocationhandler);
}
// buybuybuy（）是目标对象实现接口（Subject）中的方法
// 即$Proxy0类必须实现
// 所以在使用动态代理类对象时，才可以调用目标对象的同名方法（即上文的buybuybuy（））
public final void buybuybuy（） {
try {
super.h.invoke(this, m3, null);
// 该方法的逻辑实际上是调用了父类Proxy类的h参数的invoke（）
// h参数即在Proxy.newProxyInstance(ClassLoader loader, Class>[]interfaces,InvocationHandler h)传入的第3个参数InvocationHandler对象
// 即调用了调用处理器的InvocationHandler.invoke（）
// 而复写的invoke（）利用反射机制：Object result=method.invoke(proxied,args)
// 从而调用目标对象的的方法 ->>关注4
return;
} catch (Error e) {
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
这里源码沾的有点乱，具体看别人的https://www.jianshu.com/p/5dc416ea58a2
此类源码能说明很多问题
- 动态代理类已经继承了Proxy父类，所以动态代理类没法再代理实体父类，只能代理接口，只能代理实现接口的类
- 动态代理类会实现目标类的所实现的接口，这样就具有目标类的相同实现的方法，然后在实现方法中调用的是super.h.invoke(this, m3, null)。刚好是处理器类重写的invoke方法，而复写的invoke（）利用反射机制：Object result=method.invoke(proxied,args)—>从而调用了目标对象的方法
总结：
- 动态代理类实现了与目标类一样的接口，并实现了需要目标类对象需要调用的方法
- 该方法的实现逻辑 = 调用父类 Proxy类的 h.invoke（）
- 在 InvocationHandler.invoke（） 中通过反射机制，从而调用目标类对象的方法
参考：https://www.jianshu.com/p/5dc416ea58a2