aop的几种用法

   我们经常会用到的有如下几种

        1、基于代理的AOP

        2、纯简单Java对象切面

        3、@Aspect注解形式的

        4、注入形式的Aspcet切面

下面我们就一个一个来应用吧.

下面先写一下几个基本的类。

接口类：

 /**
  * 定义一个接口
  * @author 陈丽娜
  * @version 2015年5月31日上午9:16:50
  */
 public interface Sleepable {

     /**
      * 睡觉方法
      * @author 陈丽娜
      * @version 2015年5月31日上午9:17:14
      */
     void sleep();
 }

实现类：

 /**
  * 陈丽娜 本人实现睡觉接口
  * @author 陈丽娜
  * @version 2015年5月31日下午4:51:43
  */
 public class ChenLliNa implements Sleepable {

     @Override
     public void sleep() {
         // TODO Auto-generated method stub
         System.out.println("乖,该睡觉了！");
     }
 }

增强类：

 /**
  * 定义一个睡眠的增强 同时实现前置 和后置
  * @author 陈丽娜
  * @version 2015年5月31日上午9:24:43
  */
 public class SleepHelper implements MethodBeforeAdvice, AfterReturningAdvice {

     @Override
     public void afterReturning(Object returnValue, Method method,
             Object[] args, Object target) throws Throwable {
          System.out.println("睡觉前要敷面膜");
     }

     @Override
     public void before(Method method, Object[] args, Object target)
             throws Throwable {
         System.out.println("睡觉后要做美梦");
     }

 }

一、基于代理的AOP

 

  

     "sleepHelper" class="com.tgb.springaop.aspect.SleepHelper"/>

     "lina" class="com.tgb.springaop.service.impl.ChenLliNa"/>

     "sleepPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
            "pattern" value=".*sleep">



     "sleepHelperAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
          "advice" ref="sleepHelper"/>
          "pointcut" ref="sleepPointcut"/>



     "linaProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
             "target" ref="lina"/>
             "interceptorNames" value="sleepHelperAdvisor"/>

如配置文件中：

pattern属性指定了正则表达式，他匹配所有的sleep方法

使用org.springframework.aop.support.DefaultPointcutAdvisor的目的是为了使切点和增强结合起来形成一个完整的切面

最后配置完后通过org.springframework.aop.framework.ProxyFactoryBean产生一个最终的代理对象。

 

二、纯简单java对象切面

纯简单java对象切面这话怎么说呢，在我看来就是相对于第一种配置，不需要使用代理，，而是通过spring的内部机制去自动扫描，这时候我们的配置文件就该如下修改：

 

 "sleepHelper" class="com.tgb.springaop.aspect.SleepHelper"/>

 "lina" class="com.tgb.springaop.service.impl.ChenLliNa"/>


 "sleepAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
      "advice" ref="sleepHelper">
      "pattern" value=".*sleep"/>



 class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>

是不是相对于第一种简单了许多，不用再去配置代理了。

 

三、@Aspect注解形式

根据我们的经验也知道，注解的形式相对于配置文件是简单一些的，这时候需要在已有的方法或类上家注解：

 /**
  * 通过注解的方式 添加增强
  * @author 陈丽娜
  * @version 2015年5月31日上午10:26:13
  */
 @Aspect
 @Component
 public class SleepHelper03 {

     /*@Pointcut("execution(* com.tgb.springaop.service.impl..*(..))")*/
     @Pointcut("execution(* *.sleep(..))")
     public void sleeppoint(){}

     @Before("sleeppoint()")
     public void beforeSleep(){
         System.out.println("睡觉前要敷面膜");
     }

     @AfterReturning("sleeppoint()")
     public void afterSleep(){
         System.out.println("睡觉后要做美梦");
     }

配置文件中只需写：

      <context:component-scan base-package="com.tgb" annotation-config="true"/>

      <aop:aspectj-autoproxy  proxy-target-class="true" />


       <bean id="lina" class="com.tgb.springaop.service.impl.ChenLliNa"/>

 

四、注入形式的Aspcet切面

个人感觉这个是最简单的也是最常用的，也是最灵活的。配置文件如下：

     <bean id="lina" class="com.tgb.springaop.service.impl.ChenLliNa"/>
     <bean id ="sleepHelper" class="com.tgb.springaop.aspect.SleepHelper02"/>

     <aop:config>
         <aop:aspect ref="sleepHelper">
              <aop:before method="beforeSleep" pointcut="execution(* *.sleep(..))"/>
              <aop:after method="afterSleep" pointcut="execution(* *.sleep(..))"/>
         aop:aspect>
     aop:config>

配置文件中提到的SleepHelper02类如下：

 /**
  * 通过注解的方式 添加增强
  * @author 陈丽娜
  * @version 2015年5月31日上午10:26:13
  */

 public class SleepHelper02 {
     public void beforeSleep(){
         System.out.println("睡觉前要敷面膜");
     }
     public void afterSleep(){
         System.out.println("睡觉后要做美梦");
     }
 }

 

是不是看上去都很简单呀，这样是不是大家都会使用spring aop了？！

 

关于如何调用，这里写了几个测试类，可以看一下，基本都一样：

 

 /**
  * 配置文件 spring_aop.xml  通过代理
  * @author 陈丽娜
  * @version 2015年5月31日上午10:09:10
  */
 @Test
 public void test(){
     ApplicationContext ct = new ClassPathXmlApplicationContext("spring_aop.xml");

     Sleepable sleeper =(Sleepable) ct.getBean("linaProxy");

     sleeper.sleep();
 }

 /**
  * 配置文件 spring_aop_01.xml   简答的java对象
  * @author 陈丽娜
  * @version 2015年5月31日上午10:09:37
  */
 @Test
 public void test01(){
     ApplicationContext ct = new ClassPathXmlApplicationContext("spring_aop_01.xml");

     Sleepable sleeper = (Sleepable)ct.getBean("lina");

     sleeper.sleep();
 }

 /**
  * 配置文件 spring_aop_03.xml  通过aspect注解
  * @author 陈丽娜
  * @version 2015年5月31日上午10:09:37
  */
 @Test
 public void test03(){
     ApplicationContext ct = new ClassPathXmlApplicationContext("spring_aop_03.xml");

        Sleepable sleeper = (Sleepable)ct.getBean("lina");

     sleeper.sleep();
 }
 /**
  * 配置文件 spring_aop_02.xml  通过apsect配置文件
  * @author 陈丽娜
  * @version 2015年5月31日上午10:09:37
  */
 @Test
 public void test02(){
     ApplicationContext ct = new ClassPathXmlApplicationContext("spring_aop_02.xml");

     Sleepable sleeper = (Sleepable)ct.getBean("lina");

     sleeper.sleep();
 }

 

通过测试类可以看出，不管以什么样的方式来实现aop他们的使用都是没有差别的，这几个测试类的结果都是一样的：