Java动态代理

java动态代理的类和接口（jdk1.6源码）

1，java.lang.reflect.Proxy：动态代理机制的主类，提供一组静态方法为一组接口动态的生成对象和代理类。

// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器public static InvocationHandler getInvocationHandler(Object proxy) // 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces)// 方法 3：该方法用于判断指定类对象是否是一个动态代理类public static boolean isProxyClass(Class<?> cl) // 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)
1
2
3
4
5
6
7
8
9
10
11
12
13

2，java.lang.reflect.InvocationHandler：调用处理器接口，自定义invokle方法，用于实现对于真正委托类的代理访问。

/** 该方法负责集中处理动态代理类上的所有方法调用。 第一个参数既是代理类实例， 第二个参数是被调用的方法对象 第三个方法是调用参数。 调用处理器根据这三个参数进行预处理或分派到委托类实例上发射执行*/public Object invoke(Object proxy, Method method, Object[] args)    throws Throwable;
1
2
3
4
5
6
7
8
9

3，java.lang.ClassLoader：类装载器类，将类的字节码装载到 Java 虚拟机（JVM）中并为其定义类对象，然后该类才能被使用。Proxy类与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。 
每次生成动态代理类对象时都需要指定一个类装载器对象：newProxyInstance()方法第一个参数

动态代理机制

java动态代理创建对象的过程为如下步骤： 
1，通过实现 InvocationHandler 接口创建自己的调用处理器；

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用InvocationHandler handler = new InvocationHandlerImpl(..); 
1
2
3

2，通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；

// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); 
1
2

3，通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；

// 通过反射从生成的类对象获得构造函数对象Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });
1
2

4，通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

// 通过构造函数对象创建动态代理类实例Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });
1
2

为了简化对象创建过程，Proxy类中的newProxyInstance方法封装了2~4，只需两步即可完成代理对象的创建。

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 直接创建动态代理类实例Interface proxy = (Interface)Proxy.newProxyInstance( classLoader,      new Class[] { Interface.class },      handler );
1
2
3
4
5
6
7

动态代理的注意点： 
1，包：代理接口是public，则代理类被定义在顶层包(package为空)，否则(default)，代理类被定义在该接口所在包，

2，生成的代理类为public final，不能被继承，

3，类名：格式是“$ProxyN”，N是逐一递增的数字，代表Proxy被第N次动态生成的代理类，要注意，对于同一组接口(接口的排列顺序也相同)，不会重复创建动态代理类，而是返回一个先前已经创建并缓存了的代理类对象。提高了效率。

4，类继承关系：

 
Proxy 类是它的父类，这个规则适用于所有由 Proxy 创建的动态代理类。(也算是java动态代理的一处缺陷，java不支持多继承，所以无法实现对class的动态代理，只能对于Interface的代理)而且该类还实现了其所代理的一组接口，这就是为什么它能够被安全地类型转换到其所代理的某接口的根本原因。

5，代理类的根类 java.lang.Object 中有三个方法也同样会被分派到调用处理器的 invoke 方法执行，它们是 hashCode，equals 和 toString， 
代码在反编译中 

一个动态代理的demo

import java.lang.reflect.InvocationHandler;  import java.lang.reflect.Method;  import java.lang.reflect.Proxy;  public class HelloServiceProxy implements InvocationHandler {      private Object target;        /**       * 绑定委托对象并返回一个【代理占位】      * @param target 真实对象      * @return  代理对象【占位】      */        public  Object bind(Object target, Class[] interfaces) {            this.target = target;            //取得代理对象           return Proxy.newProxyInstance(target.getClass().getClassLoader(),                    target.getClass().getInterfaces(), this);    }        @Override        /**      * 同过代理对象调用方法首先进入这个方法.      * @param proxy --代理对象      * @param method -- 方法,被调用方法.      * @param args -- 方法的参数      */      public Object invoke(Object proxy , Method method, Object[] args) throws Throwable {            System.err.println("############我是JDK动态代理################");          Object result = null;            //反射方法前调用          System.err.println("我准备说hello。");            //反射执行方法  相当于调用target.sayHelllo;          result=method.invoke(target, args);          //反射方法后调用.          System.err.println("我说过hello了");            return result;        }    } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

其中，bind方法中的newProxyInstanc方法，就是生成一个代理对象，第一个参数是类加载器，第二个参数是真实委托对象所实现的的接口（代理对象挂在那个接口下），第三个参数this代表当前HelloServiceProxy类，换句话说是使用HelloServiceProxy作为对象的代理。

invoke方法有三个参数：第一个proxy是代理对象，第二个是当前调用那个方法，第三个是方法的参数。

public class ProxyTest {      public static void main(String[] args) {           HelloServiceProxy proxy = new HelloServiceProxy();          HelloService service = new HelloServiceImpl();          //绑定代理对象。          service = (HelloService) proxy.bind(service, new Class[] {HelloService.class});          //这里service经过绑定，就会进入invoke方法里面了。          service.sayHello("张三");      }  }  
1
2
3
4
5
6
7
8
9
10
11

测试结果：

############我是JDK动态代理################  我准备说hello。  hello 张三  我说过hello了
1
2
3
4

源码跟踪

Proxy 类

// 映射表：用于维护类装载器对象到其对应的代理类缓存private static Map loaderToCache = new WeakHashMap(); // 标记：用于标记一个动态代理类正在被创建中private static Object pendingGenerationMarker = new Object(); // 同步表：记录已经被创建的动态代理类类型，主要被方法 isProxyClass 进行相关的判断private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap()); // 关联的调用处理器引用protected InvocationHandler h;
1
2
3
4
5
6
7
8
9
10
11

Proxy 静态方法 newProxyInstance

public static Object newProxyInstance(ClassLoader loader,             Class<?>[] interfaces,             InvocationHandler h)             throws IllegalArgumentException {     // 检查 h 不为空，否则抛异常    if (h == null) {         throw new NullPointerException();     }     // 获得与制定类装载器和一组接口相关的代理类类型对象    /*     * Look up or generate the designated proxy class.     */        Class<?> cl = getProxyClass0(loader, interfaces);     // 通过反射获取构造函数对象并生成代理类实例    /*     * Invoke its constructor with the designated invocation handler.     */    try {            final Constructor<?> cons = cl.getConstructor(constructorParams);            final InvocationHandler ih = h;            SecurityManager sm = System.getSecurityManager();            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {                // create proxy instance with doPrivilege as the proxy class may                // implement non-public interfaces that requires a special permission                return AccessController.doPrivileged(new PrivilegedAction<Object>() {                    public Object run() {                        return newInstance(cons, ih);                    }                });            } else {                return newInstance(cons, ih);            }    } catch (NoSuchMethodException e) {        throw new InternalError(e.toString());    }     }private static Object newInstance(Constructor<?> cons, InvocationHandler h) {        try {            return cons.newInstance(new Object[] {h} );        } catch (IllegalAccessException e) {            throw new InternalError(e.toString());        } catch (InstantiationException e) {            throw new InternalError(e.toString());        } catch (InvocationTargetException e) {            Throwable t = e.getCause();            if (t instanceof RuntimeException) {                throw (RuntimeException) t;            } else {                throw new InternalError(t.toString());            }        }    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

动态代理真正的关键是在 getProxyClass0 方法，

getProxyClass0方法分析

方法分为四个步骤： 
1，对这组接口进行一定程度的安全检查 
检查接口类对象是否对类装载器可见并且与类装载器所能识别的接口类对象是完全相同的，还会检查确保是 interface 类型而不是 class 类型。

2，从 loaderToCache 映射表中获取以类装载器对象为关键字所对应的缓存表，如果不存在就创建一个新的缓存表并更新到 loaderToCache。 
loaderToCache存放键值对（接口名字列表，动态生成的代理类的类对象引用）。当代理类正在被创建时它会临时保存（接口名字列表，pendingGenerationMarker）。标记 pendingGenerationMarke 的作用是通知后续的同类请求（接口数组相同且组内接口排列顺序也相同）代理类正在被创建，请保持等待直至创建完成。

/*     * Find or create the proxy class cache for the class loader.     */    Map cache;    synchronized (loaderToCache) {        cache = (Map) loaderToCache.get(loader);        if (cache == null) {        cache = new HashMap();        loaderToCache.put(loader, cache);        }     }。。。。。do {     // 以接口名字列表作为关键字获得对应 cache 值    Object value = cache.get(key);     if (value instanceof Reference) {         proxyClass = (Class) ((Reference) value).get();     }     if (proxyClass != null) {         // 如果已经创建，直接返回        return proxyClass;     } else if (value == pendingGenerationMarker) {         // 代理类正在被创建，保持等待        try {             cache.wait();         } catch (InterruptedException e) {         }         // 等待被唤醒，继续循环并通过二次检查以确保创建完成，否则重新等待        continue;     } else {         // 标记代理类正在被创建        cache.put(key, pendingGenerationMarker);         // break 跳出循环已进入创建过程        break; } while (true);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

3，动态创建代理类的class对象

/**         * Choose a name for the proxy class to generate.         */        long num;        synchronized (nextUniqueNumberLock) {            num = nextUniqueNumber++;        }        String proxyName = proxyPkg + proxyClassNamePrefix + num;        /*         * Verify that the class loader hasn't already         * defined a class with the chosen name.         */        // 动态地生成代理类的字节码数组        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(            proxyName, interfaces);        try {        // 动态地定义新生成的代理类            proxyClass = defineClass0(loader, proxyName,            proxyClassFile, 0, proxyClassFile.length);        } catch (ClassFormatError e) {            /*             * A ClassFormatError here means that (barring bugs in the             * proxy class generation code) there was some other             * invalid aspect of the arguments supplied to the proxy             * class creation (such as virtual machine limitations             * exceeded).             */            throw new IllegalArgumentException(e.toString());        }        // 把生成的代理类的类对象记录进 proxyClasses 表        proxyClasses.put(proxyClass, null);             
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

首先根据规则(接口public与否)，生成代理类的名称，$ProxyN格式，然后动态生成代理类。 
所有的代码生成的工作都由 ProxyGenerator 所完成了，该类在rt.jar中，需要反编译

public static byte[] generateProxyClass(final String name,                                             Class[] interfaces)     {         ProxyGenerator gen = new ProxyGenerator(name, interfaces);      // 这里动态生成代理类的字节码，由于比较复杂就不进去看了         final byte[] classFile = gen.generateClassFile();      // 如果saveGeneratedFiles的值为true，则会把所生成的代理类的字节码保存到硬盘上         if (saveGeneratedFiles) {             java.security.AccessController.doPrivileged(             new java.security.PrivilegedAction<Void>() {                 public Void run() {                     try {                         FileOutputStream file =                             new FileOutputStream(dotToSlash(name) + ".class");                         file.write(classFile);                         file.close();                         return null;                     } catch (IOException e) {                         throw new InternalError(                             "I/O exception saving generated file: " + e);                     }                 }             });         }      // 返回代理类的字节码         return classFile;     }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

4，代码生成过程进入结尾部分，根据结果更新缓存表，如果成功则将代理类的类对象引用更新进缓存表，否则清楚缓存表中对应关键值，最后唤醒所有可能的正在等待的线程。

finally {        /*         * We must clean up the "pending generation" state of the proxy         * class cache entry somehow.  If a proxy class was successfully         * generated, store it in the cache (with a weak reference);         * otherwise, remove the reserved entry.  In all cases, notify         * all waiters on reserved entries in this cache.         */        synchronized (cache) {        if (proxyClass != null) {            cache.put(key, new WeakReference(proxyClass));        } else {            cache.remove(key);        }        cache.notifyAll();        }    }    return proxyClass;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

InvocationHandler解析

代码参考：http://rejoy.iteye.com/blog/1627405 
通过getProxyClass0方法中生成具体的class文件的过程，定义path，讲class文件写到指定的磁盘中，反编译生成的代理class文件。 
发现在静态代码块中获取了的方法有：Object中的equals方法、Object中的hashCode方法、Object中toString方法 , 以及invoke的接口方法。

Java代码  

1. package dynamic.proxy;   
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Proxy;  
6.   
7. /** 
8.  * 实现自己的InvocationHandler 
9.  * @author zyb 
10.  * @since 2012-8-9 
11.  * 
12.  */  
13. public class MyInvocationHandler implements InvocationHandler {  
14.       
15.     // 目标对象   
16.     private Object target;  
17.       
18.     /** 
19.      * 构造方法 
20.      * @param target 目标对象  
21.      */  
22.     public MyInvocationHandler(Object target) {  
23.         super();  
24.         this.target = target;  
25.     }  
26.   
27.   
28.     /** 
29.      * 执行目标对象的方法 
30.      */  
31.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
32.           
33.         // 在目标对象的方法执行之前简单的打印一下  
34.         System.out.println("------------------before------------------");  
35.           
36.         // 执行目标对象的方法  
37.         Object result = method.invoke(target, args);  
38.           
39.         // 在目标对象的方法执行之后简单的打印一下  
40.         System.out.println("-------------------after------------------");  
41.           
42.         return result;  
43.     }  
44.   
45.     /** 
46.      * 获取目标对象的代理对象 
47.      * @return 代理对象 
48.      */  
49.     public Object getProxy() {  
50.         return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),   
51.                 target.getClass().getInterfaces(), this);  
52.     }  
53. }  
54.   
55. package dynamic.proxy;  
56.   
57. /** 
58.  * 目标对象实现的接口，用JDK来生成代理对象一定要实现一个接口 
59.  * @author zyb 
60.  * @since 2012-8-9 
61.  * 
62.  */  
63. public interface UserService {  
64.   
65.     /** 
66.      * 目标方法  
67.      */  
68.     public abstract void add();  
69.   
70. }  
71.   
72. package dynamic.proxy;   
73.   
74. /** 
75.  * 目标对象 
76.  * @author zyb 
77.  * @since 2012-8-9 
78.  * 
79.  */  
80. public class UserServiceImpl implements UserService {  
81.   
82.     /* (non-Javadoc) 
83.      * @see dynamic.proxy.UserService#add() 
84.      */  
85.     public void add() {  
86.         System.out.println("--------------------add---------------");  
87.     }  
88. }  
89.   
90. package dynamic.proxy;   
91.   
92. import org.junit.Test;  
93.   
94. /** 
95.  * 动态代理测试类 
96.  * @author zyb 
97.  * @since 2012-8-9 
98.  * 
99.  */  
100. public class ProxyTest {  
101.   
102.     @Test  
103.     public void testProxy() throws Throwable {  
104.         // 实例化目标对象  
105.         UserService userService = new UserServiceImpl();  
106.           
107.         // 实例化InvocationHandler  
108.         MyInvocationHandler invocationHandler = new MyInvocationHandler(userService);  
109.           
110.         // 根据目标对象生成代理对象  
111.         UserService proxy = (UserService) invocationHandler.getProxy();  
112.           
113.         // 调用代理对象的方法  
114.         proxy.add();  
115.           
116.     }  
117. }  

执行结果如下： 
------------------before------------------ 
--------------------add--------------- 
-------------------after------------------ 

   用起来是很简单吧，其实这里基本上就是AOP的一个简单实现了，在目标对象的方法执行之前和执行之后进行了增强。Spring的AOP实现其实也是用了Proxy和InvocationHandler这两个东西的。 

    用起来是比较简单，但是如果能知道它背后做了些什么手脚，那就更好不过了。首先来看一下JDK是怎样生成代理对象的。既然生成代理对象是用的Proxy类的静态方newProxyInstance，那么我们就去它的源码里看一下它到底都做了些什么？ 

Java代码  

1. /** 
2.  * loader:类加载器 
3.  * interfaces:目标对象实现的接口 
4.  * h:InvocationHandler的实现类 
5.  */  
6. public static Object newProxyInstance(ClassLoader loader,  
7.                       Class<?>[] interfaces,  
8.                       InvocationHandler h)  
9.     throws IllegalArgumentException  
10.     {  
11.     if (h == null) {  
12.         throw new NullPointerException();  
13.     }  
14.   
15.     /* 
16.      * Look up or generate the designated proxy class. 
17.      */  
18.     Class cl = getProxyClass(loader, interfaces);  
19.   
20.     /* 
21.      * Invoke its constructor with the designated invocation handler. 
22.      */  
23.     try {  
24.             // 调用代理对象的构造方法（也就是$Proxy0(InvocationHandler h)）  
25.         Constructor cons = cl.getConstructor(constructorParams);  
26.             // 生成代理类的实例并把MyInvocationHandler的实例传给它的构造方法  
27.         return (Object) cons.newInstance(new Object[] { h });  
28.     } catch (NoSuchMethodException e) {  
29.         throw new InternalError(e.toString());  
30.     } catch (IllegalAccessException e) {  
31.         throw new InternalError(e.toString());  
32.     } catch (InstantiationException e) {  
33.         throw new InternalError(e.toString());  
34.     } catch (InvocationTargetException e) {  
35.         throw new InternalError(e.toString());  
36.     }  
37.     }  

   我们再进去getProxyClass方法看一下 

Java代码  

1. public static Class<?> getProxyClass(ClassLoader loader,   
2.                                          Class<?>... interfaces)  
3.     throws IllegalArgumentException  
4.     {  
5.     // 如果目标类实现的接口数大于65535个则抛出异常（我XX，谁会写这么NB的代码啊？）  
6.     if (interfaces.length > 65535) {  
7.         throw new IllegalArgumentException("interface limit exceeded");  
8.     }  
9.   
10.     // 声明代理对象所代表的Class对象（有点拗口）  
11.     Class proxyClass = null;  
12.   
13.     String[] interfaceNames = new String[interfaces.length];  
14.   
15.     Set interfaceSet = new HashSet();   // for detecting duplicates  
16.   
17.     // 遍历目标类所实现的接口  
18.     for (int i = 0; i < interfaces.length; i++) {  
19.           
20.         // 拿到目标类实现的接口的名称  
21.         String interfaceName = interfaces[i].getName();  
22.         Class interfaceClass = null;  
23.         try {  
24.         // 加载目标类实现的接口到内存中  
25.         interfaceClass = Class.forName(interfaceName, false, loader);  
26.         } catch (ClassNotFoundException e) {  
27.         }  
28.         if (interfaceClass != interfaces[i]) {  
29.         throw new IllegalArgumentException(  
30.             interfaces[i] + " is not visible from class loader");  
31.         }  
32.   
33.         // 中间省略了一些无关紧要的代码 .......  
34.           
35.         // 把目标类实现的接口代表的Class对象放到Set中  
36.         interfaceSet.add(interfaceClass);  
37.   
38.         interfaceNames[i] = interfaceName;  
39.     }  
40.   
41.     // 把目标类实现的接口名称作为缓存（Map）中的key  
42.     Object key = Arrays.asList(interfaceNames);  
43.   
44.     Map cache;  
45.       
46.     synchronized (loaderToCache) {  
47.         // 从缓存中获取cache  
48.         cache = (Map) loaderToCache.get(loader);  
49.         if (cache == null) {  
50.         // 如果获取不到，则新建地个HashMap实例  
51.         cache = new HashMap();  
52.         // 把HashMap实例和当前加载器放到缓存中  
53.         loaderToCache.put(loader, cache);  
54.         }  
55.   
56.     }  
57.   
58.     synchronized (cache) {  
59.   
60.         do {  
61.         // 根据接口的名称从缓存中获取对象  
62.         Object value = cache.get(key);  
63.         if (value instanceof Reference) {  
64.             proxyClass = (Class) ((Reference) value).get();  
65.         }  
66.         if (proxyClass != null) {  
67.             // 如果代理对象的Class实例已经存在，则直接返回  
68.             return proxyClass;  
69.         } else if (value == pendingGenerationMarker) {  
70.             try {  
71.             cache.wait();  
72.             } catch (InterruptedException e) {  
73.             }  
74.             continue;  
75.         } else {  
76.             cache.put(key, pendingGenerationMarker);  
77.             break;  
78.         }  
79.         } while (true);  
80.     }  
81.   
82.     try {  
83.         // 中间省略了一些代码 .......  
84.           
85.         // 这里就是动态生成代理对象的最关键的地方  
86.         byte[] proxyClassFile = ProxyGenerator.generateProxyClass(  
87.             proxyName, interfaces);  
88.         try {  
89.             // 根据代理类的字节码生成代理类的实例  
90.             proxyClass = defineClass0(loader, proxyName,  
91.             proxyClassFile, 0, proxyClassFile.length);  
92.         } catch (ClassFormatError e) {  
93.             throw new IllegalArgumentException(e.toString());  
94.         }  
95.         }  
96.         // add to set of all generated proxy classes, for isProxyClass  
97.         proxyClasses.put(proxyClass, null);  
98.   
99.     }   
100.     // 中间省略了一些代码 .......  
101.       
102.     return proxyClass;  
103.     }  

进去ProxyGenerator类的静态方法generateProxyClass，这里是真正生成代理类class字节码的地方。 

Java代码  

1. public static byte[] generateProxyClass(final String name,  
2.                                            Class[] interfaces)  
3.    {  
4.        ProxyGenerator gen = new ProxyGenerator(name, interfaces);  
5.     // 这里动态生成代理类的字节码，由于比较复杂就不进去看了  
6.        final byte[] classFile = gen.generateClassFile();  
7.   
8.     // 如果saveGeneratedFiles的值为true，则会把所生成的代理类的字节码保存到硬盘上  
9.        if (saveGeneratedFiles) {  
10.            java.security.AccessController.doPrivileged(  
11.            new java.security.PrivilegedAction<Void>() {  
12.                public Void run() {  
13.                    try {  
14.                        FileOutputStream file =  
15.                            new FileOutputStream(dotToSlash(name) + ".class");  
16.                        file.write(classFile);  
17.                        file.close();  
18.                        return null;  
19.                    } catch (IOException e) {  
20.                        throw new InternalError(  
21.                            "I/O exception saving generated file: " + e);  
22.                    }  
23.                }  
24.            });  
25.        }  
26.   
27.     // 返回代理类的字节码  
28.        return classFile;  
29.    }  

现在，JDK是怎样动态生成代理类的字节的原理已经一目了然了。 

好了，再来解决另外一个问题，那就是由谁来调用InvocationHandler的invoke方法的。要解决这个问题就要看一下JDK到底为我们生成了一个什么东西。用以下代码可以获取到JDK为我们生成的字节码并写到硬盘中。 

Java代码  

1. package dynamic.proxy;   
2.   
3. import java.io.FileOutputStream;  
4. import java.io.IOException;  
5.   
6. import sun.misc.ProxyGenerator;  
7.   
8. /** 
9.  * 代理类的生成工具 
10.  * @author zyb 
11.  * @since 2012-8-9 
12.  */  
13. public class ProxyGeneratorUtils {  
14.   
15.     /** 
16.      * 把代理类的字节码写到硬盘上 
17.      * @param path 保存路径 
18.      */  
19.     public static void writeProxyClassToHardDisk(String path) {  
20.         // 第一种方法，这种方式在刚才分析ProxyGenerator时已经知道了  
21.         // System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", true);  
22.           
23.         // 第二种方法  
24.           
25.         // 获取代理类的字节码  
26.         byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy11", UserServiceImpl.class.getInterfaces());  
27.           
28.         FileOutputStream out = null;  
29.           
30.         try {  
31.             out = new FileOutputStream(path);  
32.             out.write(classFile);  
33.             out.flush();  
34.         } catch (Exception e) {  
35.             e.printStackTrace();  
36.         } finally {  
37.             try {  
38.                 out.close();  
39.             } catch (IOException e) {  
40.                 e.printStackTrace();  
41.             }  
42.         }  
43.     }  
44. }  
45.   
46. package dynamic.proxy;   
47.   
48. import org.junit.Test;  
49.   
50. /** 
51.  * 动态代理测试类 
52.  * @author zyb 
53.  * @since 2012-8-9 
54.  * 
55.  */  
56. public class ProxyTest {  
57.   
58.     @Test  
59.     public void testProxy() throws Throwable {  
60.         // 实例化目标对象  
61.         UserService userService = new UserServiceImpl();  
62.           
63.         // 实例化InvocationHandler  
64.         MyInvocationHandler invocationHandler = new MyInvocationHandler(userService);  
65.           
66.         // 根据目标对象生成代理对象  
67.         UserService proxy = (UserService) invocationHandler.getProxy();  
68.           
69.         // 调用代理对象的方法  
70.         proxy.add();  
71.           
72.     }  
73.       
74.     @Test  
75.     public void testGenerateProxyClass() {  
76.         ProxyGeneratorUtils.writeProxyClassToHardDisk("F:/$Proxy11.class");  
77.     }  
78. }  

通过以上代码，就可以在F盘上生成一个$Proxy.class文件了，现在用反编译工具来看一下这个class文件里面的内容。 

Java代码  

1. // Decompiled by DJ v3.11.11.95 Copyright 2009 Atanas Neshkov  Date: 2012/8/9 20:11:32  
2. // Home Page: http://members.fortunecity.com/neshkov/dj.html  http://www.neshkov.com/dj.html - Check often for new version!  
3. // Decompiler options: packimports(3)   
4.   
5. import dynamic.proxy.UserService;  
6. import java.lang.reflect.*;  
7.   
8. public final class $Proxy11 extends Proxy  
9.     implements UserService  
10. {  
11.   
12.     // 构造方法，参数就是刚才传过来的MyInvocationHandler类的实例  
13.     public $Proxy11(InvocationHandler invocationhandler)  
14.     {  
15.         super(invocationhandler);  
16.     }  
17.   
18.     public final boolean equals(Object obj)  
19.     {  
20.         try  
21.         {  
22.             return ((Boolean)super.h.invoke(this, m1, new Object[] {  
23.                 obj  
24.             })).booleanValue();  
25.         }  
26.         catch(Error _ex) { }  
27.         catch(Throwable throwable)  
28.         {  
29.             throw new UndeclaredThrowableException(throwable);  
30.         }  
31.     }  
32.   
33.     /** 
34.      * 这个方法是关键部分 
35.      */  
36.     public final void add()  
37.     {  
38.         try  
39.         {  
40.             // 实际上就是调用MyInvocationHandler的public Object invoke(Object proxy, Method method, Object[] args)方法，第二个问题就解决了  
41.             super.h.invoke(this, m3, null);  
42.             return;  
43.         }  
44.         catch(Error _ex) { }  
45.         catch(Throwable throwable)  
46.         {  
47.             throw new UndeclaredThrowableException(throwable);  
48.         }  
49.     }  
50.   
51.     public final int hashCode()  
52.     {  
53.         try  
54.         {  
55.             return ((Integer)super.h.invoke(this, m0, null)).intValue();  
56.         }  
57.         catch(Error _ex) { }  
58.         catch(Throwable throwable)  
59.         {  
60.             throw new UndeclaredThrowableException(throwable);  
61.         }  
62.     }  
63.   
64.     public final String toString()  
65.     {  
66.         try  
67.         {  
68.             return (String)super.h.invoke(this, m2, null);  
69.         }  
70.         catch(Error _ex) { }  
71.         catch(Throwable throwable)  
72.         {  
73.             throw new UndeclaredThrowableException(throwable);  
74.         }  
75.     }  
76.   
77.     private static Method m1;  
78.     private static Method m3;  
79.     private static Method m0;  
80.     private static Method m2;  
81.   
82.     // 在静态代码块中获取了4个方法：Object中的equals方法、UserService中的add方法、Object中的hashCode方法、Object中toString方法  
83.     static   
84.     {  
85.         try  
86.         {  
87.             m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {  
88.                 Class.forName("java.lang.Object")  
89.             });  
90.             m3 = Class.forName("dynamic.proxy.UserService").getMethod("add", new Class[0]);  
91.             m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);  
92.             m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);  
93.         }  
94.         catch(NoSuchMethodException nosuchmethodexception)  
95.         {  
96.             throw new NoSuchMethodError(nosuchmethodexception.getMessage());  
97.         }  
98.         catch(ClassNotFoundException classnotfoundexception)  
99.         {  
100.             throw new NoClassDefFoundError(classnotfoundexception.getMessage());  
101.         }  
102.     }  
103. }  

在学习Spring的时候，我们知道Spring主要有两大思想，一个是IoC，另一个就是AOP，对于IoC，依赖注入就不用多说了，而对于Spring的核心AOP来说，我们不但要知道怎么通过AOP来满足的我们的功能，我们更需要学习的是其底层是怎么样的一个原理，而AOP的原理就是java的动态代理机制，所以本篇随笔就是对java的动态机制进行一个回顾。

在java的动态代理机制中，有两个重要的类或接口，一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)，这一个类和接口是实现我们动态代理所必须用到的。首先我们先来看看java的API帮助文档是怎么样对这两个类进行描述的：

InvocationHandler:

InvocationHandler is the interface implemented by the invocation handler of a proxy instance. 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 invoke method of its invocation handler.

每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法：

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

我们看到这个方法一共接受三个参数，那么这三个参数分别代表什么呢？

Object invoke(Object proxy, Method method, Object[] args) throws Throwableproxy:　　指代我们所代理的那个真实对象method:　　指代的是我们所要调用真实对象的某个方法的Method对象args:　　指代的是调用真实对象某个方法时接受的参数

如果不是很明白，等下通过一个实例会对这几个参数进行更深的讲解。

接下来我们来看看Proxy这个类：

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这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是 newProxyInstance 这个方法：

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

Returns an instance of a proxy class for the specified interfaces that dispatches method invocations to the specified invocation handler.

这个方法的作用就是得到一个动态的代理对象，其接收三个参数，我们来看看这三个参数所代表的含义：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentExceptionloader:　　一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载interfaces:　　一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了h:　　一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

好了，在介绍完这两个接口(类)以后，我们来通过一个实例来看看我们的动态代理模式是什么样的：

首先我们定义了一个Subject类型的接口，为其声明了两个方法：

public interface Subject{    public void rent();        public void hello(String str);}

接着，定义了一个类来实现这个接口，这个类就是我们的真实对象，RealSubject类：

public class RealSubject implements Subject{    @Override    public void rent()    {        System.out.println("I want to rent my house");    }        @Override    public void hello(String str)    {        System.out.println("hello: " + str);    }}

下一步，我们就要定义一个动态代理类了，前面说个，每一个动态代理类都必须要实现 InvocationHandler 这个接口，因此我们这个动态代理类也不例外：

public class DynamicProxy implements InvocationHandler{    //　这个就是我们要代理的真实对象    private Object subject;        //    构造方法，给我们要代理的真实对象赋初值    public DynamicProxy(Object subject)    {        this.subject = subject;    }        @Override    public Object invoke(Object object, Method method, Object[] args)            throws Throwable    {        //　　在代理真实对象前我们可以添加一些自己的操作        System.out.println("before rent house");                System.out.println("Method:" + method);                //    当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用        method.invoke(subject, args);                //　　在代理真实对象后我们也可以添加一些自己的操作        System.out.println("after rent house");                return null;    }}

最后，来看看我们的Client类：

public class Client{    public static void main(String[] args)    {        //    我们要代理的真实对象        Subject realSubject = new RealSubject();        //    我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的        InvocationHandler handler = new DynamicProxy(realSubject);        /*         * 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数         * 第一个参数 handler.getClass().getClassLoader() ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象         * 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了         * 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上         */        Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject                .getClass().getInterfaces(), handler);                System.out.println(subject.getClass().getName());        subject.rent();        subject.hello("world");    }}

我们先来看看控制台的输出：

$Proxy0
before rent houseMethod:public abstract void com.xiaoluo.dynamicproxy.Subject.rent()I want to rent my houseafter rent house
before rent houseMethod:public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java.lang.String)hello: worldafter rent house

我们首先来看看 $Proxy0 这东西，我们看到，这个东西是由 System.out.println(subject.getClass().getName()); 这条语句打印出来的，那么为什么我们返回的这个代理对象的类名是这样的呢？

Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject                .getClass().getInterfaces(), handler);

可能我以为返回的这个代理对象会是Subject类型的对象，或者是InvocationHandler的对象，结果却不是，首先我们解释一下为什么我们这里可以将其转化为Subject类型的对象？原因就是在newProxyInstance这个方法的第二个参数上，我们给这个代理对象提供了一组什么接口，那么我这个代理对象就会实现了这组接口，这个时候我们当然可以将这个代理对象强制类型转化为这组接口中的任意一个，因为这里的接口是Subject类型，所以就可以将其转化为Subject类型了。

同时我们一定要记住，通过 Proxy.newProxyInstance 创建的代理对象是在jvm运行时动态生成的一个对象，它并不是我们的InvocationHandler类型，也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，并且命名方式都是这样的形式，以$开头，proxy为中，最后一个数字表示对象的标号。

接着我们来看看这两句 

subject.rent();
subject.hello("world");

这里是通过代理对象来调用实现的那种接口中的方法，这个时候程序就会跳转到由这个代理对象关联到的 handler 中的invoke方法去执行，而我们的这个 handler 对象又接受了一个 RealSubject类型的参数，表示我要代理的就是这个真实对象，所以此时就会调用 handler 中的invoke方法去执行：

public Object invoke(Object object, Method method, Object[] args)            throws Throwable    {        //　　在代理真实对象前我们可以添加一些自己的操作        System.out.println("before rent house");                System.out.println("Method:" + method);                //    当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用        method.invoke(subject, args);                //　　在代理真实对象后我们也可以添加一些自己的操作        System.out.println("after rent house");                return null;    }

我们看到，在真正通过代理对象来调用真实对象的方法的时候，我们可以在该方法前后添加自己的一些操作，同时我们看到我们的这个 method 对象是这样的：

public abstract void com.xiaoluo.dynamicproxy.Subject.rent()public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java.lang.String)

正好就是我们的Subject接口中的两个方法，这也就证明了当我通过代理对象来调用方法的时候，起实际就是委托由其关联到的 handler 对象的invoke方法中来调用，并不是自己来真实调用，而是通过代理的方式来调用的。

 AOP的拦截功能是由java中的动态代理来实现的。说白了，就是在目标类的基础上增加切面逻辑，生成增强的目标类（该切面逻辑或者在目标类函数执行之前，或者目标类函数执行之后，或者在目标类函数抛出异常时候执行。不同的切入时机对应不同的Interceptor的种类，如BeforeAdviseInterceptor，AfterAdviseInterceptor以及ThrowsAdviseInterceptor等）。

那么动态代理是如何实现将切面逻辑（advise）织入到目标类方法中去的呢？下面我们就来详细介绍并实现AOP中用到的两种动态代理。

AOP的源码中用到了两种动态代理来实现拦截切入功能：jdk动态代理和cglib动态代理。两种方法同时存在，各有优劣。jdk动态代理是由java内部的反射机制来实现的，cglib动态代理底层则是借助asm来实现的。总的来说，反射机制在生成类的过程中比较高效，而asm在生成类之后的相关执行过程中比较高效（可以通过将asm生成的类进行缓存，这样解决asm生成类过程低效问题）。还有一点必须注意：jdk动态代理的应用前提，必须是目标类基于统一的接口。如果没有上述前提，jdk动态代理不能应用。由此可以看出，jdk动态代理有一定的局限性，cglib这种第三方类库实现的动态代理应用更加广泛，且在效率上更有优势。。

1、定义接口和实现

[java] view plain copy

 print?

1. package com.meituan.hyt.test3.service;  
2.   
3.   
4. public interface UserService {  
5.     public String getName(int id);  
6.   
7.     public Integer getAge(int id);  
8. }  

[java] view plain copy

 print?

1. package com.meituan.hyt.test3.service.impl;  
2.   
3. import com.meituan.hyt.test3.service.UserService;  
4.   
5.   
6. public class UserServiceImpl implements UserService {  
7.     @Override  
8.     public String getName(int id) {  
9.         System.out.println("------getName------");  
10.         return "Tom";  
11.     }  
12.   
13.     @Override  
14.     public Integer getAge(int id) {  
15.         System.out.println("------getAge------");  
16.         return 10;  
17.     }  
18. }  

2、jdk动态代理实现

[java] view plain copy

 print?

1. package com.meituan.hyt.test3.jdk;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5.   
6.   
7. public class MyInvocationHandler implements InvocationHandler {  
8.     private Object target;  
9.   
10.     MyInvocationHandler() {  
11.         super();  
12.     }  
13.   
14.     MyInvocationHandler(Object target) {  
15.         super();  
16.         this.target = target;  
17.     }  
18.   
19.     @Override  
20.     public Object invoke(Object o, Method method, Object[] args) throws Throwable {  
21.         if("getName".equals(method.getName())){  
22.             System.out.println("++++++before " + method.getName() + "++++++");  
23.             Object result = method.invoke(target, args);  
24.             System.out.println("++++++after " + method.getName() + "++++++");  
25.             return result;  
26.         }else{  
27.             Object result = method.invoke(target, args);  
28.             return result;  
29.         }  
30.   
31.     }  
32. }  

[java] view plain copy

 print?

1. package com.meituan.hyt.test3.jdk;  
2.   
3. import com.meituan.hyt.test3.service.UserService;  
4. import com.meituan.hyt.test3.service.impl.UserServiceImpl;  
5.   
6. import java.lang.reflect.InvocationHandler;  
7. import java.lang.reflect.Proxy;  
8.   
9.   
10. public class Main1 {  
11.     public static void main(String[] args) {  
12.         UserService userService = new UserServiceImpl();  
13.         InvocationHandler invocationHandler = new MyInvocationHandler(userService);  
14.         UserService userServiceProxy = (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(),  
15.                 userService.getClass().getInterfaces(), invocationHandler);  
16.         System.out.println(userServiceProxy.getName(1));  
17.         System.out.println(userServiceProxy.getAge(1));  
18.     }  
19. }  

运行结果

++++++before getName++++++
------getName------
++++++after getName++++++
Tom
------getAge------
10

3、cglib动态代理实现

Cglib是一个优秀的动态代理框架，它的底层使用ASM在内存中动态的生成被代理类的子类，使用CGLIB即使代理类没有实现任何接口也可以实现动态代理功能。CGLIB具有简单易用，它的运行速度要远远快于JDK的Proxy动态代理：

CGLIB的核心类：
    net.sf.cglib.proxy.Enhancer – 主要的增强类
    net.sf.cglib.proxy.MethodInterceptor – 主要的方法拦截类，它是Callback接口的子接口，需要用户实现
    net.sf.cglib.proxy.MethodProxy – JDK的java.lang.reflect.Method类的代理类，可以方便的实现对源对象方法的调用,如使用：
    Object o = methodProxy.invokeSuper(proxy, args);//虽然第一个参数是被代理对象，也不会出现死循环的问题。

net.sf.cglib.proxy.MethodInterceptor接口是最通用的回调（callback）类型，它经常被基于代理的AOP用来实现拦截（intercept）方法的调用。这个接口只定义了一个方法
public Object intercept(Object object, java.lang.reflect.Method method,
Object[] args, MethodProxy proxy) throws Throwable;

第一个参数是代理对像，第二和第三个参数分别是拦截的方法和方法的参数。原来的方法可能通过使用java.lang.reflect.Method对象的一般反射调用，或者使用 net.sf.cglib.proxy.MethodProxy对象调用。net.sf.cglib.proxy.MethodProxy通常被首选使用，因为它更快。

[java] view plain copy

 print?

1. package com.meituan.hyt.test3.cglib;  
2.   
3.   
4. import net.sf.cglib.proxy.MethodInterceptor;  
5. import net.sf.cglib.proxy.MethodProxy;  
6.   
7. import java.lang.reflect.Method;  
8.   
9.   
10. public class CglibProxy implements MethodInterceptor {  
11.     @Override  
12.     public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {  
13.         System.out.println("++++++before " + methodProxy.getSuperName() + "++++++");  
14.         System.out.println(method.getName());  
15.         Object o1 = methodProxy.invokeSuper(o, args);  
16.         System.out.println("++++++before " + methodProxy.getSuperName() + "++++++");  
17.         return o1;  
18.     }  
19. }  

[java] view plain copy

 print?

1. package com.meituan.hyt.test3.cglib;  
2.   
3. import com.meituan.hyt.test3.service.UserService;  
4. import com.meituan.hyt.test3.service.impl.UserServiceImpl;  
5. import net.sf.cglib.proxy.Enhancer;  
6.   
7.   
8.   
9. public class Main2 {  
10.     public static void main(String[] args) {  
11.         CglibProxy cglibProxy = new CglibProxy();  
12.   
13.         Enhancer enhancer = new Enhancer();  
14.         enhancer.setSuperclass(UserServiceImpl.class);  
15.         enhancer.setCallback(cglibProxy);  
16.   
17.         UserService o = (UserService)enhancer.create();  
18.         o.getName(1);  
19.         o.getAge(1);  
20.     }  
21. }  

运行结果：

++++++before CGLIB$getName$0++++++
getName
------getName------
++++++before CGLIB$getName$0++++++
++++++before CGLIB$getAge$1++++++
getAge
------getAge------
++++++before CGLIB$getAge$1++++++