上篇博文介绍的静态代理有一个最主要的缺点：每个业务类，必须有一个代理类。这样在程序中就会出现很多个代理类，这样的代码还是有坏味道的。这篇文章就为了解决这个问题而来--JDK动态代理。
先来看一看最基本的业务接口和业务类：
<span style="font-size:18px;">/**
* 业务接口类
* @author sunliduan
*
*/
public interface Greeting {
void sayHello(String name);
}</span>
<span style="font-size:18px;">/**
* 业务实现类
* @author sunliduan
*
*/
public class GreetingImpl implements Greeting {
@Override
public void sayHello(String name) {
System.out.println("Hello! " + name);
}
}</span>
这时候为了减少重复工作，处理过多的代理类，我们抽象了一个公共的代理类，也就是我们所说的动态代理类。先看代码：
<span style="font-size:18px;">public class JDKDynamicProxy implements InvocationHandler {
// 这个就是我们要代理的真实对象
private Object target;
// 构造方法，给我们要代理的真实对象赋初值
public JDKDynamicProxy(Object target) {
super();
this.target = target;
}
/**
* 创建代理对象
*
* @return target.getClass().getClassLoader() :
* 使用target这个类的ClassLoader对象来加载我们最终生成的代理对象
* target.getClass().getInterfaces() :
* 为代理对象提供的接口.这里提供的是真实对象所实行的接口，那么我这个代理对象就会实现了这组接口 this :
* 将这个代理对象关联到了上方的 InvocationHandler 这个对象上
*/
@SuppressWarnings("unchecked")
public <T> T getProxy() {
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), this);
}
@Override
// proxy 在其上调用方法的代理实例
// method 拦截的方法
// args 拦截的参数
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
before(); // 在代理真实对象前我们可以添加一些自己的操作
// 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
Object ojb = method.invoke(target, args);
after(); // 在代理真实对象后我们也可以添加一些自己的操作
return ojb;
}
private void before() {
System.out.println("Before==通过JDK动态代理把我加到被切方法之前");
}
private void after() {
System.out.println("After==通过JDK动态代理把我加到被切方法之后");
}
}</span>
可以说，动态代理可以提供对另一个对象的访问，同时隐藏实际对象的具体事实。代理一般会实现它所表示的实际对象的接口。代理可以访问实际对象，但是延迟实现实际对象的部分功能，实际对象实现系统的实际功能，代理对象对客户隐藏了实际对象。客户不知道它是与代理打交道还是与实际对象打交道。这样我们可以用动态代理对请求进行任何处理。
接下来咱们就详细的说一说动态代理的机制。在java的动态代理机制中，有两个重要的类或接口，一个是InvocationHandler(Interface)、另一个则是Proxy(Class)，这一个类和接口是实现我们动态代理所必须用到的。每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke
方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法：
<span style="font-size:18px;">public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;</span>
这个方法一共接受三个参数，那么这三个参数分别代表什么呢？
proxy:
指代我们所代理的那个真实对象
method: 指代的是我们所要调用真实对象的某个方法的Method对象
args: 指代的是调用真实对象某个方法时接受的参数
对应到咱们的demo中，proxy就是指GreetingImpl类，method是指GreetingImpl类中的sayHello方法，args是指sayHello方法中需要的参数name。
接下来我们再来看看Proxy这个类，这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是newProxyInstance 这个方法，这个方法的作用就是得到一个动态的代理对象，其接收三个参数，我们来看看这三个参数所代表的含义：
loader: 一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
interfaces: 一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
this: 一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上。
介绍完两个接口或类，我们大概了解了Java动态代理的机制了。简单的来说，先是通过Proxy类，为我们动态创建一个代理对象；然后当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke
方法来进行调用，这样我们就可以在invoke方法里对请求进行任何处理了。
可是看完代码之后，大家可能还是有疑问的，那就是公共的方法（例如demo中的before和after）还是没有实现复用啊？那我们如何将这些公共部分也抽象出来呢，欲知答案如何，且听下回分解~~