Spring全家桶之Spring AOP

综述：AOP，即面向切面编程，它与OOP（面向对象编程）相辅相成，AOP中的基本单元是切面(Aspect)，如同OOP中的基本单元类(class)，Spring AOP存在就是为了解耦。其实AOP就是在某一个类或方法执行前后打个标记，声明在执行到这里之前要先执行什么，执行完这里之后要接着执行什么。插入了新的执行方法。

推荐阅读：Spring AOP是什么意思，通俗讲解

下面是引用自上面的文章：

当我们需要在许多类中添加相同逻辑（或记录等其他）代码的时候，一般我们编程会在每一个类中都写上这些代码。当需要修改的时候，我们又必须找出这些类来删除这些逻辑代码。这里，你觉不觉得有什么问题。这好像关系到复用的问题，那么可以用聚合或继承来完成？那么再继续下去，我们需要这些逻辑代码指定到类中的某个方法前面执行，或者在方法后面执行，又或者我想指定在类的某一个位置去执行它，那么这就不是复用的问题了，而是要修改类了，变成动态的了。那么就出现了aop这个概念-面向切面编程。

如上图，黑线为一个流程代码，红线为切入的代码。即在5个流程中固定位置插入了3个逻辑代码，如果你不需要的时候，你完全可以撤出红线代码，而要修改的话，也只需修改这三个类（红线）即可，因为主代码（黑线）和添加代码(红线）是没有耦合的，相当于插拔式的。而且spring aop支持声明式的配置，使得aop更加方便。

通过上面的理解，我们可以简单地这样认为：Spring AOP其实相当于一个拦截器，在指定的地方完成相应的功能。

一、Spring AOP 相关术语

1、Aspect：切面

其实就是一个拦截器类，里面会定义切点以及通知。可以简单地理解使用了@Aspect注解的类就是切面。在Aspect里面包含着Pointcut和Advice。可以简单地认为, 使用 @Aspect 注解的类就是切面.

2、Advice：增强

切面中的方法，是切面在特定的连接点运行的动作。
几种常用的增强

前置通知（before advice）： 在某个连接点（join point）之前执行的通知，但不能阻止连接点前的执行（除非抛出一个异常）
返回后通知（after returning advice）在某个连接点（join point）正常执行完后执行通知
抛出异常通知（after throwing advice） 在方法异常退出时执行的通知
后置通知（after(finally) advice）在方法抛出异常退出时候的执行通知（不管正常返回还是异常退出）
环绕通知（around advice) 包围一个连接点（join point)的通知，在 join point 前和 joint point 退出后都执行的 advice，最常用

对Advice的小结：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。

3、Joint point（连接点）

程序运行过程中的一个点，比方说运行方法或者是处理异常。在Spring Aop中。一个连接点总是代表一个方法的运行。其实就是AOP拦截到的方法就是一个连接点。通过声明一个org.aspectj.lang.JoinPoint类型参数我们可以在通知(Advice)中获得连接点的信息。

4、Pointcut（切点）

Advice 是和特定的 point cut 关联的, 并且在 point cut 相匹配的 join point 中执行。
在 Spring 中, 所有的方法都可以认为是 joinpoint, 但是我们并不希望在所有的方法上都添加 Advice, 而 pointcut 的作用就是提供一组规则(使用 AspectJ pointcut expression language 来描述) 来匹配joinpoint, 给满足规则的 joinpoint 添加 Advice。

point cut 是一个描述信息, 它修饰的是 join point, 通过 point cut, 我们就可以确定哪些 join point 可以被织入 Advice。advice 是在 join point 上执行的, 而 point cut 规定了哪些 join point 可以执行哪些 advice。

5、Target：目标对象

通俗来说就是被一个或者多个切面通知的对象，所以也叫被通知对象(advised object)，因为Spring AOP是用执行时代理来实现的，所以这个对象总是个被代理的对象。

6、weaving：织入

把切面和其他对象连接起来并创建目标对象的过程，AOP织入有三种方式：

编译期：切面在目标类编译时织入。这种方式需要特殊的编译器。AspectJ的织入编译器就是以这种方式织入切面的。

类加载期：切面在目标类被加载到JVM时织入。这种方式需要特殊的类加载器，他可以在目标类被引入应用之前增加该目标类的字节码。AspectJ5的加载时织入，就支持以这种方式织入。

运行期：切面在应用运行的某个时刻被织入。一般情况下，在切面被织入时，AOP容器会为目标对象动态创建代理对象，Spring AOP就是以这种方式进行织入的。

二、切点表达式

1、execution

由于Spring切面粒度最小是达到方法级别，而execution表达式可以用于明确指定方法返回类型，类名，方法名和参数名等与方法相关的部件，并且在Spring中，大部分需要使用AOP的业务场景也只需要达到方法级别即可，因而execution表达式的使用是最为广泛的。如下是execution表达式的语法：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)

这里问号表示当前项可以有也可以没有，其中各项的语义如下：

modifiers-pattern：方法的可见性，如public，protected；
ret-type-pattern：方法的返回值类型，如int，void等；
declaring-type-pattern：方法所在类的全路径名，如com.spring.Aspect；
name-pattern：方法名类型，如buisinessService()；
param-pattern：方法的参数类型，如java.lang.String；
throws-pattern：方法抛出的异常类型，如java.lang.Exception；

实例：

execution (* com.qctsw.*.service..*.*(..))

另一个实例：

execution(public * com.spring.service.BusinessObject.businessService(java.lang.String,..))

上述切点表达式将会匹配使用public修饰，返回值为任意类型，并且是com.spring.BusinessObject类中名称为businessService的方法，方法可以有多个参数，但是第一个参数必须是java.lang.String类型的方法。

对于上述使用的通配符作出如下说明：
*通配符，该通配符主要用于匹配单个单词，或者是以某个词为前缀或后缀的单词。
如下示例表示返回值为任意类型，在com.spring.service.BusinessObject类中，并且参数个数为零的方法：
execution(* com.spring.service.BusinessObject.*())
下述示例表示返回值为任意类型，在com.spring.service包中，以Business为前缀的类，并且是类中参数个数为零方法：
execution(* com.spring.service.Business*.*())
. . 通配符，该通配符表示0个或多个项，主要用于declaring-type-pattern和param-pattern中，如果用于declaring-type-pattern中，则表示匹配当前包及其子包，如果用于param-pattern中，则表示匹配0个或多个参数。
如下示例表示匹配返回值为任意类型，并且是com.spring.service包及其子包下的任意类的名称为businessService的方法，而且该方法不能有任何参数：
execution(* com.spring.service..*.businessService())

2、within

within表达式的粒度为类，其参数为全路径的类名（可使用通配符），表示匹配当前表达式的所有类都将被当前方法环绕。如下是within表达式的语法：
within(declaring-type-pattern)

3、args

args表达式的作用是匹配指定参数类型和指定参数数量的方法，无论其类路径或者是方法名是什么。这里需要注意的是，args指定的参数必须是全路径的。如下是args表达式的语法：
args(param-pattern)
args属于动态切入点，开销相对来说较大，一般不使用

小结：关于更多的AOP切点表达式用法可参考这篇文章：Spring AOP切点表达式用法总结

三、Spring AOP简单的测试例子

目标类

@Component(value = "tests")
public class Test1 {
    public void test(){
        System.out.println("目标方法");
    }
}

AOP类

@Component(value = "annotationTest")
@Aspect //将类声明为切面
public class AnnotationTest {
    @Pointcut("execution(* *.test(..))") 定义切点
    public void test(){}

//    @Before("test()")
//    public void before(){
//        System.out.println("注解类型环绕通知..环绕前");
//    }
//
//    @After("test()")
//    public void after(){
//        System.out.println("注解类型环绕通知..环绕后");
//    }

    @Around("test()")
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("注解类型环绕通知..环绕前");
        pjp.proceed();//执行方法
        System.out.println("注解类型环绕通知..环绕后");
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        Test1 aopTargetMethod = (Test1) ac.getBean("tests");
        aopTargetMethod.test();
    }
}

配置文件

<!-- 配置文件只需要扫描包的配置 -->
    <context:component-scan base-package="com" />
    <!--开启AOP注解方式一定要写-->
    <aop:aspectj-autoproxy/>

参考文章：彻底征服 Spring AOP 之 理论篇