理解java动态代理

标签：

      java动态代理是java语言的一项高级特性。在平时的项目开发中，可能很难遇到动态代理的案例。但是动态代理在很多框架中起着不可替代的作用，例如Spring的AOP。今天我们就聊一聊java动态代理的实现原理。

     jdk对于动态代理的支持主要依赖于两个类：Proxy和InvocationHandler。我们先看一下类图。

　　Subject类是主题类，定义了我要做什么。我们需要代理的类即实现Subject接口的RealSubject。

　　1.InvocationHandler

　　InvocationHandler接口是jdk提供的接口，这个接口只有一个方法

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

      我们先了解下InvocationHandler这个类是做什么。以下是java doc

* <p>Each proxy instance has an associated invocation handler.
* When a method is invoked on a proxy instance, the method
* invocation is encoded and dispatched to the {@code invoke}
* method of its invocation handler.

　　每一个代理实例都会和一个invocation handler关联，准确的说，每一个proxy类都会持有一个InvocationHandler实例，并且将目标函数交给InvcationHandler实例去执行。InvocationHandler只有invoke()这个方法，这个方法即实际被调用的方法。不管代理调用的是何种方法，处理器被调用的一定是invoke()方法。下面我们看看这个方法的参数。

　　1. Object proxy。传入的Subject引用，即我们想要真正执行的目标对象。

　　2. Method method。Method是java reflection API的一部分。这里传入的method对象，是实际被调用的method方法。

　　3. Object[] args。这是方法调用时传入的参数数组。

　　了解invoke()方法后，读者一定想知道，Subject的目标方法是怎么被调用的呢？接下来我们继续了解Proxy类。

　　2. Proxy

　　接下来我们了解下Proxy类是如何与InvocationHandler一共工作的。java doc中对Proxy的介绍如下：

* provides static methods for creating dynamic proxy
* classes and instances, and it is also the superclass of all
* dynamic proxy classes created by those methods.

　　Proxy提供了一个静态方法去创建动态代理类，最常用的就是下面这个方法了。

 public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

　　利用newProxyInstance可以动态的创建所需要的代理对象，并且和与它关联的InvocationHandler绑定。参数如下

　　1. ClassLoader loader, 加载代理类的类加载器。

　　2. Class<?>[] interfaces, 代理类实现的接口。创建的代理类对象，只能强转为该interfaces的子类。

　　3. InvocationHandler h, 代理类所关联的InvocationHandler。所有被代理的方法都会通过该InvocationHandler的invoke()方法执行。

　　newProxyInstance方法是生成代理类的关键方法，代理类在程序运行的过程中生成，因而叫做动态代理。

　　3. 案例

　　了解了这两个最重要的类之后，我们需要通过一个实例来帮助我们更好的理解动态代理的运行机制。

　　首先我们创建一个Subject接口以及其实现类。

　　步骤1. 定义Subject

 1 public interface Subject {
 2 
 3     public void say(String str);
 4 }
 5 
 6 public class SubjectBean implements Subject {
 7 
 8     @Override
 9     public void say(String str) {
10         System.out.println(str);
11     }
12 }

 　　Subject的say方法是我们需要代理的方法。在该方法的前后我们不妨做一些额外的操作。接下来我们定义我们的InvocationHandler。

　　步骤2. 定义InvocationHandler

 1 public class MyInvocationHandle implements InvocationHandler {
 2 
 3     Subject subject;
 4 
 5     public MyInvocationHandle(Subject subject) {
 6         this.subject = subject;
 7     }
 8 
 9     @Override
10     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
11         System.out.println("pre");
12         method.invoke(subject, args);
13         System.out.println("post");
14         return null;
15     }
16 
17 }

　　通过构造器，把被代理的对象传入。

　　步骤3. 定义生成代理类方法实现

public class Main {

    public static Subject getProxy(Subject subject){
        return (Subject) Proxy.newProxyInstance(subject.getClass().getClassLoader(),
                subject.getClass().getInterfaces(),
                new MyInvocationHandle(subject));
    }

    public static void main(String[] args) {
        Subject subject = new SubjectBean();
        Subject proxy =  getProxy(subject);
        proxy.say("hello");
    }
}

　　执行main函数，最后输出的结果为：

　可见，say()函数真正method.invoke(subject, args)这里完成的。在执行前后可以加入任意代码片段，完成对say()方法的增强操作。

　4. debug

　　我们对main方法debug看看，proxy类到底是什么。如下图

　　com.sun.proxy.$Proxy()类，是Proxy.newProxyInstance被调用后在jvm运行时动态生成的一个对象，命名方式都是这样的形式，以$开头，proxy为中，最后一个数字表示对象的标号。至于它为什么可以转为Subject，是因为我们在传入的第二个参数中，规定了它的类型信息。

　　这篇文章主要简述了java动态代理的实现机制。如有错误之处，还望读者多多指教。

　　参考文献：

　《Head First设计模式》

理解java动态代理

标签：

原文地址：http://www.cnblogs.com/maypattis/p/5495801.html