Java动态代理的实现

最新推荐文章于 2024-07-08 21:02:47 发布
最新推荐文章于 2024-07-08 21:02:47 发布
阅读量308 收藏
点赞数
分类专栏： java 文章标签： class

  1. import java.lang.reflect.Proxy;    
  2. import java.lang.reflect.InvocationHandler;    
  3. import java.lang.reflect.InvocationTargetException;    
  4. import java.lang.reflect.Method;

处理类：DynamicProxyHandler<T> implements InvocationHandler

DynamicProxyHandler handler = new DynamicProxyHandler<T>(sessionId,

target, targetInterface, minasServerFacade);


target代理的目标对象：

(T) Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), handler);

处理类实现方法：

public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
String facadeName = targetInterface.getCanonicalName();
String methodName = method.getName();


Object result = null;

}


以下部分为说明摘抄：



       概念 

       代理模式 
      代理模式是常用的Java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。 
      按照代理的创建时期，代理类可以分为两种。 
     静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。 
     动态代理：在程序运行时，运用反射机制动态创建而成。     

     动态代理作为代理模式的一种扩展形式，广泛应用于框架（尤其是基于AOP的框架）的设计与开发，本文将通过实例来讲解Java动态代理的实现过程。

      通常情况下，代理模式中的每一个代理类在编译之后都会生成一个class文件，代理类所实现的接口和所代理的方法都被固定，这种代理被称之为静态代理(Static Proxy)。那么有没有一种机制能够让系统在运行时动态创建代理类？答案就是本文将要介绍的动态代理(Dynamic Proxy)。动态代理是一种较为高级的代理模式，它在事务管理、AOP（面向方面编程）等领域都发挥了重要的作用。

      在传统的代理模式中，客户端通过Proxy类调用RealSubject类的request()方法，同时还可以在代理类中封装其他方法（如preRequest()和postRequest()等）。如果按照这种方法使用代理模式，那么代理类和真实主题类都应该是事先已经存在的，代理类的接口和所代理方法都已明确指定，如果需要为不同的真实主题类提供代理类或者代理一个真实主题类中的不同方法，都需要增加新的代理类，这将导致系统中的类个数急剧增加，因此需要想办法减少系统中类的个数。动态代理可以让系统能够根据实际需要来动态创建代理类，让同一个代理类能够代理多个不同的真实主题类而且可以代理不同的方法。

      从JDK 1.3开始，Java语言提供了对动态代理的支持，Java语言实现动态代理时需要用到位于java.lang.reflect包中的一些类，现简要说明如下：


(1) Proxy类


      Proxy类提供了用于创建动态代理类和实例对象的方法，它是所创建的动态代理类的父类，它最常用的方法如下：

  • public static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces)：该方法用于返回一个Class类型的代理类，在参数中需要提供类加载器并需要指定代理的接口数组（与真实主题类的接口列表一致）。
  • public static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces, InvocationHandler h)：该方法用于返回一个动态创建的代理类的实例，方法中第一个参数loader表示代理类的类加载器，第二个参数interfaces表示代理类所实现的接口列表（与真实主题类的接口列表一致），第三个参数h表示所指派的调用处理程序类。

    

  (2) InvocationHandler接口


      InvocationHandler接口是代理处理程序类的实现接口，该接口作为代理实例的调用处理者的公共父类，每一个代理类的实例都可以提供一个相关的具体调用处理者（InvocationHandler接口的子类）。在该接口中声明了如下方法：

  • public Object invoke(Objectproxy, Method method, Object[] args)：该方法用于处理对代理类实例的方法调用并返回相应的结果，当一个代理实例中的业务方法被调用时将自动调用该方法。invoke()方法包含三个参数，其中第一个参数proxy表示代理类的实例，第二个参数method表示需要代理的方法，第三个参数args表示代理方法的参数数组。

        动态代理类需要在运行时指定所代理真实主题类的接口，客户端在调用动态代理对象的方法时，调用请求会将请求自动转发给InvocationHandler对象的invoke()方法，由invoke()方法来实现对请求的统一处理。

 

      下面通过一个简单实例来学习如何使用动态代理模式：

     Sunny软件公司欲为公司OA系统数据访问层DAO增加方法调用日志，记录每一个方法被调用的时间和调用结果，现使用动态代理进行设计和实现。


[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. import java.lang.reflect.Proxy;    
  2. import java.lang.reflect.InvocationHandler;    
  3. import java.lang.reflect.InvocationTargetException;    
  4. import java.lang.reflect.Method;    
  5. import java.util.Calendar;    
  6. import java.util.GregorianCalendar;    
  7.     
  8. //抽象UserDAO：抽象主题角色    
  9. interface AbstractUserDAO {    
  10.     public Boolean findUserById(String userId);    
  11. }    
  12.     
  13. //抽象DocumentDAO：抽象主题角色    
  14. interface AbstractDocumentDAO {    
  15.     public Boolean deleteDocumentById(String documentId);    
  16. }    
  17.     
  18. //具体UserDAO类：真实主题角色    
  19. class UserDAO implements AbstractUserDAO {    
  20.     public Boolean findUserById(String userId) {    
  21.         if (userId.equalsIgnoreCase("张无忌")) {    
  22.             System.out.println("查询ID为" + userId + "的用户信息成功！");    
  23.             return true;    
  24.         }    
  25.         else {    
  26.             System.out.println("查询ID为" + userId + "的用户信息失败！");    
  27.             return false;    
  28.         }    
  29.     }    
  30. }    
  31.     
  32. //具体DocumentDAO类：真实主题角色    
  33. class DocumentDAO implements AbstractDocumentDAO {    
  34.     public Boolean deleteDocumentById(String documentId) {    
  35.         if (documentId.equalsIgnoreCase("D001")) {    
  36.             System.out.println("删除ID为" + documentId + "的文档信息成功！");    
  37.             return true;    
  38.         }    
  39.         else {    
  40.             System.out.println("删除ID为" + documentId + "的文档信息失败！");    
  41.             return false;    
  42.         }    
  43.     }    
  44. }    
  45.     
  46. //自定义请求处理程序类    
  47. class DAOLogHandler implements InvocationHandler {    
  48.     private Calendar calendar;    
  49.     private Object object;    
  50.         
  51.     public DAOLogHandler() {        
  52.     }    
  53.         
  54.     //自定义有参构造函数，用于注入一个需要提供代理的真实主题对象    
  55.     public DAOLogHandler(Object object) {    
  56.         this.object = object;    
  57.     }    
  58.         
  59.     //实现invoke()方法，调用在真实主题类中定义的方法    
  60.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    
  61.         beforeInvoke();    
  62.         Object result = method.invoke(object, args); //转发调用    
  63.         afterInvoke();    
  64.         return null;    
  65.     }    
  66.     
  67.     //记录方法调用时间    
  68.     public void beforeInvoke(){    
  69.         calendar = new GregorianCalendar();    
  70.         int hour = calendar.get(Calendar.HOUR_OF_DAY);    
  71.         int minute = calendar.get(Calendar.MINUTE);    
  72.         int second = calendar.get(Calendar.SECOND);    
  73.         String time = hour + ":" + minute + ":" + second;    
  74.         System.out.println("调用时间：" + time);    
  75.     }    
  76.     
  77.     public void afterInvoke(){    
  78.         System.out.println("方法调用结束！" );    
  79.     }    
  80. }    


编写如下客户端测试代码：


[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. class Client {    
  2.     public static void main(String args[]) {    
  3.         InvocationHandler handler = null;    
  4.             
  5.         AbstractUserDAO userDAO = new UserDAO();    
  6.         handler = new DAOLogHandler(userDAO);    
  7.         AbstractUserDAO proxy = null;    
  8.         //动态创建代理对象，用于代理一个AbstractUserDAO类型的真实主题对象    
  9.         proxy = (AbstractUserDAO)Proxy.newProxyInstance(AbstractUserDAO. class.getClassLoader(), new Class[]{AbstractUserDAO.class}, handler);    
  10.         proxy.findUserById("张无忌"); //调用代理对象的业务方法    
  11.         
  12.         System.out.println("------------------------------");    
  13.         
  14.         AbstractDocumentDAO docDAO = new DocumentDAO();    
  15.         handler = new DAOLogHandler(docDAO);    
  16.         AbstractDocumentDAO proxy_new = null;    
  17. //动态创建代理对象，用于代理一个AbstractDocumentDAO类型的真实主题对象    
  18.         proxy_new = (AbstractDocumentDAO)Proxy.newProxyInstance(Abstract DocumentDAO.class.getClassLoader(), new Class[]{AbstractDocumentDAO.class}, handler);    
  19.         proxy_new.deleteDocumentById("D002"); //调用代理对象的业务方法    
  20.     }     
  21. }    

编译并运行程序，输出结果如下：


[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. 调用时间：13:47:14  
  2. 查询ID为张无忌的用户信息成功！  
  3. 方法调用结束！  
  4. ------------------------------  
  5. 调用时间：13:47:14  
  6. 删除ID为D002的文档信息失败！  
  7. 方法调用结束！  

 通过使用动态代理，我们可以实现对多个真实主题类的统一代理和集中控制。


       注：JDK中提供的动态代理只能代理一个或多个接口，如果需要动态代理具体类或抽象类，可以使用CGLib(Code Generation Library)等工具，CGLib是一个功能较为强大、性能和质量也较好的代码生成包，在许多AOP框架中都得以广泛应用，大家可以自行查阅相关资料来学习CGLib。


动态代理底层实现原理：


从上面可以看出，JDK的动态代理使用起来非常简单，但是只知道如何使用是不够的，知其然，还需知其所以然。所以要想搞清楚它的实现，那么得从源码入手。这里的源码是1.7.0_79。首先来看看它是如何生成代理类的：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public static Object newProxyInstance(ClassLoader loader,    
  2.                                       Class<?>[] interfaces,    
  3.                                       InvocationHandler h)    
  4.     throws IllegalArgumentException {    
  5.     if (h == null) {    
  6.         throw new NullPointerException();    
  7.     }    
  8.     
  9.     final Class<?>[] intfs = interfaces.clone();    
  10.     final SecurityManager sm = System.getSecurityManager();    
  11.     if (sm != null) {    
  12.         checkProxyAccess(Reflection.getCallerClass(), loader, intfs);    
  13.     }    
  14.     // 这里是生成class的地方    
  15.     Class<?> cl = getProxyClass0(loader, intfs);    
  16.     // 使用我们实现的InvocationHandler作为参数调用构造方法来获得代理类的实例    
  17.     try {    
  18.         final Constructor<?> cons = cl.getConstructor(constructorParams);    
  19.         final InvocationHandler ih = h;    
  20.         if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {    
  21.             return AccessController.doPrivileged(new PrivilegedAction<Object>() {    
  22.                 public Object run() {    
  23.                     return newInstance(cons, ih);    
  24.                 }    
  25.             });    
  26.         } else {    
  27.             return newInstance(cons, ih);    
  28.         }    
  29.     } catch (NoSuchMethodException e) {    
  30.         throw new InternalError(e.toString());    
  31.     }    
  32. }    


其中newInstance只是调用Constructor.newInstance来构造相应的代理类实例，这里重点是看getProxyClass0这个方法的实现：


[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. private static Class<?> getProxyClass0(ClassLoader loader,    
  2.                                        Class<?>... interfaces) {    
  3.     // 代理的接口数量不能超过65535（没有这种变态吧）    
  4.     if (interfaces.length > 65535) {    
  5.         throw new IllegalArgumentException("interface limit exceeded");    
  6.     }    
  7.     // JDK对代理进行了缓存，如果已经存在相应的代理类，则直接返回，否则才会通过ProxyClassFactory来创建代理    
  8.     return proxyClassCache.get(loader, interfaces);    
  9. }    


其中代理缓存是使用WeakCache实现的，如下：


[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. private static final WeakCache<ClassLoader, Class<?>[], Class<?>>    
  2.     proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());   

我查看了底层代码，其实是用weakHashMap来实现缓存的。

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. private static Map proxyClasses =  
  2. ollections.synchronizedMap(new WeakHashMap());  


具体的缓存逻辑这里暂不关心，只需要关心ProxyClassFactory是如何生成代理类的，ProxyClassFactory是Proxy的一个静态内部类，实现了WeakCache的内部接口BiFunction的apply方法：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. private static final class ProxyClassFactory    
  2.     implements BiFunction<ClassLoader, Class<?>[], Class<?>> {    
  3.     // 所有代理类名字的前缀    
  4.     private static final String proxyClassNamePrefix = "$Proxy";    
  5.     
  6.     // 用于生成代理类名字的计数器    
  7.     private static final AtomicLong nextUniqueNumber = new AtomicLong();    
  8.     
  9.     @Override    
  10.     public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {    
  11.         // 省略验证代理接口的代码……    
  12.     
  13.         String proxyPkg = null;     // 生成的代理类的包名    
  14.         // 对于非公共接口，代理类的包名与接口的相同    
  15.         for (Class<?> intf : interfaces) {    
  16.             int flags = intf.getModifiers();    
  17.             if (!Modifier.isPublic(flags)) {    
  18.                 String name = intf.getName();    
  19.                 int n = name.lastIndexOf('.');    
  20.                 String pkg = ((n == -1) ? "" : name.substring(0, n + 1));    
  21.                 if (proxyPkg == null) {    
  22.                     proxyPkg = pkg;    
  23.                 } else if (!pkg.equals(proxyPkg)) {    
  24.                     throw new IllegalArgumentException(    
  25.                         "non-public interfaces from different packages");    
  26.                 }    
  27.             }    
  28.         }    
  29.     
  30.         // 对于公共接口的包名，默认为com.sun.proxy    
  31.         if (proxyPkg == null) {    
  32.             proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";    
  33.         }    
  34.     
  35.         // 获取计数    
  36.         long num = nextUniqueNumber.getAndIncrement();    
  37.         // 默认情况下，代理类的完全限定名为：com.sun.proxy.$Proxy0，com.sun.proxy.$Proxy1……依次递增    
  38.         String proxyName = proxyPkg + proxyClassNamePrefix + num;    
  39.     
  40.         // 这里才是真正的生成代理类的字节码的地方    
  41.         byte[] proxyClassFile = ProxyGenerator.generateProxyClass(    
  42.             proxyName, interfaces);    
  43.         try {    
  44.             // 根据二进制字节码返回相应的Class实例    
  45.             return defineClass0(loader, proxyName,    
  46.                                 proxyClassFile, 0, proxyClassFile.length);    
  47.         } catch (ClassFormatError e) {    
  48.             throw new IllegalArgumentException(e.toString());    
  49.         }    
  50.     }    
  51. }    


ProxyGenerator是sun.misc包中的类，它没有开源，但是可以反编译来一探究竟：


[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public static byte[] generateProxyClass(final String var0, Class[] var1) {    
  2.     ProxyGenerator var2 = new ProxyGenerator(var0, var1);    
  3.     final byte[] var3 = var2.generateClassFile();    
  4.     // 这里根据参数配置，决定是否把生成的字节码（.class文件）保存到本地磁盘，我们可以通过把相应的class文件保存到本地，再反编译来看看具体的实现，这样更直观    
  5.     if(saveGeneratedFiles) {    
  6.         AccessController.doPrivileged(new PrivilegedAction() {    
  7.             public Void run() {    
  8.                 try {    
  9.                     FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class");    
  10.                     var1.write(var3);    
  11.                     var1.close();    
  12.                     return null;    
  13.                 } catch (IOException var2) {    
  14.                     throw new InternalError("I/O exception saving generated file: " + var2);    
  15.                 }    
  16.             }    
  17.         });    
  18.     }    
  19.     return var3;    
  20. }    


saveGeneratedFiles这个属性的值从哪里来呢：

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. private static final boolean saveGeneratedFiles = ((Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))).booleanValue();    

GetBooleanAction实际上是调用Boolean.getBoolean(propName)来获得的，而Boolean.getBoolean(propName)调用了System.getProperty(name)，所以我们可以设置sun.misc.ProxyGenerator.saveGeneratedFiles这个系统属性为true来把生成的class保存到本地文件来查看。

这里要注意，当把这个属性设置为true时，生成的class文件及其所在的路径都需要提前创建，否则会抛出FileNotFoundException异常。如：


[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. Exception in thread "main" java.lang.InternalError: I/O exception saving generated file: java.io.FileNotFoundException: com/sun/proxy/$Proxy0.class (No such file or directory)    
  2. at sun.misc.ProxyGenerator$1.run(ProxyGenerator.java:336)    
  3. at sun.misc.ProxyGenerator$1.run(ProxyGenerator.java:327)    
  4. at java.security.AccessController.doPrivileged(Native Method)    
  5. at sun.misc.ProxyGenerator.generateProxyClass(ProxyGenerator.java:326)    
  6. at java.lang.reflect.Proxy$ProxyClassFactory.apply(Proxy.java:672)    
  7. at java.lang.reflect.Proxy$ProxyClassFactory.apply(Proxy.java:592)    
  8. at java.lang.reflect.WeakCache$Factory.get(WeakCache.java:244)    
  9. at java.lang.reflect.WeakCache.get(WeakCache.java:141)    
  10. at java.lang.reflect.Proxy.getProxyClass0(Proxy.java:455)    
  11. at java.lang.reflect.Proxy.newProxyInstance(Proxy.java:738)    
  12. at com.mikan.proxy.ProxyTest.main(ProxyTest.java:15)    
  13. at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)    
  14. at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)    
  15. at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)    
  16. at java.lang.reflect.Method.invoke(Method.java:606)    
  17. at com.intellij.rt.execution.application.AppMain.main(AppMain.java:140)    

即我们要在运行当前main方法的路径下创建com/sun/proxy目录，并创建一个$Proxy0.class文件，才能够正常运行并保存class文件内容。

反编译$Proxy0.class文件，如下所示：


[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package com.sun.proxy;    
  2.     
  3. import com.mikan.proxy.HelloWorld;    
  4. import java.lang.reflect.InvocationHandler;    
  5. import java.lang.reflect.Method;    
  6. import java.lang.reflect.Proxy;    
  7. import java.lang.reflect.UndeclaredThrowableException;    
  8.     
  9. public final class $Proxy0 extends Proxy implements HelloWorld {    
  10.   private static Method m1;    
  11.   private static Method m3;    
  12.   private static Method m0;    
  13.   private static Method m2;    
  14.     
  15.   public $Proxy0(InvocationHandler paramInvocationHandler) {    
  16.     super(paramInvocationHandler);    
  17.   }    
  18.     
  19.   public final boolean equals(Object paramObject) {    
  20.     try {    
  21.       return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();    
  22.     }    
  23.     catch (Error|RuntimeException localError) {    
  24.       throw localError;    
  25.     }    
  26.     catch (Throwable localThrowable) {    
  27.       throw new UndeclaredThrowableException(localThrowable);    
  28.     }    
  29.   }    
  30.     
  31.   public final void sayHello(String paramString) {    
  32.     try {    
  33.       this.h.invoke(this, m3, new Object[] { paramString });    
  34.       return;    
  35.     }    
  36.     catch (Error|RuntimeException localError) {    
  37.       throw localError;    
  38.     }    
  39.     catch (Throwable localThrowable) {    
  40.       throw new UndeclaredThrowableException(localThrowable);    
  41.     }    
  42.   }    
  43.     
  44.   public final int hashCode() {    
  45.     try {    
  46.       return ((Integer)this.h.invoke(this, m0, null)).intValue();    
  47.     }    
  48.     catch (Error|RuntimeException localError) {    
  49.       throw localError;    
  50.     }    
  51.     catch (Throwable localThrowable) {    
  52.       throw new UndeclaredThrowableException(localThrowable);    
  53.     }    
  54.   }    
  55.     
  56.   public final String toString() {    
  57.     try {    
  58.       return (String)this.h.invoke(this, m2, null);    
  59.     }    
  60.     catch (Error|RuntimeException localError) {    
  61.       throw localError;    
  62.     }    
  63.     catch (Throwable localThrowable) {    
  64.       throw new UndeclaredThrowableException(localThrowable);    
  65.     }    
  66.   }    
  67.     
  68.   static {    
  69.     try {    
  70.       m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });    
  71.       m3 = Class.forName("com.mikan.proxy.HelloWorld").getMethod("sayHello", new Class[] { Class.forName("java.lang.String") });    
  72.       m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);    
  73.       m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);    
  74.       return;    
  75.     }    
  76.     catch (NoSuchMethodException localNoSuchMethodException) {    
  77.       throw new NoSuchMethodError(localNoSuchMethodException.getMessage());    
  78.     }    
  79.     catch (ClassNotFoundException localClassNotFoundException) {    
  80.       throw new NoClassDefFoundError(localClassNotFoundException.getMessage());    
  81.     }    
  82.   }    
  83. }    

可以看到，动态生成的代理类有如下特性：

  1. 继承了Proxy类，实现了代理的接口，由于java不能多继承，这里已经继承了Proxy类了，不能再继承其他的类，所以JDK的动态代理不支持对实现类的代理，只支持接口的代理。
  2. 提供了一个使用InvocationHandler作为参数的构造方法。
  3. 生成静态代码块来初始化接口中方法的Method对象，以及Object类的equals、hashCode、toString方法。
  4. 重写了Object类的equals、hashCode、toString，它们都只是简单的调用了InvocationHandler的invoke方法，即可以对其进行特殊的操作，也就是说JDK的动态代理还可以代理上述三个方法。
  5. 代理类实现代理接口的sayHello方法中，只是简单的调用了InvocationHandler的invoke方法，我们可以在invoke方法中进行一些特殊操作，甚至不调用实现的方法，直接返回。

至此JDK动态代理的实现原理就分析的差不多了。同时我们可以想像一下spring AOP提供的各种拦截该如何实现，就已经很明了了，如下所示：


[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    
  2.     // BeforeAdvice    
  3.     Object retVal = null;    
  4.     try {    
  5.         // AroundAdvice    
  6.         retVal = method.invoke(target, args);    
  7.         // AroundAdvice    
  8.         // AfterReturningAdvice    
  9.     }    
  10.     catch (Throwable e) {    
  11.         // AfterThrowingAdvice    
  12.     }    
  13.     finally {    
  14.         // AfterAdvice    
  15.     }    
  16.     return retVal;    
  17. }    

     上面是对于Spring AOP使用JDK动态代理实现的基本框架代码，当然具体的实现肯定比这个复杂得多，但是基本原理不外乎如是。所以理解基本原理对于理解其他的代码也是很有好处的。


但是，JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。 

Cglib动态代理 
JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 


示例 

1、BookFacadeCglib.java 

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. <strong><span style="font-family:Arial;color:#333333;"><span style="font-size: 14px;">   </span></span></strong> package net.battier.dao;    
  2.         
  3.     public interface BookFacade {    
  4.         public void addBook();    
  5.     }  <strong><span style="font-family:Arial;color:#333333;"><span style="font-size: 14px;">  
  6. </span></span></strong>  


2、BookCadeImpl1.java 

[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. <strong>   </strong> package net.battier.dao.impl;    
  2.         
  3.     /**  
  4.      * 这个是没有实现接口的实现类  
  5.      *   
  6.      * @author student  
  7.      *   
  8.      */    
  9.     public class BookFacadeImpl1 {    
  10.         public void addBook() {    
  11.             System.out.println("增加图书的普通方法...");    
  12.         }    
  13.     }  <strong>  
  14. </strong>  


3、BookFacadeProxy.java


[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. <strong>   </strong> package net.battier.proxy;    
  2.         
  3.     import java.lang.reflect.Method;    
  4.         
  5.     import net.sf.cglib.proxy.Enhancer;    
  6.     import net.sf.cglib.proxy.MethodInterceptor;    
  7.     import net.sf.cglib.proxy.MethodProxy;    
  8.         
  9.     /**  
  10.      * 使用cglib动态代理  
  11.      *   
  12.      * @author student  
  13.      *   
  14.      */    
  15.     public class BookFacadeCglib implements MethodInterceptor {    
  16.         private Object target;    
  17.         
  18.         /**  
  19.          * 创建代理对象  
  20.          *   
  21.          * @param target  
  22.          * @return  
  23.          */    
  24.         public Object getInstance(Object target) {    
  25.             this.target = target;    
  26.             Enhancer enhancer = new Enhancer();    
  27.             enhancer.setSuperclass(this.target.getClass());    
  28.             // 回调方法    
  29.             enhancer.setCallback(this);    
  30.             // 创建代理对象    
  31.             return enhancer.create();    
  32.         }    
  33.         
  34.         @Override    
  35.         // 回调方法    
  36.         public Object intercept(Object obj, Method method, Object[] args,    
  37.                 MethodProxy proxy) throws Throwable {    
  38.             System.out.println("事物开始");    
  39.             proxy.invokeSuper(obj, args);    
  40.             System.out.println("事物结束");    
  41.             return null;    
  42.         
  43.         
  44.         }    
  45.         
  46.     }  <strong>  
  47. </strong>  

4、TestCglib.java


[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. <strong>    </strong>package net.battier.test;    
  2.         
  3.     import net.battier.dao.impl.BookFacadeImpl1;    
  4.     import net.battier.proxy.BookFacadeCglib;    
  5.         
  6.     public class TestCglib {    
  7.             
  8.         public static void main(String[] args) {    
  9.             BookFacadeCglib cglib=new BookFacadeCglib();    
  10.             BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());    
  11.             bookCglib.addBook();    
  12.         }    
  13.     }  <strong>  
  14. </strong>  

参考文章：http://blog.csdn.net/mhmyqn/article/details/48474815

                       http://blog.csdn.net/lovelion/article/details/8116704

                       http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html



B-Tree
关注
专栏目录
深入理解Java动态代理与代码模拟JDK实现动态代理【JAVA核心】
罗先森何其有幸的博客
04-02 4861
前言文章目录如下，便于快速索引一、什么叫代理？二、什么叫动态代理？三、动态代理有什么优势？四、动态代理的JDK实现原理    4.1核心类/接口    4.2 代理类$Proxy0解析    4.3 动态代理的经典使用五、手写代码模拟JDK动态代理六、参考资料项目源码已经上传，欢迎点击下载~先将自己总结的Java动态代理UML图放在前面，用相同的颜色代表同一个或本质上相同的类与方法，便于大家理解。...
JAVA动态代理实现Demo（JDK动态代理和CGLIB动态代理）
12-19
Java提供了两种主要的动态代理实现方式：JDK动态代理和CGLIB动态代理。 **JDK动态代理**： JDK动态代理基于接口实现，也就是说，被代理的对象必须实现至少一个接口。代理机制的核心是`java.lang.reflect.Proxy`类和...
Java动态代理实现
kongxx的专栏
07-04 4762
Java动态代理实现  在目前的Java开发包中包含了对动态代理的支持，但是其实现只支持对接口的的实现。其实现主要通过是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。Proxy类主要用来获取动态代理对象，InvocationHandler接口用来约束调用者实现，如下，HelloWorld接口定义的业务方
Java实现动态代理
最新发布
ZHI_YUE的博客
07-08 615
JAVA动态代理一种结构型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。代理模式在客户端和目标对象之间起到一个中介的作用（1）功能增强: 基于某个功能，再增加一些功能。（目标类只负责核心功能，其他附属功能通过代理类完成。代理类的方法名与目标类的方法相同，内容不同，在核心功能外加了一些额外逻辑）（2）控制访问: 防止直接访问目标这种模式广泛应用于软件设计中，尤其是在需要延迟加载、访问控制、缓存实现、日志记录、事务管理、远程调用等场景中。
使用Java动态代理实现一个简单的网络请求拦截器.txt
08-17
### 使用Java动态代理实现一个简单的网络请求拦截器 #### 一、引言 在软件开发过程中，为了增强程序的功能或方便进行调试与监控，我们常常需要在不改变原有业务逻辑的基础上，添加一些额外的行为（如日志记录、...
java动态代理
weixin_44528095的博客
06-03 2056
动态代理通用模板
Java动态代理
CVPR收割机的博客
03-21 2088
代理类代理目标类（代理）目标类是实现目标功能的类（杨超越）
jdk动态代理
lolichan的博客
09-20 220
  简介 jdk动态代理用于在运行时生成实现多个接口的动态代理类，关键的类有两个 Proxy：提供多个静态方法用于创建动态代理类和动态代理对象，同时也是所有此种方式生成的动态代理类的父类 InvocationHandler：该接口只有一个方法如下，每个动态代理对象都有一个关联的InvocationHandler实例对象，当一个动态代理对象的方法被调用时，实际上是被分配到了Invocat...
Java中实现动态代理5种实现
austinlyway的博客
02-15 3437
Java动态代理的5中实现
java 中的动态代理实现
qq_38217393的博客
06-02 963
相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。代理模式是常见的设计模式之一，顾名思义，代理模式就是代理对象具备真实对象的功能，并代替真实对象完成相应操作，并能够在操作执行的前后，对操作进行增强处理。代理模式就是为其他对象提供一种代理来控制这个对象的访问，在某些情况下一个对象不适合或不能直接引用另一个对象，而代理对象可以在客户类和目标对象直接起到中介的作用。这时，可以在a和c之间创建一个b类代理，a类访问b类，b类访问c类。生成的代理类源码方法。
java动态代理实现
zbq1334的博客
07-30 374
Java中的代理有静态代理和动态代理，下面我会分别用一个简单的例子来介绍一下静态代理和动态代理代码实现。 1 静态代理 代理接口：UserDao.java public interface UserDao { void save(); } 目标对象：UserDaoImpl.java public class UserDaoImpl implements UserDao...
用java实现动态代理
weixin_35756637的博客
12-30 210
动态代理是指在运行时动态地创建代理类的机制。在 Java 中，动态代理可以使用 java.lang.reflect.Proxy 类实现。 要实现动态代理，你需要定义一个接口并创建该接口的实现类。然后你可以使用 Proxy 类的 newProxyInstance 方法来创建该接口的代理。这个方法需要三个参数： 一个类加载器(ClassLoader)，它负责加载代理类。 一个接口数组，表示该代理类要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值