前言：阅读这篇文章前，一定要知道什么是代理模式，具体可以参考这篇文章《设计模式(一)：代理模式》。
在《设计模式(一)：代理模式》一文中说了，程序员思思买书有两种选择：一种是选择去书厂（目标对象）买；另一种则是去书店（代理对象）买。第二种方式可以称为静态代理，因为这个代理对象是我们自己编写的。而JDK动态代理则是一种系统自动为我们生成代理对象的方式，下面先介绍一下这种方式如何实现。
一、JDK动态代理
首先还是有一家书厂，并且宣称自己有思思想要的书卖。
public interface Book {
public void buyBook();
}
public class BookFactory implements Book{
@Override
public void buyBook() {
System.out.println("思思买的书来自书厂");
}
}现在思思将使用JDK动态代理的方式去买到和书厂一模一样的书，那应该怎么做呢？
首先思思要找到一个 “神秘人” ，这个人专做各种倒买倒卖的生意。
public class MysteryMen implements InvocationHandler{
private Object target; //思思需要告诉神秘人她想买书厂的书
public MysteryMen(Object target){
this.target = target;
}
//下面是神秘人做的事情，他能帮思思买到书，暂时不用管是怎么做到的。
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("神秘人开始买书");
method.invoke(target, args);
System.out.println("神秘人完成买书");
return null;
}
}找到神秘人买书后，神秘人告诉思思还必须填写下面这个承诺表，才能将书给她。
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)思思可是程序员啊，这自然难不倒她，下面是思思买书的具体步骤。
public class SiSi {
public static void main(String[] args) {
Book book = new BookFactory();
MysteryMen mysteryMen = new MysteryMen(book);
Book dynamicBookStore = (Book)Proxy.newProxyInstance(BookFactory.class.getClassLoader(),
BookFactory.class.getInterfaces(), mysteryMen);
dynamicBookStore.buyBook();
}
}执行 main 方法，结果如下：
二、代码分析
结合上面的例子，下面对整个动态代理的过程做一个简单的梳理。
综合上一篇文章《设计模式(一)：代理模式》可以看到，动态代理与静态代理有一个最大的不同点，就是静态代理需要自己编写代理类，即《设计模式(一)：代理模式》中的 BookStore 类，再在 main 方法中执行 bookStore.buyBook()方法来达到目的。而使用动态代理时，这个代理对象是由系统在运行时为我们动态生成的。那系统到底是怎么为我们生成动态代理对象的呢？
首先看示例中，Proxy 类是JDK为我们提供的，它的 newProxyInstance 方法源码是这样写的：
*@param loader the class loader to define the proxy class
*@param interfaces the list of interfaces for the proxy class
* to implement
*@param h the invocation handler to dispatch method invocations to
*@return a proxy instance with the specified invocation handler of a
* proxy class that is defined by the specified class loader
* and that implements the specified interfaces
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)- 第一个参数是一个类加载器，这个类加载器必须是加载目标对象字节码的类加载器。
- 第二个参数是指定把动态生成的代理对象挂载到哪个接口下，此处是让动态代理对象与目标对象实现了同一个接口 Book。
- 第三个参数，也是最为重要的一个参数，需要一个InvocationHandler接口的实现类。
- 这个方法返回的是一个动态代理对象。
如果上面的参数不是很理解。具体到文中的例子，应该写成这样：Proxy.newProxyInstance(BookFactory.class.getClassLoader(),
BookFactory.class.getInterfaces(), mysteryMen)
InvocationHandler接口的源码如下：
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}结合上面的例子来看，我们在 invoke 方法里写了这样一段代码method.invoke(target, args)，这段代码涉及到 Java 反射的内容，相当于通过反射调用了 BookFactory 中的 buyBook 方法。
那系统是怎么知道要去调用BookFactory方法的呢？
使用Debug调试可以看到：
- method就是 buyBook 方法。
- 而args是方法参数，此处为 null。
- $Proxy0就是系统为我们动态生成的代理对象。通过在 main 方法里加上
System.out.println(dynamicBookStore.toString)可验证。
method.invoke(target, args)中还有一处还没有说到，那就是第一个参数target。这个参数为系统指明了调用哪个实现类的 buyBook 方法。在示例中我们通过构造函数的传参的方式，在MysteryMen类中传入了一个 BookFactory 类的引用，也是为了反射调用目标方法做准备的。
至此我们重新梳理一下整个动态代理的过程。
三、动态代理过程解析
结合文章开始的例子，要写一个动态代理，首先得有个接口（Book）和该接口的实现类（BookFactory），这里的实现类其实就是被代理对象，或者称为目标对象 target ；然后写一个 InvocationHandler 实现类，这个实现类的 invoke 方法里包含着我们的处理逻辑，例如对目标对象方法的调用，或者添加上我们自己想要实现的处理逻辑；最后通过 Proxy 类的静态方法 newProxyInstance 来生成动态代理对象。
再次使用Debug调试，将断点打在dynamicBookstore.buyBook()处，再单步进入此方法可以看到，程序立刻跳入了 MysteryMen 的 invoke 方法：
这张图说明了一点，那就是执行dynamicBookstore.buyBook()方法其实是执行了 InvocationHandler 接口实现类的 invoke 方法，invoke 方法里才是真正的处理逻辑地方。
在 invoke 方法里我们可以做任何我们想要的处理逻辑，例如在反射调用方法前后做一些操作，甚至不执行对目标方法的反射调用。
三、动态代理的优势
目前来说，我们使用动态代理完成的功能都能换用静态代理来完成。那么如此的话，动态代理到底有什么优势呢？
在静态代理中，一个目标对象对应这一个代理对象，如果目标对象过多，将会加重程序的代码量。而对于动态代理来说，如果我们想要对多个类进行代理，只需通过 newProxyInstance 方法让程序为我们动态生成代理对象即可，减少了代码工作量。并且在目标对象和动态代理对象之间还增加了一层 InvocationHandler 对目标方法进行拦截，一定程度上实现了解耦。
还有最重要的一点，就是静态代理在编译期间就需要指定对哪一个类进行代理，并写好该类的代理类。而动态代理则可以在运行期间确定需要对哪一个类进行代理，增加了系统的灵活性，其中运用了 Java 反射技术。