java进阶（二）--动态代理
什么是动态代理？
在介绍动态代理之前，首先我觉得有必要先理解下什么是静态代理，所谓的静态代理，就是程序运行前就已经存在编译好的代理类，具体的介绍和例子
可以看我之前的一篇博客介绍->java设计模式（四）--代理模式。如果这样，那么我们就很容易理解什么是动态代理了，所谓动态代理，就是代理类在
程序运行前并不存在，需要程序在运行时动态生成（无需手工编写代理类源码），这就是动态代理。
动态代理的原理
在展开动态代理的例子和代码讲解之前，请容许我花点时间啰嗦下它实现的机制或说原理，这个对于动态代理的理解至关重要。在java动态代理
机制中，有两个重要的类或是接口，一个是InvocationHandler(Interface)，另一个是Proxy(Class)，这两个类和接口是我们实现动态代理必须实现的。
InvocationHandler：每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们遇到代理对
象调用一个方法时，这个方法就会被转发为由InvocationHandler这个接口的Invoke方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个
方法invoke方法：
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
proxy: 指我们所代理的那个真实对象
method: 指的是我们所要调用真实对象的某个方法的Method对象
args: 指的是调用真实对象某个方法时接受的参数接下来我们来看看Proxy这个类，Proxy这个类是用来动态创建一个代理对象的类，他提供了许多方法，但是我们用的最多的就是
newProxyInstance这个方法：
public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) throws IllegalArgumentException
loader: 一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
interfaces: 一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
h: 一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上OK，这两个接口都了解了以后，对后面动态代理的代码的理解就会显得非常easy了，我们通过下面的实例来看看我们动态代理是怎么玩的，例子还是
用王婆的例子来说明吧，比较生动：
首先，我们定义一个公共接口，王婆和潘金莲共有的：
package DynamicProxy;
/*
* 定义一种类型的女人，王婆和潘金莲都属于这个类型的女人
*/
public interface KindWoman
{
//这种女人能做什么事情呢？
public void makeEyesWithMan();//抛媚眼
public void happyWithMan();//和男人那个....
}接着，我们定义潘金莲，也就是真实在干活的那个：
package DynamicProxy;
public class PanJinLian implements KindWoman
{
@Override
public void makeEyesWithMan()
{
System.out.println("潘金莲抛媚眼...");
}
@Override
public void happyWithMan()
{
System.out.println("潘金莲和男人在做那个...");
}
}好，西门庆看到潘金莲垂涎三尺，想跟她那个，但是不好直接上啊，这样万一人家不同意，那不是成流氓了，这时候王婆来了，她作为一个动态代理，
还提供在happy前，教你如何挑逗对方，happy后，还要打扫现场呀，不能光顾着happy吧，让武大郎看见怎么办：
package DynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/*
* 动态代理类，就是我在我另外一篇博客--代理模式中的王婆啦
*/
public class DynamicProxy implements InvocationHandler
{
// 这个就是我们要代理的真实对象(就是我另外一篇博客--代理模式中的潘金莲啦)
private Object kindWoman;
// 构造方法，给我们要代理的真实对象赋初值
public DynamicProxy(Object kindWoman)
{
this.kindWoman = kindWoman;
}
@Override
public Object invoke(Object object, Method method, Object[] args)
throws Throwable
{
System.out.println("\nThe invoking Method is:" + method.getName());
if(method.getName().equals("happyWithMan"))
{
// 在代理真实对象前我们可以添加一些自己的操作，是不是发现Spring中AOP的影子
System.out.println("happy之前，先挑逗。。。");
}
// 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
method.invoke(kindWoman, args);
if(method.getName().equals("happyWithMan"))
{
// 在代理真实对象后我们也可以添加一些自己的操作，是不是发现Spring中AOP的影子
System.out.println("happy完了，要打扫现场。。。");
}
return null;
}
}好，这时候西门庆出来就水到渠成啦，我们把他叫做客户（端） ：
package DynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class Client
{
public static void main(String[] args)
{
// 我们要代理的真实对象
KindWoman wanpo = new PanJinLian();
// 我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的
InvocationHandler handler = new DynamicProxy(wanpo);
/*
* 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数
* 第一个参数handler.getClass().getClassLoader() ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
* 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
* 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
*/
KindWoman wangPo = (KindWoman)Proxy.newProxyInstance(
handler.getClass().getClassLoader(),
wanpo.getClass().getInterfaces(),
handler);
// 表面上看是王婆在跟西门庆抛媚眼，其实爽的是潘金莲
wangPo.makeEyesWithMan();
wangPo.happyWithMan();
}
}最后，看看我们的输出：
The invoking Method is:makeEyesWithMan
潘金莲抛媚眼...
The invoking Method is:happyWithMan
happy之前，先挑逗。。。
潘金莲和男人在做那个...
happy完了，要打扫现场。。。我们来看下DynamicProxy这个方法，它实现了 InvocationHandler 这个接口，当我们用newProxyInstance生成代理对象的时候，它就会根据传进去的第二个参数，根据具体生成的代理对象去调用对应的方法执行，如下面这两个调用：
// 表面上看是王婆在跟西门庆抛媚眼，其实爽的是潘金莲
wangPo.makeEyesWithMan();
wangPo.happyWithMan();这里是通过代理对象来调用实现的哪种接口中的方法，这个时候程序就会跳转到由这个代理对象关联到的 handler 中的invoke方法去执行，而我们的
这个 handler对象又接受了一个 RealSubject类型的参数，表示我要代理的就是这个真实对象，所以此时就会调用 handler 中的invoke方法去执行，
同时，在执行方法之前，我们还能做一些其他的事情：
public Object invoke(Object object, Method method, Object[] args)
throws Throwable
{
System.out.println("\nThe invoking Method is:" + method.getName());
if(method.getName().equals("happyWithMan"))
{
// 在代理真实对象前我们可以添加一些自己的操作，是不是发现Spring中AOP的影子
System.out.println("happy之前，先挑逗。。。");
}
// 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
method.invoke(kindWoman, args);
if(method.getName().equals("happyWithMan"))
{
// 在代理真实对象后我们也可以添加一些自己的操作，是不是发现Spring中AOP的影子
System.out.println("happy完了，要打扫现场。。。");
}
return null;
}当我们通过代理对象来调用方法的时候，其实就是委托由其关联到的 handler 对象的invoke方法中来调用，并不是自己来真实调用，而是通
过代理的方式来调用的。
这就是java的动态代理机制。