Spring 的 AOP 的支持

面向切面编程(Aspect-oriented Programming,AOP)通过提供另一种思考程序结构的方法来补充面向对象编程(Object-oriented Programming,OOP)。OOP中模块化的关键单元是类，而AOP中模块化的单元是切面。切面支持跨多个类型和对象的关注点(例如事务管理)的模块化

一、AOP 的概念

AOP 术语

在使用 AOP 之前，先熟悉一下 AOP 概念和术语。这些术语并不特定于 Spring，而是与 AOP 有关的

项	描述
Aspect（切面）	跨越多个类的关注点的模块化，切面是通知和切点的结合。通知和切点共同定义了切面的全部内容——它是什么，在何时和何处完成其功能。事务处理和日志处理可以理解为切面
Join point（连接点）	程序执行过程中的一个点，如方法的执行或异常的处理
Advice（通知）	切面在特定连接点上采取的动作
Pointcut（切点）	匹配连接点的断言。通知与切入点表达式相关联，并在切入点匹配的任何连接点上运行(例如，具有特定名称的方法的执行)。切入点表达式匹配的连接点概念是AOP的核心，Spring默认使用AspectJ切入点表达式语言
Introduction（引用）	为类型声明其他方法或字段。Spring AOP允许您向任何建议的对象引入新的接口(和相应的实现)。例如，您可以使用介绍使bean实现IsModified接口，以简化缓存
Target object（目标）	由一个或多个切面通知的对象。也称为“通知对象”。由于Spring AOP是通过使用运行时代理实现的，所以这个对象始终是代理对象
AOP proxy（代理）	AOP框架为实现切面契约(通知方法执行等)而创建的对象。在Spring框架中，AOP代理是JDK动态代理或CGLIB代理
Weaving（织入）	织入是将通知添加对目标类具体连接点上的过程，可以在编译时(例如使用AspectJ编译器)、加载时或运行时完成

Spring切面可以应用5种类型的通知：

• 前置通知（Before）：在目标方法被调用之前调用通知
• 后置通知（After）：在目标方法完成之后调用通知（无论是正常还是异常退出）
• 返回通知（After-returning）：在目标方法成功执行之后调用通知
• 异常通知（After-throwing）：在目标方法抛出异常后调用通知
• 环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为

其中环绕通知包括前置、后置、返回、异常通知，这个在后面的例子体现

二、使用 XML 配置的AOP支持

xml配置中需要aop命名空间标记，需要先导入 spring-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:aop="http://www.springframework.org/schema/aop" 
    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">

    <!-- bean definitions here -->
</beans>

也是需要AspectJ的 aspectjweaver.jar 包，spring-aspects 模块是依赖该jar包的

spring-aspects 模块集成自 AspectJ 框架， 主要是为 Spring AOP 提供多种 AOP 实现方法

1、声明一个切面

使用 <aop:aspect> 标签声明切面，使用 ref 属性去引用支持的 bean

<aop:config>
   <aop:aspect id="myAspect" ref="aspectBean">
   ...
   </aop:aspect>
</aop:config>
<bean id="aspectBean" class="com.demo.aspect.AspectBean">
...
</bean>

切面可以具有与任何其他类相同的方法和字段。它们还可以包含切入点、通知和引入(内部类型)声明。

2、声明切入点

声明切入点是确定通知感兴趣的或是将要织入的连接点（即目标方法）

<aop:config>
  <aop:aspect id="myAspect" ref="aspectBean">
    <aop:pointcut id="businessService"
         expression="execution(* com.demo.service.*.*(..))"/>
    ...
  </aop:aspect>
</aop:config>

<bean id="aspectBean" class="com.demo.aspect.AspectBean">
</bean>

表达式 expression 是对连接点的筛选，上面的例子是 com.demo.service 包下所有类的所有方法

详细的表达式语法见后面详说
也还可以通过名称匹配切入点参数与建议方法参数

3、声明通知

使用 <aop:{ADVICE-NAME}> 标签声明五个建议中的任意一个，如下

<aop:config>
  <aop:aspect id="myAspect" ref="aspectBean">
    <aop:pointcut id="businessService"
        expression="execution(* com.demo.service.*.*(..))" />
    
    <!-- 前置通知定义 -->
    <aop:before pointcut-ref="businessService" 
        method="doBeforeTask" />
    <!-- 后置通知定义 -->
    <aop:after pointcut-ref="businessService" 
        method="doAfterTask" />
    <!-- 返回通知定义 -->
    <!-- doReturnTask方法必须要有一个名字与“returning”值一致（如retVal）的参数，这个是目标方法的返回值 -->
    <aop:after-returning
        pointcut-ref="businessService" returning="retVal"
        method="doReturnTask" />
    <!-- 异常通知定义 -->
    <!-- doRequiredTask方法必须要有一个名字与“throwing”值一致（如ex）的参数，这个是目标方法的抛出的异常-->
    <aop:after-throwing pointcut-ref="businessService"
        throwing="ex" method="doThrowTask" />

    <!-- 环绕通知定义（环绕通知包含了其他的通知） -->
    <!-- <aop:around pointcut-ref="businessService"
        method="doAroundTask" /> -->

  </aop:aspect>
</aop:config>

<bean id="aspectBean" class="com.demo.aspect.AspectBean">
</bean>

其中环绕通知包括前置、后置、返回、异常通知，在待会的例子中可以看出

这里 pointcut-ref=“businessService” 是在 <aop:config> 里定义的切入点。也可以改为内联切入点，使用 pointcut 属性替换 pointcut-ref 属性

<aop:aspect id="beforeExample" ref="aBean">
    <aop:before
        pointcut="execution(* com.demo.service.*.*(..))"
        method="doAccessCheck"/>
    ...
</aop:aspect>

---

例子

我们使用上面的例子，定义的切入点为 com.demo.service 下的所有的类的所有方法，该切面支持的bean为 com.demo.aspect 下的 AspectBean。我们的切入点也是需要在IoC容器中被管理的 bean，可以用注解也可以xml配置

<bean id="targetService" class="com.demo.service.TargetService"/>

TargetService，目标对象，这个operation方法便是我们的切入点

public class TargetService {
    public String operation(String msg) {
        System.out.println("执行目标方法，方法参数[msg:" + msg + "]");
        // 测试异常通知
        // throw new RuntimeException("我是个异常");
        return msg;
    }
}

同时我也写一下 AspectBean 里面的方法

public class AspectBean {
    private static int step = 0;

    public void doBeforeTask(String msg) {
        System.out.println(++step + " 前置通知,参数为[msg:" + msg + "]");
    }

    public void doAfterTask() {
        System.out.println(++step + " 后置通知");
    }

    public void doReturnTask(Object retVal) {
        System.out.println(++step + " 返回通知，返回值为：" + retVal.toString());
    }

    public void doThrowTask(Exception ex) {
        System.out.println(++step + " 异常通知，异常信息为：" + ex.getMessage());
    }

    /**
     * 环绕通知需要携带ProceedingJoinPoint类型的参数 
     * 环绕通知类似于动态代理的全过程ProceedingJoinPoint类型的参数可以决定是否执行目标方法 
     * 且环绕通知必须有返回值，返回值即目标方法的返回值
     */
    public Object doAroundTask(ProceedingJoinPoint pjp) {
        String methodname = pjp.getSignature().getName();
        Object result = null;
        try {
            // 前置通知
            System.out.println("目标方法" + methodname + "开始，参数为" + Arrays.asList(pjp.getArgs()));
            // 执行目标方法
            result = pjp.proceed();
            // 返回通知
            System.out.println("目标方法" + methodname + "执行成功，返回" + result);
        } catch (Throwable e) {
            // 异常通知
            System.out.println("目标方法" + methodname + "抛出异常: " + e.getMessage());
        }
        // 后置通知
        System.out.println("目标方法" + methodname + "结束");
        return result;
    }
}

我们先注释掉xml中环绕通知的配置，运行一下看下结果如何

public class MainApp {
    public static void main( String[] args ){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        TargetService targetService  = (TargetService) applicationContext.getBean("targetService");
        targetService.operation("zou");
    }
}

结果为

1 前置通知
执行目标方法，方法参数[msg:zou]
2 后置通知
3 返回通知，返回值为：zou

然后我们注释掉其他其他通知，测试一下环绕通知，并且我们在目标方法中抛出一个异常，再运行一下，结果为

目标方法operation开始，参数为[zou]
执行目标方法，方法参数[msg:zou]
目标方法operation抛出异常: 我是个异常
目标方法operation结束

三、使用 @AspectJ 的AOP支持

1、启用@AspectJ支持

要在Spring配置中使用@AspectJ切面，需要启用Spring支持

使用XML配置启用@AspectJ支持

<aop:aspectj-autoproxy/>

这里也需要AspectJ的 aspectjweaver.jar 包，spring-aspects 模块是依赖该jar包的

2、声明一个切面

Aspects 类和其他任何正常的 bean 一样，除了它们将会用 @AspectJ 注释之外，它和其他类一样可能有方法和字段

import org.aspectj.lang.annotation.Aspect;
@Aspect
public class AnnotationAspect {

}

也可以在 xml 中配置，和其他 bean 一样

<bean id="myAspect" class="org.xyz.AnnotationAspect">
    <!-- configure properties of the aspect here -->
</bean>

切面(用@Aspect标注的类)可以具有与任何其他类相同的方法和字段。它们还可以包含切入点、通知和引入(内部类型)声明。

3、声明切入点

切入点声明有两部分:包含名称和任何参数的签名，以及准确确定我们感兴趣的方法执行的切入点表达式
在AOP的@AspectJ注释样式中，切入点签名是由一个常规方法定义提供的，切入点表达式是通过使用@Pointcut注释表示的(作为切入点签名的方法必须为void返回类型)

如下代码，定义了一个名为anyOldTransfer的切入点，该切入点与任何名为transfer的方法的执行匹配

@Pointcut("execution(* transfer(..))")// the pointcut expression
private void anyOldTransfer() {}// the pointcut signature

表达式见

4、声明通知

你可以使用 @{ADVICE-NAME} 注释声明五个建议中的任意一个，如下所示。这假设你已经定义了一个切入点标签方法 operation()

@Aspect
public class AnnotationAspect {
    private static int step = 0;

    @Pointcut("execution(* transfer(..))") // the pointcut expression
    private void operation() {}

    @Before("operation()")
    public void doBeforeTask() {
        System.out.println(++step + " 前置通知");
    }

    @After("operation()")
    public void doAfterTask() {
        System.out.println(++step + " 后置通知");
    }

    @AfterReturning(pointcut = "operation()", returning = "retVal")
    public void doAfterReturnningTask(Object retVal) {
        System.out.println(++step + " 返回通知，返回值为：" + retVal.toString());
    }

    @AfterThrowing(pointcut = "operation()", throwing = "ex")
    public void doAfterThrowingTask(Exception ex) {
        System.out.println(++step + " 异常通知，异常信息为：" + ex.getMessage());
    }

    /**
     * 环绕通知需要携带ProceedingJoinPoint类型的参数 
     * 环绕通知类似于动态代理的全过程ProceedingJoinPoint类型的参数可以决定是否执行目标方法 
     * 且环绕通知必须有返回值，返回值即目标方法的返回值
     */
    //@Around("operation()")
    public Object doAroundTask(ProceedingJoinPoint pjp) {
        String methodname = pjp.getSignature().getName();
        Object result = null;
        try {
            // 前置通知
            System.out.println("目标方法" + methodname + "开始，参数为" + Arrays.asList(pjp.getArgs()));
            // 执行目标方法
            result = pjp.proceed();
            // 返回通知
            System.out.println("目标方法" + methodname + "执行成功，返回" + result);
        } catch (Throwable e) {
            // 异常通知
            System.out.println("目标方法" + methodname + "抛出异常: " + e.getMessage());
        }
        // 后置通知
        System.out.println("目标方法" + methodname + "结束");
        return result;
    }
}

也可以为任意一个通知直接写入内联切入点

@Before("execution(* com.xyz.myapp.dao.*.*(..))")
public void doAccessCheck() {
    // ...
}

其中环绕通知包括前置、后置、返回、异常通知
运行的结果这里不给了，可以参考上面xml配置的例子