1. 概述
首先，我们来思考如下两个问题：
什么是代理模式？为什么要使用代理模式？
简单总结一下，所谓的代理模式就是在原有的服务上多加一个占位，通过这个占位去控制服务的访问。通过代理模式，一方面可以控制如何访问真正的服务对象，提供额外服务；另一方面，有机会通过重写一些类来满足特定的需要。
在java的动态代理机制中，有两个重要的类或接口，一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)，这一个类和接口是实现动态代理所必须用到的。下面我们具体分析一下：
（1）InvocationHandler接口：当通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler接口的 invoke 方法来进行调用。InvocationHanler的 invoke 方法如下：
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
三个参数的具体含义如下：
proxy: 代理的真实对象
method: 调用真实对象的某个方法的Method对象
args: 调用真实对象某个方法时接收的参数
（2）Proxy类：这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是 newProxyInstance 这个方法，如下：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
这个方法的作用就是得到一个动态的代理对象，其接收三个参数，我们来看看这三个参数所代表的含义：
loader: 一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载；
interfaces: 一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了；
h: 一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
2. 示例
（1）我们先定义一个接口：
public interface Library {
void isAvalid();
void sayHello(String name);
}
（2）接口的实现类:
public class Book implements Library {
@Override
public void isAvalid() {
System.out.println("This book can be borrowed! ");
}
@Override
public void sayHello(String name) {
System.out.println("Book name is: "+ name);
}
}
（3）动态代理：
public class DynamicProxy implements InvocationHandler {
private Object object;
public DynamicProxy(Object object) {
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Bollow flow begin...");
System.out.println("Method name is: "+ method);
method.invoke(object, args);
System.out.println("Bollow flow end...");
return null;
}
}
（4）测试类：
public class Reader {
public static void main(String[] args) {
Book book = new Book();
InvocationHandler handler = new DynamicProxy(book);
Library library = (Library) Proxy.newProxyInstance(handler.getClass().getClassLoader(),
book.getClass().getInterfaces(), handler);
System.out.println(library.getClass().getName());
library.isAvalid();
library.sayHello("<JAVA Concurrency In Practice>");
}
}
结果输出：
$Proxy0
Bollow flow begin...
Method name is: public abstract void com.cn.dynamicProxy.Library.isAvalid()
This book can be borrowed!
Bollow flow end...
Bollow flow begin...
Method name is: public abstract void com.cn.dynamicProxy.Library.sayHello(java.lang.String)
Book name is: <JAVA Concurrency In Practice>
Bollow flow end...
说明：
通过 Proxy.newProxyInstance 创建的代理对象是在jvm运行时动态生成的一个对象，它并不是我们的InvocationHandler类型，也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，并且命名方式都是这样的形式，以$开头，proxy为中，最后一个数字表示对象的标号。
实际的运行方法：
Method name is: public abstract void com.cn.dynamicProxy.Library.isAvalid()
Method name is: public abstract void com.cn.dynamicProxy.Library.sayHello(java.lang.String)
所以，当我通过代理对象来调用方法的时候，实际上就是委托由其关联到的 handler 对象的invoke方法中来调用，并不是自己来真实调用，而是通过代理的方式来调用的。这就是java的动态代理机制。