spring框架应用系列四：切面编程（环绕通知与前后置通知区别）

切面编程（环绕通知与前后置通知区别）

本文系作者原创，转载请注明出处:http://www.cnblogs.com/further-further-further/p/7867034.html

解决问题

1、拥有前置通知和后置通知的功能，并能解决前置通知和后置通知在共享信息方面的不足（例如：统计切点方法执行时间）；

2、在多线程并发条件下，能保证线程安全（因为在一个方法内定义的局部变量）；

3、解决代码重复性，降低代码复杂程度；

内容说明

1、以下会给出前置通知、后置通知与环绕通知实例(观众观看表演)，通过对比更能理解彼此之间的区别；

2、两者都通过@Component注解，扫描（Audience,Juggler）bean并注册到spring容器中时，需在XML配置文件中引入component-scan（前后置通知：<context:component-scan base-package="com.spring.example.aspectAspectJNoArgs"/> 环绕通知：<context:component-scan base-package="com.spring.example.aspectAround"/>）

3、切面是观众（Audience）,切点是节目表演（Performance.perform()）
       前置通知：在节目表演之前，观众就坐（调用Audience的takeSeats方法），并关掉手机（调用Audience的turnOffCellPhones方法）；
       后置通知：在节目表演结束，观众鼓掌（调用Audience的applaud方法）；
       异常通知：节目表演出现异常，观众要求退票（调用Audience的demandRefund方法）；

环绕通知：其他与上面相同，只是在节目表演开始与结束时打印时间，统计节目表演时长；

4、通过执行Juggler的perform方法，从而执行切面Audience中相应的方法，达到通知的效果；

应用实例：观众观看表演所做出的相应行为

先列出相关接口以及类代码

节目表演接口（切点方法）

 package com.spring.example.aspectAround;
 
 /**
  * Created by weixw on 2017/11/16.
  */
 public interface Performer {
 
     void perform();
 }

切点类实现接口Juggler

 package com.spring.example.aspectAround;
 
 import org.springframework.stereotype.Component;
 
 /**
  * Created by weixw on 2017/11/16.
  */
 @Component
 public class Juggler implements Performer {
     private int beanBags = 3;
     public Juggler(){
 
     }
     public Juggler(int beanBags){
         this.beanBags = beanBags ;
     }
     @Override
     public void perform()  {
         System.out.println("JUGGLING "+ beanBags + " BEANBAGS");
         try {
             Thread.sleep(1);
         }catch (InterruptedException e){
             e.printStackTrace();
         }
     }
 
 }

上述代码都能共用，下面分别列举前后置通知与环绕通知区别代码

前后置通知（通过AspectJ注解实现，注意：<aop:aspectj-autoproxy/>不能少，它实现了切面相关方法绑定在切点上，切点方法执行就能触发相应通知）

XML配置文件：spring/aspect-aspectJnoArgs.xml（放在spring文件夹下）

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 
     <!--使用前置通知和后置通知唯一方式：在前置通知中记录开始时间，并在后置通知中报告表演耗费的时长，必须保存开始时间。因为Audience是单例，如果像这样保-->
     <!--存状态，会存在线程安全问题；-->
     <context:component-scan base-package="com.spring.example.aspectAspectJNoArgs"/>
     <aop:aspectj-autoproxy/>
 </beans>

前后置通知切面实现类

 package com.spring.example.aspectAspectJNoArgs;
 
 import org.aspectj.lang.annotation.*;
 import org.springframework.stereotype.Component;
 
 /**
  * Created by weixw on 2017/11/16.
  * 通过AspectJ注解实现切面编程
  * 切点方法 id 默认是所依赖方法（public void performance(){}）的小写方法名performance
  */
 
 @Component
 @Aspect
 public class Audience {
     @Pointcut("execution(* com.spring.example.aspectAspectJNoArgs.Performer.perform(..))") //定义切点
     public void performance(){}
     @Before("performance()")//表演之前
     public void takeSeats(){
         System.out.println("The audience is taking their seats.");
     }
     @Before("performance()")//表演之前
     public void turnOffCellPhones(){
         System.out.println("The audience is turning off their cellphones.");
     }
     @AfterReturning("performance()")//表演之后
     public void applaud(){
         System.out.println("CLAP CLAP CLAP CLAP CLAP ");
     }
     @AfterThrowing("performance()") //表演失败之后
     public void demandRefund(){
         System.out.println("Boo! We want our money back!");
     }
 }

环绕通知

XML配置文件：spring/aspect-around.xml（放在spring文件夹下）

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 
     <!--前置通知和后置通知是在一个方法中实现，所以不需要保存变量值，自然是线程安全的；-->
 
     <context:component-scan base-package="com.spring.example.aspectAround"/>
     <!--通过component-scan自动扫描，@Component注解将Magician注册到spring容器-->
     <aop:config>
             <!--audience :切面  watchPerformance：切面方法   performance：切点-->
             <aop:aspect ref="audience">
                 <aop:pointcut id="performance" expression="execution(* com.spring.example.aspectAround.Performer.perform(..))"/>
                 <aop:around pointcut-ref="performance" method="watchPerformance" />
             </aop:aspect>
     </aop:config>
 </beans>

环绕通知切面实现类

 package com.spring.example.aspectAround;
 
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.springframework.stereotype.Component;
 
 /**
  * Created by weixw on 2017/11/16.
  */
 @Component
 public class Audience {
     public void takeSeats(){
         System.out.println("The audience is taking their seats.");
     }
     public void turnOffCellPhones(){
         System.out.println("The audience is turning off their cellphones.");
     }
     public void applaud(){
         System.out.println("CLAP CLAP CLAP CLAP CLAP");
     }
     public void demandRefund(){
         System.out.println("Boo! We want our money back!");
     }
 
     public void watchPerformance(ProceedingJoinPoint joinPoint){
         try{
             takeSeats(); //表演之前
             turnOffCellPhones(); //表演之前
             long start = System.currentTimeMillis();
             System.out.println("The performance start ......");//节目开始
             joinPoint.proceed(); //执行被通知的方法
             System.out.println("The performance end ......");//节目结束
             long end = System.currentTimeMillis(); //表演之后
             applaud();//表演之后
             System.out.println("The performance took milliseconds："+ (end - start) );//表演时长
         }catch (Throwable t){
             demandRefund(); //表演失败之后
         }
     }
 }

测试代码

环绕通知测试代码如下，前后置通知测试代码只需将配置文件名称改成spring/aspect-aspectJnoArgs.xml即可

 package com.spring.example.aspectAround;/**
  * Created by weixw on 2017/11/16.
  */
 
 import javafx.application.Application;
 import javafx.stage.Stage;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 
 public class Driver extends Application {
 
     public static void main(String[] args) {
         launch(args);
     }
 
     @Override
     public void start(Stage primaryStage) {
         try {
 
             ApplicationContext ctx = new ClassPathXmlApplicationContext("spring/aspect-around.xml");
             Performer performer = (Performer) ctx.getBean("juggler");
             performer.perform();
 
         }catch (Exception e){
             e.printStackTrace();
         }
     }
 }

运行结果

环绕通知结果：

前后置通知结果：

总结

上述列出前后置通知和环绕通知样例。对于有变量缓存需求，线程安全的应用场景，前后置通知实现比较困难，而环绕通知实现就非常容易；

不要让懒惰占据你的大脑，不要让妥协拖垮你的人生。青春就是一张票，能不能赶上时代的快车，你的步伐掌握在你的脚下。