zoukankan      html  css  js  c++  java

  • 代理模式 及 实现AOP 拦截机制

    原文出处：http://chjl2020.iteye.com/blog/517835

    代理模式:给某一对象提供代理对象,并由代理对象控制具体对象的引用. 

    代理,指的就是一个角色代表另一个角色采取行动,就象生活中,一个红酒厂商,是不会直接把红酒零售客户的,都是通过代理来完成他的销售业务的.而客户,也不用为了喝红酒而到处找工厂,他只要找到厂商在当地的代理就行了,具体红酒工厂在那里,客户不用关心,代理会帮他处理. 

    代理模式涉及的角色: 
    1:抽象主题角色.声明了代理主题和真实主题的公共接口,使任何需要真实主题的地方都能用代理主题代替. 

    2:代理主题角色.含有真实主题的引用,从而可以在任何时候操作真实主题,代理主题功过提供和真实主题相同的接口,使它可以随时代替真实主题.代理主题通过持有真实主题的引用,不但可以控制真实主题的创建或删除,可以在真实主题被调用前进行拦截,或在调用后进行某些操作. 

    3:真实代理对象.定义了代理角色所代表的具体对象. 

    下面是代理模式的实现类图: 
     

    根据上图的关系,我们可以用客户买红酒来模拟代理模式的实现, 

    红酒代理商和红酒厂商都有销售红酒的只能,我们可以为他们定义一个共同的抽象主题角色, 

    Java代码  收藏代码
    1. /** 
    2. *抽象主题角色,定义了真实角色和代理角色的公共接口 
    3. */  
    4. public interface SellInterface{  
    5.      public Object sell();  
    6. }  



    接着,我们定义真实主题角色(这里就是红酒工厂),它必须实现了SellInterface接口的. 

    Java代码  收藏代码
    1. /** 
    2. *真实主题角色,这里指红酒工厂角色,它实现了SellInterface接口 
    3. */  
    4. public class RedWineFactory implements SellInterface{  
    5.      public Object sell(){  
    6.          System.out.println("真实主题角色RedWineFactory 被调用了");  
    7.          return new Object();  
    8.      }  
    9. }  



    下面是代理主题角色(这里指红酒代理商),同样,代理主题也必须实现SellInterface接口. 

    Java代码  收藏代码
    1. /** 
    2. *代理主题角色,这里指红酒代理商.它除了也要实现了sellInterface接口外,还持有红酒 
    3. *厂商RedWineFactory 对象的引用,从而使它能在调用真实主题前后做一些必要处理. 
    4. */  
    5. public class RedWineProxy implements SellInterface{  
    6.      //持有一个RedWineFactory对象的引用  
    7.       private RedWineFactory redWineFactory;  
    8.   
    9.      //销售总量  
    10.       private static int sell_count = 0;  
    11.   
    12.      public Object sell(){  
    13.          if(checkUser()){//在通过代理主题角色,我们可以在真实主题角色被调用前做一些诸如权限判断的事情  
    14.              Object obj = redWineFactory.sell();  
    15.              count ++;//同样,在调用后我们也可以执行一些额外的动作.  
    16.              return obj ;  
    17.          }else{  
    18.              throw new RuntimeException();  
    19.          }  
    20.      }  
    21.   
    22.      protected boolean checkUser(){  
    23.             //do something  
    24.             return true;  
    25.      }  
    26. }  



    接下来看看调用代理对象的代码 

    Java代码  收藏代码
    1. public static void main(String agr[])  
    2. {  
    3.      SellInterface sell = new RedWineProxy();  
    4.      sell.sell();  
    5. }  



    从上面的例子可以看出代理模式的工作方式,首先,因为代理主题和真实主题都实现了共同的接口,这使我们可以在不改变原来接口的情况下,只要用真实主题对象的地方,都可以用代理主题来代替.其次,代理主题在客户和真实主题之间起了一个中介作用,利用这个中介平台,我们可以在把客户请求传递给真实主题之前,做一些必要的预处理. 

    java对代理模式的支持 ---动态代理 
    上面的代理,我们强迫代理类RedWineProxy实现了抽象接口SellInterface.这导致我们的代理类无法通用于其他接口,所以不得不为每一个接口实现一个代理类.幸好,java为代理模式提供了支持. 
    java主要是通过Proxy类和InvocationHandler接口来给实现对代理模式的支持的. 
    下面用java的代理机制来实现上面的例子 

    Java代码  收藏代码
    1. import java.lang.reflect.InvocationHandler;  
    2. import java.lang.reflect.Method;  
    3. import java.lang.reflect.Proxy;  
    4. /** 
    5. *代理类一定要实现了InvocationHandler接口 
    6. */  
    7. public class ProxyObject implements InvocationHandler{  
    8.     private Object proxy_obj;  
    9.   
    10.     ProxyObject(Object obj){  
    11.         this.proxy_obj = obj;  
    12.     }  
    13.   
    14.     public static Object factory(Object obj){  
    15.         Class cls = obj.getClass();  
    16.         //通过Proxy类的newProxyInstance方法来返回代理对象  
    17.         return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),new ProxyObject(obj));  
    18.     }  
    19.   
    20. /** 
    21. *实现InvocationHandler接口的invoke 
    22. */  
    23.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
    24.         System.out.println("函数调用前被拦截了:   " + method);  
    25.         if(args != null){  
    26.             //打印参数列表  
    27.             System.out.println("方法有  " + args.length + "    个参数");  
    28.             for(int i = 0; i < args.length; i ++){  
    29.                 System.out.println(args[i]);  
    30.             }  
    31.         }  
    32.         //利用反射机制动态调用原对象的方法  
    33.          Object mo = method.invoke(proxy_obj, args);  
    34.         System.out.println("函数调用后进行处理 :   " + method);  
    35.         return mo;  
    36.     }  
    37.   
    38.     //测试代码      
    39.     public static void main(String agr[]){  
    40.         SellInterface si = (SellInterface)factory(new RedWineFactory());  
    41.         si.sell();  
    42.     }  
    43. }  


    通过上面的代码可以看出,代理主题ProxyObject类并没有实现我们定义的SellInterface借口, 
    而是实现了java的InvocationHandler接口,这样就把代理主题角色和我们的业务代码分离开来,使代理对象能通用于其他接口. 
    其实InvocationHandler接口就是一种拦截机制,当系统中有了代理对象以后,对原对象(真实主题)方法的调用,都会转由InvocationHandler接口来处理,并把方法信息以参数的形式传递给invoke方法,这样,我们就可以在invoke方法中拦截原对象的调用,并通过反射机制来动态调用原对象的方法.这好象也是spring aop编程的基础吧 

    接着,用代理模式实现一个超级简单的aop拦截机制 
    这个例子可以拦截我们指定的函数,并在拦截前后根据需要进行处理 

    Java代码  收藏代码
    1. /** 
    2. *切面接口,通过实现这个接口,我们可以对指定函数在调用前后进行处理 
    3. */  
    4. public interface AopInterface {  
    5.    public void before(Object obj);//调用的处理  
    6.    public void end(Object obj);//调用后的处理  
    7. }  



    这个是实现了AopInterface 接口,在这里我们实现了我们的处理逻辑 

    Java代码  收藏代码
    1. public class AopInterfaceImp implements AopInterface{  
    2.   
    3.     public void before(Object obj) {  
    4.         System.out.println("调用前拦截");  
    5.     }  
    6.   
    7.     public void end(Object obj) {  
    8.         System.out.println("调用调用后处理");  
    9.     }  
    10.   
    11. }  



    接着是代理类 

    Java代码  收藏代码
    1. public class PeoxyObject implements InvocationHandler {  
    2.     private AopInterface aop;//定义了切入时调用的方法  
    3.     private Object proxy_obj;  
    4.     private String methodName;//指定要切入的方法名  
    5.   
    6.     PeoxyObject(){}  
    7.   
    8.     public Object factory(Object obj){  
    9.         proxy_obj = obj;  
    10.         Class cls = obj.getClass();  
    11.         return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),this);  
    12.     }  
    13.   
    14.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
    15.         if(this.aop == null)throw new NullPointerException("aop is null");  
    16.         if(method == null)throw new NullPointerException("method is null");  
    17.   
    18.         Object o;  
    19. //如果指定了要拦截方法名,并且调用的方法和指定的方法名相同,则进行拦截处理  
    20. //否则当正常方法处理  
    21.         if(methodName != null && method.toString().indexOf(methodName) != -1){  
    22.             aop.before(proxy_obj);//指定方法调用前的处理  
    23.             o = method.invoke(proxy_obj, args);  
    24.             aop.end(proxy_obj);//指定方法调用后的处理  
    25.         }else{  
    26.             //没有指定的方法,以正常方法调用  
    27.             o = method.invoke(proxy_obj, args);  
    28.         }  
    29.         return o;  
    30.     }  
    31.   
    32.     public AopInterface getAop() {  
    33.         return aop;  
    34.     }  
    35.   
    36.     public void setAop(AopInterface aop) {  
    37.         this.aop = aop;  
    38.     }  
    39.   
    40.     public String getMethodName() {  
    41.         return methodName;  
    42.     }  
    43.   
    44.     public void setMethodName(String methodName) {  
    45.         this.methodName = methodName;  
    46.     }  
    47. }  



    这里定义一个用来测试用的类 

    Java代码  收藏代码
    1. public interface SubInterface {  
    2.     public void add(String value1,String value2);  
    3.     public void acc(String value1);  
    4. }  
    5.   
    6. public class ImpObject implements SubInterface{  
    7.   
    8.     public void add(String value1,String value2) {  
    9.         System.out.println("ImpObject add(String value1,String value2)");  
    10.     }  
    11.   
    12.     public void acc(String value1){  
    13.         System.out.println("ImpObject acc(String value1)");  
    14.     }  
    15.   
    16. }  



    这里是测试代码 

    Java代码  收藏代码
    1. public static void main(String agr[]){  
    2.      PeoxyObject po = new PeoxyObject();  
    3.   
    4.      po.setAop(new AopInterfaceImp());//我们实现的拦截处理对象  
    5.       po.setMethodName("acc");//指定要拦截的函数  
    6.        
    7.       SubInterface si = (SubInterface)po.factory(new ImpObject());  
    8.    //因为add方法不是我们指定的拦截函数,AopInterfaceImp是不会被执行  
    9.       si.add("tt","dd");     
    10.   
    11.    //acc是我们指定的拦截方法,所以调用acc的前后会先执行AopInterfaceImp  
    12.     //对象的两个方法  
    13.       si.acc("tt");  
    14.  }  



    通过上面可以看出,拦截机制是代理模式的重要使用方式之一, 
    除了拦截,代理模式还常用于资源加载,当我们要加载的资源很大时,我们可以让真实主题角色在后台加载资源,让代理主题角色负责处理前台的等待提示信息. 
    还有就是授权机制,通过代理能拦截真实主题的能力,来控制真实主题的访问权限.

    jdk动态代理和cgli代理的区别

    http://www.iteye.com/topic/1121357

    http://blog.csdn.net/xpsharp/article/details/9428663

    比如AOP开启事务，注解的方式：

    基于JDK动态代理 ，可以将@Transactional放置在接口和具体类上。

    基于CGLIB类代理，只能将@Transactional放置在具体类上。

    因此 在实际开发时全部将@Transactional放到具体类上，而不是接口上。

    当一个对象（客户端）不能或者不想直接引用另一个对象（目标对象），这时可以应用代理模式在这两者之间构建一个桥梁--代理对象。按照代理对象的创建时期不同，可以分为两种：
    静态代理：程序员事先写好代理对象类，在程序发布前就已经存在了；
    动态代理：应用程序发布后，通过动态创建代理对象。
    其中动态代理又可分为：
     

    1.JDK动态代理

    此时代理对象和目标对象实现了相同的接口，目标对象作为代理对象的一个属性，具体接口实现中，可以在调用目标对象相应方法前后加上其他业务处理逻辑。

    代理模式在实际使用时需要指定具体的目标对象，如果为每个类都添加一个代理类的话，会导致类很多，同时如果不知道具体类的话，怎样实现代理模式呢？这就引出动态代理。

    JDK动态代理只能针对实现了接口的类生成代理。

    2.CGLIB代理

    CGLIB（CODE GENERLIZE LIBRARY）代理是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的所有方法，所以该类或方法不能声明称final的。

    如果目标对象没有实现接口，则默认会采用CGLIB代理；

    如果目标对象实现了接口，可以强制使用CGLIB实现代理（添加CGLIB库，并在spring配置中加入<aop:aspectj-autoproxy proxy-target-class="true"/>）。

    AOP包括切面（aspect）、通知（advice）、连接点（joinpoint），实现方式就是通过对目标对象的代理在连接点前后加入通知，完成统一的切面操作。
  • 相关阅读:
    Centos7.3安装jdk和maven
    Centos7.3安装sftp服务和ssh
    Centos7.3安装，并设置网络和防火墙
    Docker 常用命令
    Tomcat配置
    MySQL配置
    配置JDK
    JTable的模型
    JavaBean和List<JavaBean>
    JavaBean
  • 原文地址：https://www.cnblogs.com/alexlo/p/2989353.html
Copyright © 2011-2022 走看看