zoukankan      html  css  js  c++  java

  • java动态代理

    JAVA的动态代理 

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

     

    首先看一下静态代理： 
    1、Count.java 

    Java代码  
    1. package net.battier.dao;  
    2.   
    3. /** 
    4.  * 定义一个账户接口 
    5.  *  
    6.  * @author Administrator 
    7.  *  
    8.  */  
    9. public interface Count {  
    10.     // 查看账户方法  
    11.     public void queryCount();  
    12.   
    13.     // 修改账户方法  
    14.     public void updateCount();  
    15.   
    16. }  


    2、CountImpl.java 

    Java代码  
    1. package net.battier.dao.impl;  
    2.   
    3. import net.battier.dao.Count;  
    4.   
    5. /** 
    6.  * 委托类(包含业务逻辑) 
    7.  *  
    8.  * @author Administrator 
    9.  *  
    10.  */  
    11. public class CountImpl implements Count {  
    12.   
    13.     @Override  
    14.     public void queryCount() {  
    15.         System.out.println("查看账户方法...");  
    16.   
    17.     }  
    18.   
    19.     @Override  
    20.     public void updateCount() {  
    21.         System.out.println("修改账户方法...");  
    22.   
    23.     }  
    24.   
    25. }  
    26.   
    27. 、CountProxy.java  
    28. package net.battier.dao.impl;  
    29.   
    30. import net.battier.dao.Count;  
    31.   
    32. /** 
    33.  * 这是一个代理类（增强CountImpl实现类） 
    34.  *  
    35.  * @author Administrator 
    36.  *  
    37.  */  
    38. public class CountProxy implements Count {  
    39.     private CountImpl countImpl;  
    40.   
    41.     /** 
    42.      * 覆盖默认构造器 
    43.      *  
    44.      * @param countImpl 
    45.      */  
    46.     public CountProxy(CountImpl countImpl) {  
    47.         this.countImpl = countImpl;  
    48.     }  
    49.   
    50.     @Override  
    51.     public void queryCount() {  
    52.         System.out.println("事务处理之前");  
    53.         // 调用委托类的方法;  
    54.         countImpl.queryCount();  
    55.         System.out.println("事务处理之后");  
    56.     }  
    57.   
    58.     @Override  
    59.     public void updateCount() {  
    60.         System.out.println("事务处理之前");  
    61.         // 调用委托类的方法;  
    62.         countImpl.updateCount();  
    63.         System.out.println("事务处理之后");  
    64.   
    65.     }  
    66.   
    67. }  

     

    3、TestCount.java 

    Java代码  
    1. package net.battier.test;  
    2.   
    3. import net.battier.dao.impl.CountImpl;  
    4. import net.battier.dao.impl.CountProxy;  
    5.   
    6. /** 
    7.  *测试Count类 
    8.  *  
    9.  * @author Administrator 
    10.  *  
    11.  */  
    12. public class TestCount {  
    13.     public static void main(String[] args) {  
    14.         CountImpl countImpl = new CountImpl();  
    15.         CountProxy countProxy = new CountProxy(countImpl);  
    16.         countProxy.updateCount();  
    17.         countProxy.queryCount();  
    18.   
    19.     }  
    20. }  

     

    观察代码可以发现每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。 
    再来看一下动态代理： 
    JDK动态代理中包含一个类和一个接口： 
    InvocationHandler接口： 
    public interface InvocationHandler { 
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 
    } 
    参数说明： 
    Object proxy：指被代理的对象。 
    Method method：要调用的方法 
    Object[] args：方法调用时所需要的参数 

    可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。 

    Proxy类： 
    Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法： 
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, 
    InvocationHandler h) 
                                   throws IllegalArgumentException 
    参数说明： 
    ClassLoader loader：类加载器 
    Class<?>[] interfaces：得到全部的接口 
    InvocationHandler h：得到InvocationHandler接口的子类实例 

    Ps:类加载器 
    在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器; 
    Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的； 
    Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类; 
    AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。 

    动态代理 
    与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 

    动态代理示例: 
    1、BookFacade.java 

    Java代码  
    1. package net.battier.dao;  
    2.   
    3. public interface BookFacade {  
    4.     public void addBook();  
    5. }  

     

    2、BookFacadeImpl.java 

    Java代码  
    1. package net.battier.dao.impl;  
    2.   
    3. import net.battier.dao.BookFacade;  
    4.   
    5. public class BookFacadeImpl implements BookFacade {  
    6.   
    7.     @Override  
    8.     public void addBook() {  
    9.         System.out.println("增加图书方法。。。");  
    10.     }  
    11.   
    12. }  
    13.   
    14. 、BookFacadeProxy.java  
    15.   
    16. package net.battier.proxy;  
    17.   
    18. import java.lang.reflect.InvocationHandler;  
    19. import java.lang.reflect.Method;  
    20. import java.lang.reflect.Proxy;  
    21.   
    22. /** 
    23.  * JDK动态代理代理类 
    24.  *  
    25.  * @author student 
    26.  *  
    27.  */  
    28. public class BookFacadeProxy implements InvocationHandler {  
    29.     private Object target;  
    30.     /** 
    31.      * 绑定委托对象并返回一个代理类 
    32.      * @param target 
    33.      * @return 
    34.      */  
    35.     public Object bind(Object target) {  
    36.         this.target = target;  
    37.         //取得代理对象  
    38.         return Proxy.newProxyInstance(target.getClass().getClassLoader(),  
    39.                 target.getClass().getInterfaces(), this);   //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)  
    40.     }  
    41.   
    42.     @Override  
    43.     /** 
    44.      * 调用方法 
    45.      */  
    46.     public Object invoke(Object proxy, Method method, Object[] args)  
    47.             throws Throwable {  
    48.         Object result=null;  
    49.         System.out.println("事物开始");  
    50.         //执行方法  
    51.         result=method.invoke(target, args);  
    52.         System.out.println("事物结束");  
    53.         return result;  
    54.     }  
    55.   
    56. }  

     

    3、TestProxy.java 

    Java代码  
    1. package net.battier.test;  
    2.   
    3. import net.battier.dao.BookFacade;  
    4. import net.battier.dao.impl.BookFacadeImpl;  
    5. import net.battier.proxy.BookFacadeProxy;  
    6.   
    7. public class TestProxy {  
    8.   
    9.     public static void main(String[] args) {  
    10.         BookFacadeProxy proxy = new BookFacadeProxy();  
    11.         BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());  
    12.         bookProxy.addBook();  
    13.     }  
    14.   
    15. }  

     

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

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

    Java代码  
    1. package net.battier.dao;  
    2.   
    3. public interface BookFacade {  
    4.     public void addBook();  
    5. }  

     

    2、BookCadeImpl1.java 

    Java代码  
    1. 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. }  


    3、BookFacadeProxy.java 

    Java代码  
    1. 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. }  


    4、TestCglib.java 

    Java代码  
    1. 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. }  

     

    另一个人对动态代理的理解：

    Java代码 
    1. /** 
    2.  * 相亲接口 
    3.  *  
    4.  * @author zhengt 
    5.  * @time Jun 3, 2095 3:13:03 PM 
    6.  */  
    7. public interface XiangQinInterface {  
    8.     /** 
    9.      * 相亲方法 
    10.      */  
    11.     public void xiangQin();  
    12. }  
    13. /** 
    14.  * 张三相亲实现类 
    15.  *  
    16.  * @author zhengt 
    17.  * @time Jun 3, 2095 3:14:48 PM 
    18.  */  
    19. public class ZhangSanXiangQinInterfaceImpl implements XiangQinInterface {  
    20.     public void xiangQin() {  
    21.         System.out.println("张三去相亲，娶个漂亮老婆。");  
    22.     }  
    23. }  
    24. import java.lang.reflect.InvocationHandler;  
    25. import java.lang.reflect.Method;  
    26.   
    27. /** 
    28.  * 相亲可是一辈子的大事，相亲前要准备一下，打扮得帅气些。 
    29.  *  
    30.  * @author zhengt 
    31.  * @time Jun 3, 2095 3:15:48 PM 
    32.  */  
    33. public class ReadyInvocationHandler implements InvocationHandler {  
    34.     //相亲接口的实现类，也就是张三相亲类  
    35.     private Object zhangSan = null;  
    36.   
    37.     public ReadyInvocationHandler(Object realSubject) {  
    38.         this.zhangSan = realSubject;  
    39.     }  
    40.   
    41.     public Object invoke(Object proxy, Method m, Object[] args) {  
    42.         Object result = null;  
    43.         try {  
    44.             /** 
    45.              * 动态代理类$Proxy0调用xiangQin方法时会调用它自己的xiangQin方法， 
    46.              * 而它自己的xiangQin方法里面调用的是super.h.invoke(this, , )，也就是父类Proxy的h的invoke方法， 
    47.              * 也就是ReadyInvocationHandler类的invoke方法。 
    48.              * 所以，invoke(Object proxy, Method m, Object[] args)种的proxy实际上就是动态代理类$Proxy0， 
    49.              * 如果你将其强转成XiangQinInterface然后调用它的xiangQin方法，然后它就会调用super.h.invoke(this, , )，这样就会死循环。 
    50.              */  
    51.             /** 
    52.              * 网上关于这里最多问题就是Object proxy放在这里用来做什么呢？这个我也不知道， 
    53.              * 不过至少我们知道它到底是个什么东西，具体做什么用嘛就不得而知了 
    54.              */  
    55.             System.out.println(proxy.getClass().getSimpleName());  
    56.             System.out.println("张三相亲前，代理人给他打扮了打扮。");  
    57.             result = m.invoke(zhangSan, args);  
    58.         } catch (Exception ex) {  
    59.             System.exit(1);  
    60.         }  
    61.         return result;  
    62.     }  
    63. }  
    64. import java.lang.reflect.InvocationHandler;  
    65. import java.lang.reflect.Method;  
    66. import java.lang.reflect.Proxy;  
    67.   
    68. /** 
    69.  * 张三来到了婚介所(相亲现场)，开始相亲。 
    70.  *  
    71.  * @author zhengt 
    72.  * @time Jun 3, 2095 3:17:16 PM 
    73.  */  
    74. public class HunJieSuo {  
    75.     public static void main(String args[]) {  
    76.         //先将张三相亲这个相亲的实现类实例化，也就是得到XiangQinInterface接口的一个实例对象  
    77.         XiangQinInterface zhangSan = new ZhangSanXiangQinInterfaceImpl();  
    78.         /** 
    79.          * 得到ZhangSanXiangQinInterfaceImpl这个类的一个代理类，同时为代理类绑定了一个处理类ReadyInvocationHandler。 
    80.          * 听着很绕口，其实就是每次调用ZhangSanXiangQinInterfaceImpl这个子类的xiangQin方法时， 
    81.          * 不是zhangSan这个ZhangSanXiangQinInterfaceImpl类的实例去调用， 
    82.          * 而是这个ZhangSanXiangQinInterfaceImpl的代理类ReadyInvocationHandler去调用它自己的invoke方法, 
    83.          * 这个invoke方法里呢可以调用zhangSan这个实例的xiangQin方法 
    84.          */  
    85.         /** 
    86.          * 在java种怎样实现动态代理呢 
    87.          * 第一步，我们要有一个接口，还要有一个接口的实现类，而这个实现类呢就是我们要代理的对象， 
    88.          * 所谓代理呢也就是在调用实现类的方法时，可以在方法执行前后做额外的工作，这个就是代理。 
    89.          * 第二步，我们要自己写一个在要代理类的方法执行时，能够做额外工作的类，而这个类必须继承InvocationHandler接口， 
    90.          * 为什么要继承它呢？因为代理类的实例在调用实现类的方法的时候，不会调真正的实现类的这个方法， 
    91.          * 而是转而调用这个类的invoke方法（继承时必须实现的方法），在这个方法中你可以调用真正的实现类的这个方法。 
    92.          * 第三步，在要用代理类的实例去调用实现类的方法的时候，写出下面两段代码。 
    93.          */  
    94.         XiangQinInterface proxy = (XiangQinInterface) Proxy.newProxyInstance(  
    95.                 zhangSan.getClass().getClassLoader(),  
    96.                 zhangSan.getClass().getInterfaces(),  
    97.                 new ReadyInvocationHandler(zhangSan));  
    98.         proxy.xiangQin();  
    99.         /** 
    100.          * 这里要解释下中部那段长长的代码的意思，以及具体做了哪些工作？ 
    101.          * 第一，根据zhangSan.getClass().getClassLoader()这个要代理类的类加载器和 
    102.          * zhangSan.getClass().getInterfaces()要代理类所实现的所有的接口 
    103.          * 作为参数调用Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces) 
    104.          * 的方法返回代理类的java.lang.Class对象，也就是得到了java动态生成的代理类$Proxy0的Class对象。 
    105.          * 同时，java还让这个动态生成的$Proxy0类实现了要代理类的实现的所有接口，并继承了Proxy接口。 
    106.          * 第二，实例化这个动态生成的$Proxy0类的一个实例，实例化代理类的构造函数为Proxy(InvocationHandler h)， 
    107.          * 也就是说要实例化这个动态生成的$Proxy0类，必须给它一个InvocationHandler参数，也就是我们自己实现的用来在代理类 
    108.          * 方法执行前后做额外工作的类ReadyInvocationHandler。 
    109.          * 这段代码Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan)) 
    110.          * 得到的其实是一个类名叫$Proxy0 extends Proxy implements XiangQinInterface的类。 
    111.          * 第三，将这个$Proxy0类强制转型成XiangQinInterface类型，调用xiangQin方法。 
    112.          */  
    113.     }  
    114. }  

     
  • 相关阅读:
    Multidimensional Arrays
    TortoiseGit
    Excel教程(14)
    Excel教程(13)
    Excel教程(12)
    Excel教程(11)
    lock
    reflect
    game
    html x
  • 原文地址：https://www.cnblogs.com/happyPawpaw/p/2724476.html
Copyright © 2011-2022 走看看