这几天一直在学习Spring的东西，在学习AOP的过程中，发现其基本的原理还是使用Java的动态代理机制，但是之前学的都忘记了。为了更好的理解AOP，把Java的动态代理重新复习了一遍
一、为什么？
比如我有这样一个接口：AritmeticCaculator.java，用于完成加、减、乘、除
public interface ArithmeticCaculator {
int add(int i, int j);
int sub(int i, int j);
void mul(int i, int j);
void div(int i, int j);
}
接口的实现类：ArithmeticCaculatorImpl.java
public class ArithmeticCaculatorImpl2 implements ArithmeticCaculator {
@Override
public int add(int i, int j) {
System.out.println("The method add begin with " + i + ", " + j);
int result = i + j;
System.out.println("The method add end with " + i + ", " + j);
return result;
}
@Override
public int sub(int i, int j) {
System.out.println("The method sub begin with " + i + ", " + j);
int result = i - j;
System.out.println("The method sub end with " + i + ", " + j);
return result;
}
@Override
public void mul(int i, int j) {
int result = i * j;
System.out.println(result);
}
@Override
public void div(int i, int j) {
int result = i / j;
System.out.println(result);;
}
}
比如我需要在每个方法的核心代码前面加上说明，如同 add 方法这样，后面几个方法并没有添加，可以自己添加
此时在主函数在调用接口的方法，如只调用 add 方法，则会出现以下内容
public static void main(String[] args) {
ArithmeticCaculator arithmeticCaculator = new ArithmeticCaculatorImpl2();
int a = arithmeticCaculator.add(1, 2);
System.out.println(a);
a = arithmeticCaculator.sub(2, 2);
System.out.println(a);
}
//输出
The method add begin with 1, 2
The method add end with 1, 2
3
The method sub begin with 2, 2
The method sub end with 2, 2
0
这还只是调用了其中两个，况且方法也不对，如果有几十个或者几百个方法呢？不可能每个都这么写把？而且，如果临时需要把核心代码的说明做些修改，那工作量可想而知。因此我们考虑使用动态代理模式。
二、是什么？
什么是代理？通俗的来说，就像是租房时候的中介，他会帮你搞定一切事情，你所作只要去了解，然后付钱就可以了。因此，代理就好像是别人帮你做的事情，你把一件很复杂的事交给他，他会帮你完成。
什么是代理设计模式？指使用一个代理将对象包装起来，然后用该代理对象取代原始对象，任何对原始对象的调用都要通过代理，代理对象决定是否、以及何时将方法调用转到原始对象上。还是举中介的例子，当你把找房子的事情交给他的事情，他便会帮你做你原本要做的事情（找房子），同时，还会实时的给你反馈信息，是否找到了或者没找到。
三、怎么做？
若我们还是使用上面的 ArithmeticCaculator.java 和 ArithmeticCaculatorImpl2.java 接口实现类，把实现类中前两个方法的说明去掉，我们尝试直接使用动态代理方法。
3.1 Proxy 类
Proxy：提供用于创建动态代理类和代理对象的静态方法，它是所有动态代理类的父类。
Proxy 提供了两个方法来创建动态代理类，这里我使用 Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 方法，其中的几个参数：
ClassLoader：由动态代理产生的对象由哪个类加载器来加载. 通常情况下和被代理对象使用一样的类加载器
Class<?>[]：由动态代理产生的对象必须需要实现接口的 Class 数组
InvocationHandler：当具体调用代理对象的方法时, 将产生什么行为
PS：Proxy.newInstance() 的第二个参数必须是一个接口类型的数组，可以传多个。若代理对象只需要实现当前的接口，则可以使用 target.getClass().getInterfaces()
3.2 InvocationHandler 接口
每一个动态代理类都必须要实现 InvocationHandler 这个接口，并且每个代理类的实例都关联到了一个 handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由接口的 invoke 方法来进行调用
Object invoke(Object proxy, Method method, Object[] args) 的几个参数：
proxy：正在被返回的那个代理对象（一般情况下不使用）
method：正在被调用的方法
args：调用方法时传入的参数
以下是实例代码
@Test
public void testProxy() {
//被代理对象
ArithmeticCaculator arithmeticCaculator = new ArithmeticCaculatorImpl2();
ArithmeticCaculator proxy =
(ArithmeticCaculator) Proxy.newProxyInstance(arithmeticCaculator.getClass().getClassLoader(),
new Class[] {ArithmeticCaculator.class},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("The method " + method.getName() + " begins with " + Arrays.asList(args));
//调用被代理类的目标方法
Object object = method.invoke(arithmeticCaculator, args);
System.out.println("The method " + method.getName() + " ends with " + object);
System.out.println("&& " + object);
return object;
}
});
int a = proxy.add(2, 2);
proxy.mul(4, 2);
proxy.div(190, 2);
a = proxy.sub(4, 2);
}
输出：
The method add begins with [2, 2]
The method add ends with 4
The method mul begins with [4, 2]
8
The method mul ends with null
The method div begins with [190, 2]
95
The method div ends with null
The method sub begins with [4, 2]
The method sub ends with 2
分析：
① 以调用的 add() 的方法为例，当代理对象 proxy 调用 add() 的方法时，会传到 invoke 方法的第二个参数 Method 中，add() 方法中的参数则传到 第三个参数 Object []args 中。
② 使用 method 参数的 invoke 方法来执行方法，此时执行的方法就是被代理的对象，即接口 ArithmeticCaculator 中的 add 方法，为什么可以这样做呢？因为 invoke 方法的第一个参数就是接口 ArithmeticCaculator 的对象。
