第四章 面向切面的Spring

4.1 什么是面向切面编程

　　横切关注点可以被模块化为特殊的类，这些类被称为切面。

　　好处：1关注点集中在一处，不是分散在多处代码中；2服务（主要的业务）模块更简洁，他们只包含主要关注点（或核心功能）的代码，次要关注点的代码被转移到切面中了；

4.1.1 定义AOP术语

　　术语：通知（advice），切点（pointcut）和连接点（join point）；

　　

　　通知（advice）定义了切面是什么以及何时使用（定义切面是“什么”及“何时”）。

• Before——在方法被调用之前调用通知
• After——在方法完成之后
• after-returning——在方法成功执行之调用通知
• after-throwing——在方法抛出异常后调用通知
• Around——通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。

　连接点（Joinpoint）：是在应用执行过程中能够插入切面的一个点。这个点可以是调用的方法时，抛出异常时，修改一个字段时（是一个时机），切面代码可以利用这些点插入到应用的正常流程之中，添加新的行为。

　　切点（Pointcut）：匹配通知所要织入的一个或多个连接点（定义切面在“何处”）

　   切面（Aspect）：是通知和切点的结合，通知和切点共同定义了关于切面的全部内容——是什么，何时、何处完成其功能；

　　织入（Weaving）：是将切面引用到目标对象来创建新的dialing对象的过程，切面在指定的连接点被织入到目标对象中。在目标对象的生命周期中有多个点可以进行织入。

• 编译期——切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ的织入编译期就是以这种方式织入切面的。
• 类加载期——切面子啊目标被加载到JVM时被织入。这种方式需要特殊的类加载器（ClassLoader），它可以在目标类被引入引用之前增强该目标类的字节码。AspectJ5的LTW（load-time weaving）就支持以这种方式织入。
• 运行期——切面在应用运行的某个时刻被织入。一般情况下，在织入切面时，AOP容器会为目标对象动态地创建一个代理对象。SpringAOP就是以这种方式织入切面的

4.1.2 Spring对AOP的支持

　　spring提供了4中AOP支持：

• 基于代理的经典AOP（这本书中不介绍）；
• @AspectJ注解驱动的切面
• 纯POJO切面
• 注入式AspectJ切面（适合spring个版本）

　　前三种都是Spring基于代理的AOP变体，因此Spring对AOP的支持局限于方法拦截。若是AOP需求超过了简单方法的拦截的范凑，那么考虑在AspectJ里实现切面，利用Spring的DI把Spring Bean注入到AspectJ切面中。

4.2 使用切点选择连接点

　　略过。。。

4.3 在xml中声明切面

4.3.1 声明前置通知和后置通知

　　声明切面，我们先创建一个观众的Audience切面类：

package com.springinaction.springidol;

/**
 * 
 * @ClassName: Audience 
 * @Description: 观众的切面类
 * @author mao
 * @date 2017年3月23日 下午4:07:01 
 *
 */
public class Audience {
    
    public void takeSeats(){
        //表演之前
        System.out.println("观众开始入座！");
    }
    
    public void turnOffCellPhones(){
        //表演之前
        System.out.println("观众正在坐着");
    }
    
    public void applaud(){
        //表演之后
        System.out.println("表演完后，鼓掌！鼓掌！鼓掌！");
    }
    
    public void demandRefund(){
        //表演失败之后
        System.out.println("表演失败，我们要退钱！");
    }
    
    
    
}

　　首先，pom.xml文件中引入spring.aspects.jar文件

<!-- spring aspects依赖，AOP用到 -->
 <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>4.2.9.RELEASE</version>
</dependency>

　　其次，springbean.xml文件中<beans>标签中需要引入aop的命名空间 ：xmlns:aop="http://www.springframework.org/schema/aop" 和xsi:schemaLocation="
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd"

<?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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
    
     
     <!--观众的bean  -->
     <bean id="audience"
             class="com.springinaction.springidol.Audience"></bean>
     <context:component-scan 
        base-package="com.springinaction.springidol"></context:component-scan>
     
     <!-- 声明aop -->
     <!-- 
          <aop:config>顶层的AOP配置元素，大多数<aop:*>都包在这个元素内
      -->
     <aop:config>
         <!-- 引用audience Bean
             <aop:aspect>定义切面的元素
          -->
         <aop:aspect ref="audience">
             
             <!-- 表演之前 -->
             <!-- <aop:before>定义aop前置通知 
                 pointcut=""是切点表达式，和method=""一起用，告诉通知切点在哪
                 整个标签表达出 在哪个类的那个方法执行什么通知
             -->
             <aop:before 
                 pointcut="execution(* com.springinaction.springidol.Performer.perform(..))" method="takeSeats"/>
             
             <!-- 表演之后  --> 
            <aop:before 
                pointcut="execution(* com.springinaction.springidol.Performer.perform(..))"
                 method="turnOffCellPhones"/>             
             
             <!-- 表演之后 -->
             <!-- <aop:after-returning>定义aop返回通知 -->
             <aop:after-returning
                pointcut="execution(* com.springinaction.springidol.Performer.perform(..))"
                 method="applaud"/>             
             
             <!-- 表演失败之后 -->
             <!-- <aop:after-throwing>定义aop异常通知 -->
             <aop:after-throwing 
                pointcut="execution(* com.springinaction.springidol.Performer.perform(..))"
                 method="demandRefund"/>            
         
         </aop:aspect>
     </aop:config>
    
     
     
     
    
</beans>

package com.springinaction.springidol;

import javax.inject.Inject;

import javax.inject.Named;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;



/**
 * 
* @ClassName: Instrumentalist 
* @Description: 一个有天赋的音乐家
* @author mao
* @date 2017年3月19日 下午7:15:17 
*
 */
//将该类注册到Spring容器中，显示的为其命名为kenny。即ID为kenny
@Component("kenny")
public class Instrumentalist implements Performer {
    
    @Value("演员---薛之谦")
    private String song;
    
    @Autowired
    @Qualifier("saxophone")
    private Instrument instrument;
    
    //注入乐器
    public void setInstrument(Instrument instrument) {
        this.instrument = instrument;
    }
    public Instrument getInstrument() {
        return instrument;
    }
    //注入歌曲
    public void setSong(String song) {
        this.song = song;
    }
    public String getSong() {
        return song;
    }
    
    public Instrumentalist(){
        
    }

    public void perform() throws Exception {
//        int i = 3/0;
        System.out.println("Playing "+song+": ");
    }

}

测试：

package com.springinaction.test;

import org.junit.Test;


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.springinaction.springidol.Auditorium;
import com.springinaction.springidol.Instrumentalist;
import com.springinaction.springidol.OneManBand;
import com.springinaction.springidol.Performer;
import com.springinaction.springidol.PoeticJuggler;
import com.springinaction.springidol.Stage;
import com.springinaction.springidol.Ticket;


public class TestCase {
    
    //这个ClassPathXmlApplicationContext是springframe-context中
    //org.springframework.context.support包下的类
    ApplicationContext ac = new ClassPathXmlApplicationContext("spring/springbean.xml");//注意路径
    
    //测试声明式的切面、通知
    @Test
    public void testAspect() throws Exception {
        
        Performer kenny = (Performer) ac.getBean("kenny");
//        System.out.println(kenny);
         
        kenny.perform();//输出 Playing 演员——薛之谦: 

        
        
    }

    
}

结果：

测试异常通知在Instrumentalist 的perform（）方法中的int i=3/0注释解封，结果：

这里要注意的是，这里的aop使用的是JDK的动态代理，因为Instrumentalist是实现了Perfromer的类，这个是JDK动态代理的条件吧，spring AOP还有个cglib代理，这个是通过创建一个类的子类来获得一个代理（这个子类是底层完成的），两者有区别，这里不详细说了（默认是使用JDK动态代理，若是满足不了JDK动态代理的条件，那就启用cglib代理）。

 　　上述的springbean.xml的aop配置还可以如下配置，简化一下代码：

<?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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
    
     
     <!--观众的bean  -->
     <bean id="audience"
             class="com.springinaction.springidol.Audience"></bean>
     <!--注解形式的 组件扫描 -->
     <context:component-scan 
        base-package="com.springinaction.springidol"></context:component-scan>
     
     <!-- 声明aop -->
     <!-- 
          <aop:config>顶层的AOP配置元素，大多数<aop:*>都包在这个元素内
      -->
    <!--  <aop:config>
         引用audience Bean
             <aop:aspect>定义切面的元素
         
         <aop:aspect ref="audience">
             
             表演之前
             <aop:before>定义aop前置通知 
                 pointcut=""是切点表达式，和method=""一起用，告诉通知切点在哪
                 整个标签表达出 在哪个类的那个方法执行什么通知
             
             <aop:before 
                 pointcut="execution(* com.springinaction.springidol.Performer.perform(..))" method="takeSeats"/>
             
             表演之后  
            <aop:before 
                pointcut="execution(* com.springinaction.springidol.Performer.perform(..))"
                 method="turnOffCellPhones"/>             
             
             表演之后
             <aop:after-returning>定义aop返回通知
             <aop:after-returning
                pointcut="execution(* com.springinaction.springidol.Performer.perform(..))"
                 method="applaud"/>             
             
             表演失败之后
             <aop:after-throwing>定义aop异常通知
             <aop:after-throwing 
                pointcut="execution(* com.springinaction.springidol.Performer.perform(..))"
                 method="demandRefund"/>            
         
         </aop:aspect>
     </aop:config> -->
    
     <!-- 上面配置aop的切点表达式是一样的，所以可以写成如下配置 -->
     <aop:config>
         <!-- 引用audience Bean -->
         <aop:aspect ref="audience">
             <!-- 定义切点表达式 -->
             <aop:pointcut id="performance" expression="execution(* com.springinaction.springidol.Performer.perform(..))" />
             <!-- 表演之前-->
            <aop:before 
                pointcut-ref="performance"
                 method="takeSeats"/>
             <!-- 表演之前-->
            <aop:before 
                pointcut-ref="performance"
                 method="turnOffCellPhones"/>             
             <!-- 
             表演之后
             <aop:after-returning>定义aop返回通知 -->
             <aop:after-returning
                pointcut-ref="performance"
                 method="applaud"/>             
             
             <!-- 表演失败之后
             <aop:after-throwing>定义aop异常通知 -->
             <aop:after-throwing 
                pointcut-ref="performance"
                 method="demandRefund"/>            
         
         </aop:aspect>
     </aop:config>
     
    
</beans>

4.3.2 声明环绕通知

在Audience类中增加如下的方法：

//环绕通知
    public void watchPerformance(ProceedingJoinPoint joinpoint){
        try {
            System.out.println("观众正在坐在自己的位置上---表演之前");
            System.out.println("观众关闭他们的手机---表演之前");
            long start = System.currentTimeMillis();
            
            joinpoint.proceed();
            
            long end=System.currentTimeMillis();
            
            System.out.println("表演很精彩，大家鼓掌....");
            System.out.println("表演耗时:"+(end-start)+"毫秒");
            
        } catch (Throwable e) {
            //表演失败，
            System.out.println("太糟糕了，我们要退钱！");
        }
        
        
    }

<!-- 上面配置aop的切点表达式是一样的，所以可以写成如下配置 -->
     <aop:config>
         <!-- 引用audience Bean -->
         <aop:aspect ref="audience">
             <!-- 定义切点表达式 -->
             <aop:pointcut id="performance" expression="execution(* com.springinaction.springidol.Performer.perform(..))" />
             <!-- 表演之前-->
            <!-- <aop:before 
                pointcut-ref="performance"
                 method="takeSeats"/> -->
             <!-- 表演之前-->
            <!-- <aop:before 
                pointcut-ref="performance"
                 method="turnOffCellPhones"/>     -->         
             <!-- 
             表演之后
             <aop:after-returning>定义aop返回通知 -->
             <!-- <aop:after-returning
                pointcut-ref="performance"
                 method="applaud"/>      -->        
             
             <!-- 表演失败之后
             <aop:after-throwing>定义aop异常通知 -->
             <!-- <aop:after-throwing 
                pointcut-ref="performance"
                 method="demandRefund"/>     -->        
             
             <!-- 环绕通知 
                 将其他通知都注释
             -->
             <aop:around 
                 pointcut-ref="performance"
                 method="watchPerformance"/>
         </aop:aspect>
     </aop:config>

 为了看出表演耗时的时间，在perform（）方法中加Thread.sleep(1000)（加不加无所谓的）睡1秒;

结果：

4.3.3 为通知传递参数

　　直接上一个读心者的例子，先创建几个类：

package com.springinaction.springidol;

/**
 * 读心者类
 * @ClassName: MindReader 
 * @Description: 可以读取别人的思想
 * @author mao
 * @date 2017年3月23日 下午5:23:49 
 *
 */
public interface MindReader {
    
    //拦截别人的想法(感应别人的内心想法)
    void interceptThoughts(String thoughts);
    
    //获得想法
    String getThoughts();
}

package com.springinaction.springidol;

/**
 * 读心者的实现类
 * @ClassName: Magician 
 * @Description: 可以读取别人想法的具体实例
 * @author mao
 * @date 2017年3月23日 下午5:29:12 
 *
 */
public class Magician implements MindReader {
    
    
    private String thoughts;
    
    public void interceptThoughts(String thoughts) {
        
        System.out.println("感应志愿者的想法！");
        this.thoughts = thoughts;

    }

    public String getThoughts() {
        
        return thoughts;
    }

}

package com.springinaction.springidol;

/**
 * 思考者的接口
 * @ClassName: Thinker 
 * @Description: 沉思者 
 * @author mao
 * @date 2017年3月23日 下午5:30:07 
 *
 */
public interface Thinker {
    //瞎想
    void thinkOfSomething(String thoughts);
}

package com.springinaction.springidol;

/**
 * 沉思者
 * @ClassName: Volunteer 
 * @Description: 一个时代的思想家
 * @author mao
 * @date 2017年3月23日 下午5:31:58 
 *
 */
public class Volunteer implements Thinker {
    
    private String thoughts;
    
    public void thinkOfSomething(String thoughts) {
        
        this.thoughts = thoughts;

    }

    public String getThoughts() {
        return thoughts;
    }
    
}

xml的配置（晕倒，在切点表达式中把thoughts写错了，找了老半天的错误） arg()限制连接点匹配参数为指定类型的执行方法：

<?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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
    
     
     <!--观众的bean  -->
    <bean id="audience"
             class="com.springinaction.springidol.Audience"></bean>
     <!--注解形式的 组件扫描 -->
     <context:component-scan 
        base-package="com.springinaction.springidol"></context:component-scan>
     
     <!-- 声明aop -->
     <!-- 
          <aop:config>顶层的AOP配置元素，大多数<aop:*>都包在这个元素内
      -->
    <!--  <aop:config>
         引用audience Bean
             <aop:aspect>定义切面的元素
         
         <aop:aspect ref="audience">
             
             表演之前
             <aop:before>定义aop前置通知 
                 pointcut=""是切点表达式，和method=""一起用，告诉通知切点在哪
                 整个标签表达出 在哪个类的那个方法执行什么通知
             
             <aop:before 
                 pointcut="execution(* com.springinaction.springidol.Performer.perform(..))" method="takeSeats"/>
             
             表演之后  
            <aop:before 
                pointcut="execution(* com.springinaction.springidol.Performer.perform(..))"
                 method="turnOffCellPhones"/>             
             
             表演之后
             <aop:after-returning>定义aop返回通知
             <aop:after-returning
                pointcut="execution(* com.springinaction.springidol.Performer.perform(..))"
                 method="applaud"/>             
             
             表演失败之后
             <aop:after-throwing>定义aop异常通知
             <aop:after-throwing 
                pointcut="execution(* com.springinaction.springidol.Performer.perform(..))"
                 method="demandRefund"/>            
         
         </aop:aspect>
     </aop:config> -->
     
     
     <!-- 上面配置aop的切点表达式是一样的，所以可以写成如下配置 -->
     <aop:config>
         <!-- 引用audience Bean -->
         <aop:aspect ref="audience">
             <!-- 定义切点表达式 -->
             <aop:pointcut id="performance" expression="execution(* com.springinaction.springidol.Performer.perform(..))" />
             <!-- 表演之前-->
            <!-- <aop:before 
                pointcut-ref="performance"
                 method="takeSeats"/> -->
             <!-- 表演之前-->
            <!-- <aop:before 
                pointcut-ref="performance"
                 method="turnOffCellPhones"/>     -->         
             <!-- 
             表演之后
             <aop:after-returning>定义aop返回通知 -->
             <!-- <aop:after-returning
                pointcut-ref="performance"
                 method="applaud"/>      -->        
             
             <!-- 表演失败之后
             <aop:after-throwing>定义aop异常通知 -->
             <!-- <aop:after-throwing 
                pointcut-ref="performance"
                 method="demandRefund"/>     -->        
             
             <!-- 环绕通知 
                 将其他通知都注释
             -->
             <aop:around 
                 pointcut-ref="performance"
                 method="watchPerformance"/>
         </aop:aspect> 
         
         <aop:aspect ref="magician">
             <aop:pointcut 
                 id="thinking"
                 expression="execution(* com.springinaction.springidol.Thinker.thinkOfSomething(String)) and args(thoughts)" />
             
             <aop:before 
                 pointcut-ref="thinking" 
                 method="interceptThoughts" 
                 arg-names="thoughts"/>
         
         </aop:aspect>
     </aop:config>
     
     <bean id="volunteer" class="com.springinaction.springidol.Volunteer"></bean>
     <bean id="magician" class="com.springinaction.springidol.Magician"></bean>
    
</beans>

测试代码：

//测试传入参数的通知
    @Test
    public void testArgsAdvisor() throws Exception {
        
        //思考者，先思考
        Thinker volunteer = (Thinker) ac.getBean("volunteer");
        volunteer.thinkOfSomething("你猜我想啥？");
        
        //读心者 对他想的啥
        MindReader magician = (MindReader) ac.getBean("magician");
        System.out.println(magician.getThoughts());

    }

结果：

4.4 注解切面

 注解使用：

package com.springinaction.springidol;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * 
 * @ClassName: Audience 
 * @Description: 观众的切面类
 * @author mao
 * @date 2017年3月23日 下午4:07:01 
 *
 */
@Component//这个不要忘了，注解的自动扫描 会将其加入到IOC容器中
@Aspect
public class Audience {
    
    //定义一个可以在@AspectJ切面内可重用的切点
    @Pointcut("execution(* com.springinaction.springidol.Performer.perform(..))")
    public void performance(){
        
    }
    
    
    @Before("performance()")
    public void takeSeats(){
        //表演之前
        System.out.println("观众开始入座！");
    }
    
    @Before("performance()")
    public void turnOffCellPhones(){
        //表演之前
        System.out.println("观众正在坐着");
    }
    
    @AfterReturning("performance()")
    public void applaud(){
        //表演之后
        System.out.println("表演完后，鼓掌！鼓掌！鼓掌！");
    }
    
    @AfterThrowing("performance()")
    public void demandRefund(){
        //表演失败之后
        System.out.println("表演失败，我们要退钱！");
    }
    
    //环绕通知
    @Around("performance()")
    public void watchPerformance(ProceedingJoinPoint joinpoint){
        try {
            System.out.println("观众正在坐在自己的位置上---表演之前");
            System.out.println("观众关闭他们的手机---表演之前");
            long start = System.currentTimeMillis();
            
            joinpoint.proceed();
            
            long end=System.currentTimeMillis();
            
            System.out.println("表演很精彩，大家鼓掌....");
            System.out.println("表演耗时:"+(end-start)+"毫秒");
            
        } catch (Throwable e) {
            //表演失败，
            System.out.println("太糟糕了，我们要退钱！");
        }
        
        
    }
    
    
}

<?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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
    
 
     <!--注解形式的 组件扫描 -->
     <context:component-scan 
        base-package="com.springinaction.springidol"></context:component-scan>
     <!--使用@AspectJ注解作为指引来创建给予代理的切面，就是把他编程切面，这个@AspectJ类中的有且点表达式和通知  -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
    
    
</beans>

测试结果（测试用例之前写过）：

这本书中错误还不少，不过不妨碍阅读：<aop:aspectj-autoproxy> 红色写成了aespectj，还有前面有一个写环绕通知的时候，method="watchPerformance()";括弧是不需要的。

4.5 注入AspectJ切面

 　　表示看不懂。。。

 

源码下载地址