说明：上一节，我们一起学习了静态代理，本章我将继续动态代理的讲述，不过本章的内容是建立在第一章知识点的基础上进行的。二者之间有着逻辑上的必然联系。如果你还没有看过设计模式--代理模式(Proxy Pattern)-静态代理，我建议你先看一下，会对本节内容的理解有所帮助！
动态代理
(1) 动态代理
代理类在程序运行时创建的代理方式被成为动态代理。 我们上面静态代理的例子中，代理类(studentProxy)是自己定义好的，在程序运行之前就已经编译完成。然而动态代理，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。 比如说，想要在每个代理的方法前都加上一个处理方法：
public void giveMoney() {
//调用被代理方法前加入处理方法
beforeMethod();
stu.giveMoney();
}
说明：
这里只有一个giveMoney方法，就写一次beforeMethod方法，但是如果除了giveMonney还有很多其他的方法，那就需要写很多beforeMethod方法，麻烦。那看看下面动态代理如何实现。
(２) 动态代理简单实现
自JDK1.3开始，Java语言通过在java.lang.reflect库中提供下面三个类直接支持代理：Proxy、Method和InvocationHandler。
其中Proxy使得设计师能够在运行时创建代理对象，其类图如下图所示：
那么代理对象的创建过程又到底是怎样的呢？
<1> 创建一个动态代理对象的过程：
1.创建一个InvocationHandler对象
//创建一个与代理对象相关联的InvocationHandler
InvocationHandler stuHandler = new MyInvocationHandler<Person>(stu);
2.使用Proxy类的getProxyClass静态方法生成一个动态代理类的Class对象stuProxyClass
Class<?> stuProxyClass = Proxy.getProxyClass(Person.class.getClassLoader(),
new Class<?>[] {Person.class});
3.获得stuProxyClass 中一个带InvocationHandler参数的构造器constructor
Constructor<?> constructor = PersonProxy.getConstructor(InvocationHandler.class);
4.通过构造器constructor来创建一个动态实例stuProxy
Person stuProxy = (Person) cons.newInstance(stuHandler);
这样一个动态代理对象就创建成功了！
然而上面的四个步骤可以通过调用Proxy的newProxyInstance()方法直接生成:
//创建一个与代理对象相关联的InvocationHandler
InvocationHandler stuHandler = new MyInvocationHandler<Person>(stu);
//创建一个代理对象stuProxy，代理对象的每个执行方法都会替换执行Invocation中的invoke方法
Person stuProxy= (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, stuHandler);
代理对象我们是知道如何创建的，但是，代理对象又是如何来代替真实对象的呢？下面是一个完整的例子：
<2> 动态代理完整实例
1.定义一个Person接口
/**
* Created by yucheng on 2018/8/9.
*/
public interface Person {
// 上交班费
void giveMoney();
}
2.创建需要被代理的实际类Student
/**
* Created by yucheng on 2018/8/9.
*/
public class Student implements Person {
private String name;
public Student(String name) {
this.name = name;
}
@Override
public void giveMoney() {
System.out.println(name + "上交班费50元");
}
}
3.创建StuInvocationHandler类，实现InvocationHandler接口
这个类中持有一个被代理对象的实例target。InvocationHandler中有一个invoke方法，所有执行代理对象的方法都会被替换成执行invoke方法。再在invoke方法中执行被代理对象target的相应方法。当然，在代理过程中，我们在真正执行被代理对象的方法前加入自己其他处理。这也是Spring中的AOP实现的主要原理。
/**
* Created by yucheng on 2018/8/9.
*/
public class StuInvocationHandler implements InvocationHandler {
//invocationHandler持有的被代理对象
// 如果知道，被代理类的类型，可以在这里直接设定特定类型，需要注意的是
// 在invoke()方法中也需要转为相应类型，而不能使用O
Object target;
public StuInvocationHandler(Object target) {
this.target = target;
}
/**
* proxy:代表动态代理对象
* method：代表正在执行的方法
* args：代表调用目标方法时传入的实参
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("代理执行" +method.getName() + "方法");
// 在方法调用之前进行系列操作,这里可以是方法
System.out.println("Before the function");
// 注意：对args进行操作之前需要进行为空的判断，因为有的方法不带参数，不进行判断，会抛出NullPointerException
if (args != null){
for (Object arg : args) {
System.out.println(" " + arg);
}
}
Object result = method.invoke(target, args);
System.out.println("After the function");
return result;
}
}
4.创建代理对象，并测试
/**
* Created by yucheng on 2018/8/9.
*/
public class ProxyTest {
public static void main(String[] args) {
//创建一个实例对象，这个对象是被代理的对象
Person zhangsan = new Student("张三");
//创建一个与代理对象相关联的InvocationHandler
InvocationHandler stuHandler = new StuInvocationHandler(zhangsan);
//创建一个代理对象stuProxy来代理zhangsan，代理对象的每个执行方法都会替换执行Invocation中的invoke方法
Person stuProxy = (Person) Proxy.newProxyInstance(
Person.class.getClassLoader(),
// Or zhangsan.getClass().getInterfaces(),
new Class<?>[]{Person.class},
stuHandler);
//代理执行上交班费的方法
stuProxy.giveMoney();
}
}
5.输出结果
我们执行这个ProxyTest类，先想一下，我们创建了一个需要被代理的学生张三，将zhangsan对象传给了stuHandler中，我们在创建代理对stuProxy时，将stuHandler作为参数了的，上面也有说到所有执行代理对象的方法都会被替换成执行invoke方法，也就是说，最后执行的是StuInvocationHandler中的invoke方法。因此出现下面的结果也就正常了。
代理执行giveMoney方法
Before the function
张三上交班费50元
After the function
动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。是因为所有被代理执行的方法，都是通过在InvocationHandler中的invoke方法调用的，所以我们只要在invoke方法中统一处理，就可以对所有被代理的方法进行相同的操作了。例如，这里的方法计时，所有的被代理对象执行的方法都会被计时，然而我只做了很少的代码量。
动态代理的过程，代理对象和被代理对象的关系不像静态代理那样一目了然，清晰明了。因为动态代理的过程中，我们并没有实际看到代理类，也没有很清晰地的看到代理类的具体样子，而且动态代理中被代理对象和代理对象是通过InvocationHandler来完成的代理过程的，其中具体是怎样操作的，为什么代理对象执行的方法都会通过InvocationHandler中的invoke方法来执行。带着这些问题，我们就需要对java动态代理的源码进行简要的分析，弄清楚其中缘由。
(3) 动态代理原理分析
<1> Java动态代理创建出来的动态代理类Proxy
我们创建动态代理对象，是通过Proxy的newProxyInstance()方法实现的，下面我们来看看它的源码
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* Look up or generate the designated proxy class.
* 2.查找或生成指定的代理类的Class对象
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
// 3.通过cl和构造器参数，返回一个带InvocationHandler参数的构造器
final Constructor<?> cons = cl.getConstructor(constructorParams);
// 1.通过参数h传递一个InvocationHandler对象
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
// 4.创建代理对象
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
由源码我们可以知晓，Proxy.newProxyInstance()方法是对创建代理对象的四个步骤的封装。
jdk为我们的生成了一个叫$Proxy0（这个名字后面的0是编号，有多个代理类会一次递增）的代理类，这个类文件时放在内存中的，我们在创建代理对象时，就是通过反射获得这个类的构造方法，然后创建的代理实例。通过对这个生成的代理类源码的查看，我们很容易能看出，动态代理实现的具体过程。
我们可以对InvocationHandler看做一个中介类，中介类持有一个被代理对象，在invoke方法中调用了被代理对象的相应方法。通过聚合方式持有被代理对象的引用，把外部对invoke的调用最终都转为对被代理对象的调用。
代理类调用自己方法时，通过自身持有的中介类对象来调用中介类对象的invoke方法，从而达到代理执行被代理对象的方法。也就是说，动态代理通过中介类实现了具体的代理功能
总结
生成的代理类：$Proxy0 extends Proxy implements Person，我们看到代理类继承了Proxy类，所以也就决定了java动态代理只能对接口进行代理，Java的继承机制注定了这些动态代理类们无法实现对class的动态代理。
上面的动态代理的例子，其实就是AOP的一个简单实现了，在目标对象的方法执行之前和执行之后进行了处理，对方法耗时统计。Spring的AOP实现其实也是用了Proxy和InvocationHandler这两个东西的。
说明：
本文是本人综合<<Java与模式>>以及一些好的博客的内容，再加上个人的一些心得，总结而成的。仅仅出于学习的目的。
参考链接：
1.https://www.cnblogs.com/gonjan-blog/p/6685611.html
2.http://www.runoob.com/design-pattern/proxy-pattern.html
推荐阅读：
代理模式之“高老庄悟空降八戒”
