详细解读JAVA动态代理

引言

Java 动态代理机制的出现，使得 Java 开发人员不用手工编写代理类，只要简单地指定一组接口及委托类对象，便能动态地获得代理类。代理类会负责将所有的方法调用分派到委托对象上反射执行，在分派执行的过程中，开发人员还可以按需调整委托类对象及其功能，这是一套非常灵活有弹性的代理框架。通过阅读本文，读者将会对 Java 动态代理机制有更加深入的理解。本文首先从 Java 动态代理的运行机制和特点出发，对其代码进行了分析，推演了动态生成类的内部实现。

代理：设计模式

代理模式是Java常见的设计模式之一。所谓代理模式是指客户端并不直接调用实际的对象，而是通过调用代理，来间接的调用实际的对象。

为什么要采用这种间接的形式来调用对象呢？一般是因为客户端不想直接访问实际的对象，或者访问实际的对象存在困难，因此通过一个代理对象来完成间接的访问。

在现实生活中，这种情形非常的常见，比如请一个律师代理来打官司。

从UML图中，可以看出代理类与真正实现的类都是继承了抽象的主题类，这样的好处在于代理类可以与实际的类有相同的方法，可以保证客户端使用的透明性。

代理类实现：静态代理

代理模式的实现方式有两种，分别是静态代理和动态代理，我们先看静态代理的实现；

针对上图中的UML图，我们看下Subject 接口的code：

public interface Subject {

void visit();

}

RealSubject 的实现：

1public class RealSubject implements Subject{

2 @Override

3 public void visit() {

4 System.out.println("real visit....");

5 }

6}

ProxySubject 代理类的实现：

1public class ProxySubject implements Subject{

2

3 private Subject subject;

4

5 public ProxySubject(Subject subject){

6 this.subject = subject;

7 }

8

9 @Override

10 public void visit() {

11 System.out.println("before......");

12 subject.visit();

13 System.out.println("end.........");

14 }

15}

Client的实现：

1public class Client {

2 public static void main(String[] args) {

3 Subject realSubject = new RealSubject();

4 ProxySubject proxySubject = new ProxySubject(realSubject);

5 proxySubject.visit();

6 }

7}

执行结果如下：

1before......

2real visit....

3end.........

为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。静态代理的缺点也很明显，如果需要代理若干Subject，那么就需要implement若干Subject接口方法，而Java 动态代理机制以巧妙的方式近乎完美地实践了代理模式的设计理念。

代理实现：JAVA动态代理

动态代理有别于静态代理，是根据代理的对象，动态创建代理类。这样，就可以避免静态代理中代理类接口过多的问题。动态代理是实现方式，是通过反射来实现的，借助Java自带的java.lang.reflect.Proxy,通过固定的规则生成。

其步骤如下：

编写一个委托类的接口，即静态代理的（Subject接口）

实现一个真正的委托类，即静态代理的（RealSubject类）

创建一个动态代理类，实现InvocationHandler接口，并重写该invoke方法

在测试类中，生成动态代理的对象。

第一二步骤，和静态代理一样。我们主要看第三步，代码如下：

1public class JavaProxy implements InvocationHandler {

2

3 private Object object;

4

5 public JavaProxy(Object object) {

6 this.object = object;

7 }

8

9 @Override

10 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

11 System.out.println("before >>>>>>>>");

12 Object result = method.invoke(object, args);

13 System.out.println("end >>>>>>>>>>>");

14 return result;

15 }

16}

第四步，创建动态代理的对象

1 Subject realSubject = new RealSubject();

2 JavaProxy proxy = new JavaProxy(realSubject);

3 ClassLoader classLoader = realSubject.getClass().getClassLoader();

4 Subject subject = (Subject) Proxy.newProxyInstance(classLoader,new Class[]{Subject.class},proxy);

5 subject.visit();

运行结果如下：

1before >>>>>>>>

2real visit....

3end >>>>>>>>>>>

创建动态代理的对象，需要借助Proxy.newProxyInstance。该方法的三个参数分别是：

ClassLoader loader表示当前使用到的appClassloader。

Class[] interfaces表示目标对象实现的一组接口。

InvocationHandler h表示当前的InvocationHandler实现实例对象。

java 自带的动态代理为什么一定要实现接口

java自带的动态代理为什么一定要实现接口，其实这个问题也一直困扰着我，我们从创建代理函数看起，即

1public static Object newProxyInstance(ClassLoader loader,

2 Class

[] interfaces, InvocationHandler h)

3 throws IllegalArgumentException

通过源码可以看到，这个类第一步生成一个代理类（注意，这里的参数就是接口列表），

1Class cl = getProxyClass(loader, interfaces);

然后通过代理类找到构造参数为InvocationHandler的构造函数并生成一个新类。

1 final Constructor

cons = cl.getConstructor(constructorParams);

2 final InvocationHandler ih = h;

3if (!Modifier.isPublic(cl.getModifiers())) {

4 AccessController.doPrivileged(new PrivilegedAction

() {

5 public Void run() {

6 cons.setAccessible(true);

7 return null;

8 }

9 });

10 }

11 return cons.newInstance(new Object[]{ h });

接口起什么作用呢，于是又看getProxyClass方法的代码，这个源码很长，就不细说了。大致分为三段：

第一：验证

第二：缓存创建新类的结构，如果创建过，则直接返回。（注意：这里的KEY就是接口列表）

第三：如果没有创建过，则创建新类

创建代码的过程代码如下：

1 /*

2 * //获得代理类数字标识

3 */

4 long num = nextUniqueNumber.getAndIncrement();

5 String proxyName = proxyPkg + proxyClassNamePrefix + num;

6

7 /*

8 * 调用class处理文件生成类的字节码，根据接口列表创建一个新类，这个类为代理类，

9

10 */

11 byte[] proxyClassFile = ProxyGenerator.generateProxyClass(

12 proxyName, interfaces, accessFlags);

13 try {

14//通过JNI接口，将Class字节码文件定义一个新类

15 return defineClass0(loader, proxyName,

16 proxyClassFile, 0, proxyClassFile.length);

17 } catch (ClassFormatError e) {

18 /*

19 * A ClassFormatError here means that (barring bugs in the

20 * proxy class generation code) there was some other

21 * invalid aspect of the arguments supplied to the proxy

22 * class creation (such as virtual machine limitations

23 * exceeded).

24 */

25 throw new IllegalArgumentException(e.toString());

26 }

27 }

可以猜测到接口创建的新类proxyClassFile 不管采用什么接口，都是以下结构

1public class $Proxy1 extends Proxy implements 传入的接口{ }

生成新类的看不到源代码，不过猜测它的执行原理很有可能是如果类是Proxy的子类，则调用InvocationHandler进行方法的Invoke. 因为新生成的类已经extends 了Proxy，而且JAVA不能多继承，因此接口是最好的实现方式了。

JDK动态代理的原理是根据定义好的规则，用传入的接口创建一个新类，这就是为什么采用动态代理时为什么只能用接口引用指向代理，而不能用传入的类引用执行动态类。

动态代理实现：Cglib

cglib是针对类来实现代理的，原理是对指定的业务类生成一个子类，并覆盖其中业务方法实现代理。因为采用的是继承，所以不能对final修饰的类进行代理。

1、首先定义业务类，无需实现接口（当然，实现接口也可以，不影响的）

1public class MyBook {

2

3 void addBook(){

4 System.out.println("add book...");

5 }

6}

2、实现 MethodInterceptor方法代理接口，创建代理类

1public class MyCglibProxy implements MethodInterceptor {

2

3 @Override

4 public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

5

6 System.out.println("before——————");

7 Object result = methodProxy.invokeSuper(o, args); //调用业务类（父类中）的方法

8 System.out.println("end——————");

9

10 return result;

11 }

12}

3、创建业务类和代理类对象

1 MyBook myBook = new MyBook();

2

3 Enhancer enhancer = new Enhancer();

4 enhancer.setSuperclass(myBook.getClass());

5 //设置回调：对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept()方法进行拦

6 MyCglibProxy myCglibProxy = new MyCglibProxy();

7 enhancer.setCallback(myCglibProxy);

8 // 创建动态代理类对象并返回

9 MyBook book = (MyBook) enhancer.create();

10

11 book.addBook();

执行结果如下：

1before——————

2add book...

3end——————

总结

1、静态代理是通过在代码中显式定义一个业务实现类一个代理，在代理类中对同名的业务方法进行包装，用户通过代理类调用被包装过的业务方法；

2、JDK动态代理是通过接口中的方法名，在动态生成的代理类中调用业务实现类的同名方法；

3、CGlib动态代理是通过继承业务类，生成的动态代理类是业务类的子类，通过重写业务方法进行代理；