动态代理是指在运行时，动态生成代理类。代理类的字节码将在运行时生成并载入当前的ClassLoader.

         生成动态代理类的方法很多，如JDK自带的动态代理、CGLIB、Javassist或者ASM库。

          JDK动态代理使用简单，它内置在JDK中，因此不需要引入第三方Jar包，但相对功能比较弱。CGLIB和Javassist都是高级的字节码生成库，总体性能比JDK自带的动态代理好，而且功能十分强大。ASM是低级的字节码生成工具，使用ASM已经近乎在于使用Javabytecode编程，对开发人员要求较高，也是性能最好的一种动态代理生辰工具。但ASM的使用是在过于繁琐，而且性能也没有数量级的提升，与CGLIB等高级字节码生成工具相比，ASM程序的可维护性也较差。

JDK实现

1、步骤

1）通过实现InvocationHandler接口创建自己的调用处理器

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

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

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

2、创建代理

3、代码

执行过程：

       如图，目标对象的方法调用被Proxy拦截，在InvocationHandler中的回调方法中通过反射调用，这种动态代理的方法实现了对类的方法的运行时修改。

        JDK动态代理有个缺点，那就是不能对类进行代理，只能对接口进行代理，如果我们的类没有实现任何接口，那么就不能使用这种方式进行动态代理（因为$Proxy()这个类集成了Proxy,Java的集成不允许出现多个父类）。准确的说这不应该是缺点，一个良好的系统，每个类都应该有一个接口与之对应。针对接口编程。

CGLIB实现

Javassist实现

       一种是使用代理工厂创建，另一种通过使用动态代码创建。使用代理工厂创建时，方法与CGLIB类似，也需要实现一个用于代理逻辑处理的Handler：例如createJavassistDynProxy()；使用动态代码创建，生成字节码，这种方式可以非常灵活，甚至可以在运行时生成业务逻辑，如createJavassistBytecodeDynamicProxy()方法。

      三种动态代理：JDK动态代理创建速度优于CGLIB动态代理，但是在函数的调用性能上远不如CGLIB和Javassist。故CGLIB和Javassist整体性能上比JDK动态代理好。

性能比较：

Javassist字节码最快，CGLIB次之，是JDK的两倍。

      它们都是通过字节码生成来实现动态代理的。只不过是它们生成的字节码不一样，像JDK，CGLIB都考虑了很多因素，以及继承或包装了自己的一些类，所以生成的字节码非常大，而我们很多时候用不上这些，手工生成的字节码非常小（Javassist是手工生成的字节码），所以速度快。

       另外，ASM也是手工生成的字节码，速度也很快，但是它没有一个数量级，通常情况下选用Javassist生成字节码的方式。

        另外，从严格意义上将Aspectj不能算动态代理，应该是静态代理，因为它采用的是编译器植入。用aspectj，需要写相应的xml，定义切面，织入点等，然后由aspectj的编译器来编译出新的字节码文件，这明显是静态代理。

下面附上jdk proxy内幕

Java代码  

1. public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)  
2.            throws IllegalArgumentException {  
3.        //InvocationHandler不能为空,因为对代理对象的所有方法调用实际上都会委托到InvocationHandler的invoke方法,  
4.        //这个我们后面通过查看产生的代理类的源代码便会一目了然  
5.        if (h == null) {  
6.            throw new NullPointerException();  
7.        }  
8.   
9.        //这个是核心的地方,通过提供的ClassLoader和interface列表来产生代理类,具体的实现可以参考getProxyClass这个方法的实现,  
10.        //真正的工作是由sun.misc.ProxyGenerator这个类来完成的,可以google查看具体的逻辑.在我们的程序中通过设置  
11.        //System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true")可以查看产生的类文件  
12.        Class cl = getProxyClass(loader, interfaces);  
13.   
14.        //因为代理类继承了Proxy类.而Proxy中定义了构造函数protected Proxy(InvocationHandler h),所以可以反射得到Constructer实例  
15.        //创建代理对象  
16.        try {  
17.            Constructor cons = cl.getConstructor(constructorParams);  
18.            return (Object) cons.newInstance(new Object[] { h });  
19.        } catch (NoSuchMethodException e) {  
20.            throw new InternalError(e.toString());  
21.        } catch (IllegalAccessException e) {  
22.            throw new InternalError(e.toString());  
23.        } catch (InstantiationException e) {  
24.            throw new InternalError(e.toString());  
25.        } catch (InvocationTargetException e) {  
26.            throw new InternalError(e.toString());  
27.        }  
28.    }  

Java代码  

1. public interface Subject {  
2.     void pub(String key, String content);  
3.   
4.     String sub(String key);  
5. }  
6.   
7.   
8. public class SimpleSubject implements Subject {  
9.     private Map<String, String> msg = new ConcurrentHashMap<String, String>();  
10.   
11.     public void pub(String key, String content) {  
12.         System.out.println("pub msg: key is " + key + ", content is " + content);  
13.         msg.put(key, content);  
14.     }  
15.   
16.     public String sub(String key) {  
17.         if (msg.containsKey(key)) {  
18.             String ret = msg.get(key);  
19.             System.out.println("sub msg: key is " + key + ", result is " + ret);  
20.             return ret;  
21.         }  
22.   
23.         return null;  
24.     }  
25.   
26. }  
27.   
28.   
29. public class SubjectProxyFactory {  
30.     //TODO: cache   
31.     public static Subject getSubject(final Subject realSubject) {  
32.         return (Subject) Proxy.newProxyInstance(realSubject.getClass().getClassLoader(), new Class[] { Subject.class },  
33.                 new InvocationHandler() {  
34.   
35.                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
36.                         System.out.println("\naction before method invocation....");  
37.                         Object retVal = method.invoke(realSubject, args);  
38.                         System.out.println("action after method invocation....\n");  
39.                         return retVal;  
40.                     }  
41.                 });  
42.     }  
43. }  
44.   
45.   
46. public class Demo {  
47.     public static void main(String[] args) {  
48.         //设置此系统属性,以查看代理类文件  
49.         System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");  
50.           
51.         //创建真实对象  
52.         Subject subj = new SimpleSubject();  
53.         subj.pub("name", "kevin.fan");  
54.         subj.sub("name");  
55.           
56.         //创建代理对象  
57.         Subject proxy = SubjectProxyFactory.getSubject(subj);  
58.         proxy.pub("hobby", "r&b music");  
59.         proxy.sub("name");  
60.     }  
61. }  

Result代码  

1. pub msg: key is name, content is kevin.fan  
2. sub msg: key is name, result is kevin.fan  
3.   
4. action before method invocation....  
5. pub msg: key is hobby, content is r&b music  
6. action after method invocation....  
7.   
8. action before method invocation....  
9. sub msg: key is name, result is kevin.fan  
10. action after method invocation….  

Java代码  

1. //这里很清楚了,代理类继承了Proxy类,并且实现了Proxy.newProxyInstance这个方法中传入的接口  
2. public final class $Proxy0 extends Proxy  
3.   implements Subject  
4. {  
5.     
6.   //这些方法在下面的static init block中进行初始化  
7.   private static Method m4;  
8.   private static Method m1;  
9.   private static Method m3;  
10.   private static Method m0;  
11.   private static Method m2;  
12.     
13.   static  
14.   {  
15.     try  
16.     {  
17.       m4 = Class.forName("com.aliyun.demo.kevin.coder.lang.proxy.Subject").getMethod("sub", new Class[] { Class.forName("java.lang.String") });  
18.       m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });  
19.       m3 = Class.forName("com.aliyun.demo.kevin.coder.lang.proxy.Subject").getMethod("pub", new Class[] { Class.forName("java.lang.String"), Class.forName("java.lang.String") });  
20.       m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);  
21.       m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);  
22.       return;  
23.     }  
24.     catch (NoSuchMethodException localNoSuchMethodException)  
25.     {  
26.       throw new NoSuchMethodError(localNoSuchMethodException.getMessage());  
27.     }  
28.     catch (ClassNotFoundException localClassNotFoundException)  
29.     {  
30.       throw new NoClassDefFoundError(localClassNotFoundException.getMessage());  
31.     }  
32.   }  
33.   
34.   //构造函数,接收一个 InvocationHandler作为参数,这就是为什么Proxy.newProxyInstance方法里可以  
35.   //通过InvocationHandler实例作为参数来反射获取Constructer实例   
36.   public $Proxy0(paramInvocationHandler)  
37.     throws   
38.   {  
39.     super(paramInvocationHandler);  
40.   }  
41.   
42.   //下面通过这个来看下代理对象中方法是怎样调用的  
43.   public final String sub(String paramString)  
44.     throws   
45.   {  
46.     try  
47.     {  
48.        //全部是通过调用InvocationHandler的invoke方法,传入对应的方法和参数  
49.       return (String)this.h.invoke(this, m4, new Object[] { paramString });  
50.     }  
51.     catch (Error|RuntimeException localError)  
52.     {  
53.       throw localError;  
54.     }  
55.     catch (Throwable localThrowable)  
56.     {  
57.       throw new UndeclaredThrowableException(localThrowable);  
58.     }  
59.   }  
60.   
61.   public final boolean equals(Object paramObject)  
62.     throws   
63.   {  
64.     try  
65.     {  
66.       return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();  
67.     }  
68.     catch (Error|RuntimeException localError)  
69.     {  
70.       throw localError;  
71.     }  
72.     catch (Throwable localThrowable)  
73.     {  
74.       throw new UndeclaredThrowableException(localThrowable);  
75.     }  
76.   }  
77.   
78.   public final void pub(String paramString1, String paramString2)  
79.     throws   
80.   {  
81.     try  
82.     {  
83.       this.h.invoke(this, m3, new Object[] { paramString1, paramString2 });  
84.       return;  
85.     }  
86.     catch (Error|RuntimeException localError)  
87.     {  
88.       throw localError;  
89.     }  
90.     catch (Throwable localThrowable)  
91.     {  
92.       throw new UndeclaredThrowableException(localThrowable);  
93.     }  
94.   }  
95.   
96.   public final int hashCode()  
97.     throws   
98.   {  
99.     try  
100.     {  
101.       return ((Integer)this.h.invoke(this, m0, null)).intValue();  
102.     }  
103.     catch (Error|RuntimeException localError)  
104.     {  
105.       throw localError;  
106.     }  
107.     catch (Throwable localThrowable)  
108.     {  
109.       throw new UndeclaredThrowableException(localThrowable);  
110.     }  
111.   }  
112.   
113.   public final String toString()  
114.     throws   
115.   {  
116.     try  
117.     {  
118.       return (String)this.h.invoke(this, m2, null);  
119.     }  
120.     catch (Error|RuntimeException localError)  
121.     {  
122.       throw localError;  
123.     }  
124.     catch (Throwable localThrowable)  
125.     {  
126.       throw new UndeclaredThrowableException(localThrowable);  
127.     }  
128.   }  
129.   
130. }  

Spring AOP里最重要的两个概念是增强(Advice)和切面(Advisor)，增强是织入到目标类连接点上的一段程序代码，切面决定要给什么类的什么方法实施增强。是怎么做到对特定方法实施增强的呢？对invoke方法中的method#name进行判断。

Java代码  

1. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
2.                         System.out.println("\naction before method invocation....");  
3.                         Object retVal = method.invoke(realSubject, args);  
4.                         System.out.println("action after method invocation....\n");  
5.                         return retVal;  
6.                     }  

    Spring提供了ProxyFactoryBean创建代理，及利用BeanPostProcessor实现自动创建代理。

    Spring是在运行期利用JDK或CGLib创建代理，我们还可以在类加载期间通过字节码编辑的技术，将切面织入到目标类中，这种织入方式称为LTW(Load Time Weaving)。Spring为LTW的过程提供了细粒度的控制，它支持在单个ClassLoader范围内实施类文件转换，且配置更为简单。

附小知识：

Ref ref = new RefImpl(); 
System.out.println(ref.getClass().getSimpleName()); //RefImpl类型 
ref.f(); //调用接口方法 
// ref.g(); //向上转型后实现类添加的方法不能调用 
if(ref instanceof RefImpl){ 
RefImpl ref1 = (RefImpl)ref; //类型识别后转型 
ref1.g("zhouyang"); 
// ref1.w(); //私有方法不能访问 

原文链接：[http://wely.iteye.com/blog/2277881]