详解Java动态代理机制
之前介绍的反射和注解都是Java中的动态特性，还有即将介绍的动态代理也是Java中的一个动态特性。这些动态特性使得我们的程序很灵活。动态代理是面向AOP编程的基础。通过动态代理，我们可以在运行时动态创建一个类，实现某些接口中的方法，目前为止该特性已被广泛应用于各种框架和类库中，例如：Spring，Hibernate，MyBatis等。理解动态代理是理解框架底层的基础。
主要内容如下：
- 理解代理是何意
- Java SDK实现动态代理
- 第三方库cglib实现动态代理
一、代理的概念
单从字面上理解，代理就是指原对象的委托人，它不是原对象但是却有原对象的权限。Java中的代理意思类似，就是指通过代理来操作原对象的方法和属性，而原对象不直接出现。这样做有几点好处：
- 节省创建原对象的高开销，创建一个代理并不会立马创建一个实际原对象，而是保存一个原对象的地址，按需加载
- 执行权限检查，保护原对象
实际上代理堵在了原对象的前面，在代理的内部往往还是调用了原对象的方法，只是它还做了其他的一些操作。下面看第一种实现动态代理的方式。
二、Java SDK实现动态代理
实现动态代理主要有如下几个步骤：
- 实现 InvocationHandler接口，完成自定义调用处理器
- 通过Proxy的getProxyClass方法获取对应的代理类
- 利用反射技术获取该代理类的constructor构造器
- 利用constructor构造代理实例对象
在一步步解析源码之前，我们先通过一个完整的实例了解下，整个程序的一步步逻辑走向。
//定义了一个调用处理器
public class MyInvotion implements InvocationHandler {
private Object realObj;
public MyInvotion(Object obj){
this.realObj = obj;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
//通过代理执行原对象的方法
return method.invoke(realObj,args);
}
}
//定义一个接口
public interface MyInterface {
public void sayHello();
}
//该接口的一个实现类，该类就是我们的原对象
public class ClassA implements MyInterface {
public void sayHello(){
System.out.println("hello walker");
}
}
//main 函数
public static void main(String[] args){
ClassA a = new ClassA();
MyInvotion myInvotion = new MyInvotion(a);
Class myProxy = Proxy.getProxyClass(ClassA.class.getClassLoader(), new Class[]{MyInterface.class});
Constructor constructor =myProxy.getConstructor(new Class[]{InvocationHandler.class});
MyInterface m = (MyInterface)constructor.newInstance(myInvotion);
m.sayHello();
}
输出结果：hello walker
简单说下整体的运行过程，首先我们创建ClassA 实例并将它传入自定义的调用处理器MyInvotion，在MyInvotion中用realObj接受该参数代表原对象。接着调用Proxy的getProxyClass方法，将ClassA 的类加载器和ClassA 的实现的接口集合传入，该方法内部会实现所有接口返回该类的代理类，然后我们利用反射获取代理类的构造器并创建实例。
以上便是整个程序运行的大致流程，接下来我们从源代码的角度看看具体是如何实现的。首先我们看InvocationHandler接口，这是我们的调用处理器，在代理类中访问的所有的方法都会被转发到这执行，具体的等我们看了代理类源码及理解了。该接口中唯一的方法是：
public Object invoke(Object proxy, Method method, Object[] args)
- 参数Proxy表示动态生成的代理类的对象，基本没啥用
- 参数method表示当前正在被调用的方法
- 数组args指定了该方法的参数集合
我们上例中对该接口的实现情况，定义了一个realObj用于保存原对象的引用。重写的invoke方法中调用了原对象realObj的method方法，具体谁来调用该方法以及传入的参数是什么，在看完代理类源码即可知晓。
接下来我们看看最核心的内容，如何动态创建代理类。这是getProxyClass方法的源码：
public static Class<?> getProxyClass(ClassLoader loader,
Class<?>... interfaces)
throws IllegalArgumentException
{
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
return getProxyClass0(loader, intfs);
}
首先获取了该类实现的所有的接口的集合，然后判断创建该代理是否具有安全性问题，检查接口类对象是否对类装载器可见等。然后调用另外一个getProxyClass0方法，我们跟进去：
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
return proxyClassCache.get(loader, interfaces);
}
判断如果该类的接口超过65535（想必还没有那么牛的类），抛出异常。在我们的Proxy类中有个属性proxyClassCache，这是一个WeakCache类型的静态变量。它指示了我们的类加载器和代理类之间的映射。所以proxyClassCache的get方法用于根据类加载器来获取Proxy类，如果已经存在则直接从cache中返回，如果没有则创建一个映射并更新cache表。具体创建一个Proxy类并存入cache表中的代码限于能力，未能参透。
至此我们就获取到了该ClassA类对应的代理类型，接着我们通过该类的getConstructor方法获取该代理类的构造器，并传入InvocationHandler.class作为参数，至于为何要传入该类型作为参数，等会看代理类源码变一目了然了。
最后newInstance创建该代理类的实例，实现对ClassA对象的代理。
可能看完上述的介绍，你还会有点晕。下面我们通过查看动态生成的代理类的源码来加深理解。上述getProxyClass方法会动态创建一个代理类并返回他的Class类型，这个代理类一般被命名为$ProxyN，这个N是递增的用于标记不同的代理类。我们可以利用反编译工具反编译该class：
final class $Proxy0 extends Proxy implements MyInterface {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy0(InvocationHandler paramInvocationHandler) {
super(paramInvocationHandler);
}
public final boolean equals(Object paramObject) {
return ((Boolean) this.h.invoke(this, m1,
new Object[] { paramObject })).booleanValue();
}
public final void sayHello() {
this.h.invoke(this, m3, null);
}
public final String toString() {
return (String) this.h.invoke(this, m2, null);
}
public final int hashCode() {
return ((Integer) this.h.invoke(this, m0, null)).intValue();
}
static {
m1 = Class.forName("java.lang.Object").getMethod("equals",
new Class[] { Class.forName("java.lang.Object") });
m3 = Class.forName("laoma.demo.proxy.SimpleJDKDynamicProxyDemo$IService")
.getMethod("sayHello",new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
}
}
这就是上述的ClassA的动态代理类，我们看到该类的构造方法传入参数InvocationHandler类型，并调用了父类Proxy的构造方法保存了这个InvocationHandler实例，这也解释了我们为什么在获取构造器的时候需要指定参数类型为InvocationHandler，就是因为动态代理类只有一个构造器并且参数类型为InvocationHandler。
接着我们看其中的方法，貌似只有一个sayHello是我们知道的，别的方法哪来的？我们说过在动态创建代理类的时候，会实现原对象的所有接口。所以sayHello方法是实现的MyInterface。而其余的四个方法是代理类由于比较常用，被默认添加到其中。而这些方法的内部都是调用的this.h.invoke这个方法，this.h就是保存在父类Proxy中的InvocationHandler实例（我们用构造器向其中保存的），调用了这个类的invoke方法，在我们自定义的InvocationHandler实例中重写了invoke方法，我们写的比较简单，直接执行传入的method。
也就是我们调用代理类的任何一个方法都会转发到该InvocationHandler实例中的involve中，因为该实例中保存有我们的原对象，所以我们可以选择直接调取原对象中的方法作为回调。
以上便是有关Java SDK中动态代理的相关内容，稍微总结下，首先我们通过实现InvocationHandler自定义一个调用处理类，该类中会保存我们的原对象，并提供一个invoke方法供代理类使用。然后我们通过getProxyClass方法动态创建代理类，最后用反射获取代理类的实例对象。
需要注意的是：以上我们使用的四步创建代理实例时最根本的，其实Proxy中提供一个方法可以封装2到4步的操作。上述代码也可以这么写：
ClassA a = new ClassA();
MyInterface aProxy = (MyInterface)Proxy.newProxyInstance(ClassA.class.getClassLoader(),new Class<?>[]{MyInterface.class},new MyInvotion(a));
aProxy.sayHello();
我们打开该方法的内部源码，其实走的还是我们上述的过程，它就是做了封装。
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
{
Objects.requireNonNull(h);
//获取所有接口
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
//创建动态代理类
Class<?> cl = getProxyClass0(loader, intfs);
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
return cons.newInstance(new Object[]{h});
.............
..............
}
二、第三方库cglib实现动态代理
使用动态代理，我们编写通用的代码逻辑，即仅实现一个InvocationHandler实例完成对多个类型的代理。但是我们从动态生成的代理类的源码可以看到，所有的代理类都继承自Proxy这个类，这就导致我们这种方式不能代理类，只能代理接口。因为java中是单继承的。也就是说，给我们一个类型，我们只能动态实现该类所有的接口类型，但是该类继承的别的类我们在代理类中是不能使用的，因为它没有被代理类继承。下面看个例子：
public class ClassB {
public void welcome(){
System.out.println("welcom walker");
}
}
public interface MyInterface {
public void sayHello();
}
//需要被代理的原类型，继承了ClassB和接口MyInterface
public class ClassA extends ClassB implements MyInterface {
public void sayHello(){
System.out.println("hello walker");
}
}
//InvocationHandler 实例
public class MyInvotion implements InvocationHandler {
private Object realObj;
public MyInvotion(Object obj){
this.realObj = obj;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
return method.invoke(realObj,args);
}
}
我们反编译该代理类，和上述的源码是一样的，此处不再重复贴出。我们能从中看出来的是，我们的代理只会实现原类型中所有的接口，至于原类型所继承的类，在生成Proxy代理类的时候会丢弃，因为所有的代理类必须继承Proxy类，这就导致原类型的父类中的方法 在代理类中丢失。这是该种方式的一大弊端。下面我们看看另一种方式实现动态代理，该种方式完美解决了这种不足。
限于篇幅，我们下篇介绍cglib实现动态代理机制的内容，本篇暂时结束，总结的不好，望海涵。
