Spring的面向切面编程AOP使用讲解

Spring IOC 是软件组件松耦合度，而AOP让你能够捕捉系统中经常使用的功能，把它转化为组件。AOP(Aspect Oriented Programming)：面向切面编程 ，面向方面编程 。（AOP是一种编程技术）

AOP 是对OOP的补充延申。AOP底层使用的就是动态代理，Spring 的AOP使用的是动态代理是: JDK动态代理 + CGLIB 动态代理技术 。Spring 在这两种动态代理中灵活切换，如果是代理接口，会默认使用JDK动态代理，如果要代理某个类，这个类没有实现接口，就会切换使用CGLIB。当然，你也可以强制通过一些配置让Spring 只使用 CGLIB。(让文章内容有所说明)

2. AOP介绍说明

一般一个系统当中都会有一些系统服务，例如：日志，事务处理，安全等，这些系统服务被称为：交叉业务 。这些交叉业务 几乎是通用的，不管你是做银行账户转账，还是删除用户数据。日志，事务处理，安全，这些都是需要做的。

如果在每一个业务处理过程当中，都参杂这些交叉业务 代码进去的话，存在两方面的问题：

1. 第一：交叉业务代码在多个业务流程中反复出现，显然这个交叉业务 代码并没有得到充分的复用，并且修改这些交叉业务 代码的话，需要修改多处。
2. 第二：程序员无法专注核心业务代码的编写，在编写核心业务代码的同时还需要处理这些交叉业务。

使用 AOP 可以很轻松的解决以上问题。

如下图：可以更好的理解 AOP思想。

简单的说AOP：就是将与核心业务 无关的代码抽离开来，形成一个独立的组件，然后，以横向 交叉的方式应用到业务流程当中的过程被称为 AOP 。

AOP的优点：

1. 代码的复用性增强
2. 代码易维护
3. 使开发者更关注业务逻辑

2.1 AOP的七大术语

• 1 连接点 JoinPoint

在程序的整个执行流程中，可以切入 的位置，方法的执行前后，异常抛出之后等位置。

• 2 切点 Pointcut

在程序执行流程中，真正织入 切面的方法。（一个切点对应多个连接点）

• 3 通知 Advice

通知叫增强，就是具体你要插入\添加 的代码。

通知包括：

1. 前置通知
2. 后置通知
3. 环绕通知
4. 异常通知
5. 最终通知

• 4 切面 Aspect ：切面 = 切点 + 通知*
• 5 织入 Weaving

把通知应用到目标对象的过程

• 6 代理对象 Proxy

一个目标对象被织入通知后产生的新对象

• 7 目标对象 Target

被织入通知的对象。

2.2 AOP 当中的 切点表达式

所谓的切点表达式：就是用来定义通知（Advice） 往哪些方法上切入的。

切入点表达式语法表达格式：

execution([访问控制权限修饰符] 返回值类型 [全限定类名]方法名(形式参数列表) [异常])

1. 访问控制权限修饰符:

   可选项，可以没有
   没写，就是默认包括了4个权限
   写public 就表示只包括公开的方法。
                
   

1. 返回值类型：

必须要有
“*” 表示返回值类型任意

1. 全限定类名

可选项：可以不写
“..” 两个点，表示当前包以及子包下的所有类
省略：表示包括所有的类；就是所有

1. 方法名

必填项
"*" 表示该对应包下的所有任意方法() 就是所有的方法
set* 则表示所有 set 开头的方法()
get* 则表示所有 get 开头的方法()

1. 形式参数列表

必填项
() 空括号，表示没有参数的方法。
(..) 括号中有两个点，表示参数类型和参数个数任意的方法，
(*) 表示只有一个参数的方法
(*,String) 第一个参数类型随意，第二个参数类型必须是String 类型才行

1. 异常：

可选项
省略表示任意异常类型

举例：

execution(public * com.rainbowsea.mall.service.*.delete*(..))
 // 表示 public 公开的， * 返回值随意，在 com.rainbowsea.mall.service.* 包下以及子包下的类, delete开头的方法名的方法(参数随意(个数任意，参数类型任意))，的方法。
 

execution(* com.rainbowsea.mall..*(..))
// 表示 权限符(省略，则默认是包含了4种权限了)， * 返回值随意，com.rainbowsea.mall 包下以及子包下的 ..* 任意类，任意方法名，方法中的参数(个数任意，参数类型任意)

execution(* *(..))
// 表示所有的类当中的所有方法，就是所有

3. 使用Spring 对 AOP 的实现使用

Spring 对AOP 的实现包括以下 三种方式：

1. 第一种方式：Spring 框架结合 AspectJ框架实现的AOP，基于注解方式（该比较常用）。
2. 第二种方式：Spring框架结合AspectJ框架实现的AOP，基于XML方式。
3. 第三种方式：Spring 框架自己实现的AOP，基于XML方式。（并不怎么用）

实际开发中，都是Spring + AspectJ实现AOP。所以我们重点学习使用第一种和第二种方式。

什么是AspectJ ? （Eclipse组织的一个支持AOP的框架。AspectJ框架是独立于Spring框架之外的一个框架，Spring框架用了AspectJ）
AspectJ项目起源于帕洛阿尔托（Palo Alto）研究中心（缩写为PARC）。该中心由Xerox集团资助，Gregor Kiczales领导，从1997年开始致力于AspectJ的开发，1998年第一次发布给外部用户，2001年发布1.0 release。为了推动AspectJ技术和社团的发展，PARC在2003年3月正式将AspectJ项目移交给了Eclipse组织，因为AspectJ的发展和受关注程度大大超出了PARC的预期，他们已经无力继续维持它的发展。

3.1 准备工作

使用Spring+AspectJ的AOP需要引入的依赖如下：

<!--    Spring 的仓库-->
    <repositories>
        <repository>
            <id>repository.spring.milestone</id>
            <name>Spring Milestone Repository</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>


    <dependencies>
        <!--        spring context 依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.11</version>
        </dependency>


        <!--        spring aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>6.0.11</version>
        </dependency>
        <!--spring aspects依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>6.0.11</version>
        </dependency>

这边，我多用上了一个 junit4 的注解

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.rainbowsea</groupId>
    <artifactId>spring6-012-aop-realapp</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>


<!--    Spring 的仓库-->
    <repositories>
        <repository>
            <id>repository.spring.milestone</id>
            <name>Spring Milestone Repository</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>


    <dependencies>
        <!--        spring context 依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.11</version>
        </dependency>


        <!--        spring aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>6.0.11</version>
        </dependency>
        <!--spring aspects依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>6.0.11</version>
        </dependency>

        <!-- junit4 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

同时需要给：Spring.xml 配置文件中添加 context 命名空间和 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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
</beans>

3.2 Spring 基于AspectJ的AOP注解式开发

准备工作，搞定之后，我们就可以进行 Spring 基于 AspectJ的 AOP 注解式开发了。

3.2.1 实现步骤

第一步： 定义好目标类和目标方法。如下：

import org.springframework.stereotype.Service;

@Service(value = "orderService")  // 使用 @Service 注解，将该Bean交给 Spring IOC 容器管理
public class OrderService {  // 目标对象

    // 生成订单业务方法
    public void generate() {  // 目标方法
        System.out.println("正在生成订单...");
    }


    // 取消订单的业务的方法
    public void cancel() {  // 目标方法
        System.out.println("订单已取消");

    }
}

第二步： 定义切面类。

注意： 切面类也是要纳入Spirng IOC 容器当中管理的，因为你是在Spring 框架当中运用的AOP 编程，当然，需要被Spring 管理到，Spring 管理不到，又该让它如何使用呢。

目标类和切面类都纳入spring bean管理
在目标类OrderService上添加@Component 注解。
在切面类MyAspect类上添加@Component 注解。

package com.rainbowsea.spring6.service;


import org.springframework.stereotype.Component;

/**
 * 切面类
 */
@Component(value = "myAspect") // 纳入 Spring IOC 容器当中管理
public class MyAspect {

}

第四步： 在spring配置文件中添加组建扫描

所谓的组件扫描：就是让我们里面的注解的位置，简单的说：就是让Spring 框架去哪些包下找，我们的注解，从而管理我们注解下的 Bean 类对象。

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">


<!--    组件扫描-->
    <context:component-scan base-package="com.rainbowsea.spring6.service"></context:component-scan>

</beans>

第五步： 在切面类中添加通知

在切面类当中(对应的类当中)添加通知，就是将 @Aspect 注解，添加到类上就可以了，便会被Spring 框架开启事务通知的操作。

package com.rainbowsea.spring6.service;


import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

/**
 * 切面类
 */
@Component(value = "myAspect") // 纳入 Spring IOC 容器当中管理
@Aspect // 开启事务通知
public class MyAspect {
    // 这就是需要增强的代码（通知）
    public void advice(){
        System.out.println("我是一个通知");
    }

}

第六步：在通知上添加切点表达式

在方法当中添加上 @Before() 前置通知注解(详细内容，文章后面说明)，想要使用该@Before() 注解的前提是，要在该切面类上添加上 @Aspect 开启事务的注解才行， @Before(execution编写切点表达式)。

package com.rainbowsea.spring6.service;


import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * 切面类
 */
@Component(value = "myAspect") // 纳入 Spring IOC 容器当中管理
@Aspect // 开启事务通知
public class MyAspect {
    // 这就是需要增强的代码（通知）
    @Before("execution(* com.rainbowsea.spring6.service..*(..))")    // 切面表达式：表示：权限符省略，任意返回值，该包下的以及包下的任意方法(参数类型，个人数任意)
    public void advice(){
        System.out.println("我是一个通知");
    }

}

第七步： 在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:context="http://www.springframework.org/schema/context"
       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/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">


<!--    组件扫描-->
    <context:component-scan base-package="com.rainbowsea.spring6.service"></context:component-scan>


<!--    启动自动代理-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

<aop:aspectj-autoproxy  proxy-target-class="true"/> 开启自动代理之后，凡事带有@Aspect注解的bean都会生成代理对象。
proxy-target-class="true" 表示采用cglib动态代理
proxy-target-class="false" 表示采用jdk动态代理。默认值是false。即使写成false，当没有接口的时候，也会自动选择cglib生成代理类。

第八步： 测试程序：

import com.rainbowsea.spring6.service.AccountService;
import com.rainbowsea.spring6.service.OrderService;
import com.rainbowsea.spring6.service.UserService;
import com.rainbowsea.spring6.service.VipService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AOPRealAppTest {


    @Test
    public void testAOP() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml");
        AccountService accountService = applicationContext.getBean("accountService", AccountService.class);
        accountService.transfer();

        accountService.withdraw();

    }
}

3.2.2 各个通知类型的说明

在Spring 的 AOP当中：有如下五种通知类型：

1. 前置通知：@Before 目标方法执行之前的通知
2. 后置通知：@AfterReturning 目标方法执行之后的通知
3. 环绕通知：@Around 目标方法之前添加通知，通知目标方法执行之后添加通知
4. 异常通知：@AfterThrowing 发生异常之后执行的通知
5. 最终通知：@After 放在 finally 语句块当中的通知

注意：以上五种通知，可以配合上，同时使用上

注意：想要运用通知，需要在对应的切面类上(通知类)上，添加上 @Aspect 注解，开启事务通知，才行 。

1. 前置通知：@Before 目标方法执行之前的通知

前置通知使用： @Before(切面表达式)

import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * 切面类
 */
@Component(value = "myAspect") // 纳入 Spring IOC 容器当中管理
@Aspect // 开启事务通知
public class MyAspect {
    // 这就是需要增强的代码（通知）

    // 前置通知
    @Before("execution(* com.rainbowsea.spring6.service..*(..))")
    public void beforeAdvice() {
        System.out.println("前置通知");
    }
}

1. 后置通知：@AfterReturning 目标方法执行之后的通知

前置通知使用： @AfterReturning(切面表达式)

import org.springframework.stereotype.Component;

/**
 * 切面类
 */
@Component(value = "myAspect") // 纳入 Spring IOC 容器当中管理
@Aspect // 开启事务通知
public class MyAspect {
    // 这就是需要增强的代码（通知）
    
    // 后置通知
    @AfterReturning("execution(* com.rainbowsea.spring6.service..*(..))")
    public void afterReturningAdvice() {
        System.out.println("后置通知");
    }
}

1. 环绕通知：@Around 目标方法之前添加通知，通知目标方法执行之后添加通知

环绕通知需要加上：public void aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable，ProceedingJoinPoint joinPoint 参数，同时需要把 异常抛出去，在环绕通知当中需要：自己手动通过 ： ProceedingJoinPoint joinPoint.procced() 调用目标方法。才会执行目标方法，不然，是不会执行目标类当中的目标方法的。

// 这个JoinPoint joinPoint ，在Spring容器调用这个方法的时候自动传过来
// 我们可以直接用，用这个 JoinPoint joinPoint 干啥？
// Signature signature = joinPoint.getSignature(); 获取目标方法的签名
// 通过方法的签名可以获取到一个方法的具体信息
// 获取目标方法的方法名

环绕通知使用： @Around(切面表达式)

/**
 * 切面类
 */
@Component(value = "myAspect") // 纳入 Spring IOC 容器当中管理
@Aspect // 开启事务通知
public class MyAspect {
    // 这就是需要增强的代码（通知）

    // 环绕通知（环绕是最大的通知，在前置通知之前，在后置通知之后）
    @Around("execution(* com.rainbowsea.spring6.service..*(..))")
    public void aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        // 前面的代码
        System.out.println("前环绕");

        // 执行目标
        joinPoint.proceed(); // 执行目标

        // 后面的代码
        System.out.println("后环绕");
    }
}

1. 异常通知：@AfterThrowing 发生异常之后执行的通知，没发生异常是不会执行的。

异常通知使用： @AfterThrowing(切面表达式)

/**
 * 切面类
 */
@Component(value = "myAspect") // 纳入 Spring IOC 容器当中管理
@Aspect // 开启事务通知
public class MyAspect {
    // 这就是需要增强的代码（通知）
    // 异常通知
    @AfterThrowing("execution(* com.rainbowsea.spring6.service..*(..))")
    public void afterThrowignAdvice() {
        System.out.println("异常通知");
    }
}

异常通知：没有异常，就不会执行异常通知的操作。

这里，我们添加模拟上一个 null 指针异常进行，测试异常通知的执行。

1. 最终通知：@After 放在 finally 语句块当中的通知

最终通知使用： @After(切面表达式)。最终通知：无论是否存在异常都是在最后都会执行的。

/**
 * 切面类
 */
@Component(value = "myAspect") // 纳入 Spring IOC 容器当中管理
@Aspect // 开启事务通知
public class MyAspect {
    // 这就是需要增强的代码（通知）

    // 最终通知（finally 语句块中的通知）
    @After(("execution(* com.rainbowsea.spring6.service..*(..))"))
    public void afterAdvice() {
        System.out.println("最终通知");
    }
}

有异常，最终通知，也是会执行的。

通过测试得知，当发生异常之后，最终通知也会执行，因为最终通知@After会出现在finally语句块中。
出现异常之后，后置通知和环绕通知的结束部分不会执行。

下面，我们集合五种通知类型，同时发生，看看他们在通知当中的执行顺序又是如何的

package com.rainbowsea.spring6.service;


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.springframework.stereotype.Component;

/**
 * 切面类
 */
@Component(value = "myAspect") // 纳入 Spring IOC 容器当中管理
@Aspect // 开启事务通知
public class MyAspect {
    // 这就是需要增强的代码（通知）

    // 前置通知
    @Before("execution(* com.rainbowsea.spring6.service..*(..))")
    public void beforeAdvice() {
        System.out.println("前置通知");
    }


    // 后置通知
    @AfterReturning("execution(* com.rainbowsea.spring6.service..*(..))")
    public void afterReturningAdvice() {
        System.out.println("后置通知");
    }


    // 环绕通知（环绕是最大的通知，在前置通知之前，在后置通知之后）
    @Around("execution(* com.rainbowsea.spring6.service..*(..))")
    public void aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        // 前面的代码
        System.out.println("前环绕");

        // 执行目标
        joinPoint.proceed(); // 执行目标

        // 后面的代码
        System.out.println("后环绕");
    }


    // 异常通知
    @AfterThrowing("execution(* com.rainbowsea.spring6.service..*(..))")
    public void afterThrowignAdvice() {
        System.out.println("异常通知");

    }


    // 最终通知（finally 语句块中的通知）
    @After(("execution(* com.rainbowsea.spring6.service..*(..))"))
    public void afterAdvice() {
        System.out.println("最终通知");
    }

}

有异常的：

前环绕
前置通知
银行账户正在完成转账操作...
后置通知
最终通知
后环绕

总结：

环绕通知是范围最大的(也是是说，环绕通知的(前环绕)是在所有通知的最前面执行的，而环绕通知的(后环绕)是在所有通知的最后面执行的)。

前环绕
前置通知
异常通知
最终通知

存在异常时，异常通知执行了，但是后面的：后置通知，环绕通知的(后环绕)通知，并不会执行，被异常给中断了。

3.2.3 切面的先后顺序的设置

我们知道，业务流程当中不一定只有一个切面，可能有的切面控制事务，有的记录日志，有的进安全控制，如果多个切面的话，顺序如何控制：关于这一点：我们可以使用@Order 注解来标识切面类，为@Order注解的 value 指定一个整数型的数字，数字越小，优先级越高。

这里我们分别定义两个通知：分别为 安全方面的通知，和日志方面的通知。如下：

package com.rainbowsea.spring6.service;


import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;


/**
 * 安全事务
 */
@Component // 将该 Bean 交给Spring IOC 容器管理上
@Aspect // 开启事务
public class SecureAspect {

    // 前置通知
    // 安全
    @Before("execution(* com.rainbowsea.spring6.service..*(..))")
    public void beforeAdvice() {
        System.out.println("安全方面的:前置通知");
    }
}

package com.rainbowsea.spring6.service;


import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;


/**
 * 日志通知
 */
@Component // 将该 Bean 加入到 Spring IOC 容器当中管理
@Aspect  // 开启事务
public class LogAspect {

    // 前置通知
    @Before("execution(* com.rainbowsea.spring6.service..*(..))")
    public void beforeAdvice() {
        System.out.println("日志的通知方面的：前置通知");
    }
}

没有添加@Order 注解的通知顺序如下：

我们添加@Order注解的整数值来切换顺序，这里，我们将安全方面的通知，放在最前面执行，执行测试程序：

package com.rainbowsea.spring6.service;


import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;


/**
 * 日志通知
 */
@Component // 将该 Bean 加入到 Spring IOC 容器当中管理
@Aspect  // 开启事务
@Order(2)  // 数值越小，优先级越高，越先执行
public class LogAspect {

    // 前置通知
    @Before("execution(* com.rainbowsea.spring6.service..*(..))")
    public void beforeAdvice() {
        System.out.println("日志的通知方面的：前置通知");
    }
}

package com.rainbowsea.spring6.service;


import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;


/**
 * 安全事务
 */
@Component // 将该 Bean 交给Spring IOC 容器管理上
@Aspect // 开启事务
@Order(1) // 数值越小，优先级越高，越先执行
public class SecureAspect {

    // 前置通知
    // 安全
    @Before("execution(* com.rainbowsea.spring6.service..*(..))")
    public void beforeAdvice() {
        System.out.println("安全方面的:前置通知");
    }
}

3.2.4 优化切点表达式的方式

观看以下代码中的切点表达式：

package com.rainbowsea.spring6.service;


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.springframework.stereotype.Component;

/**
 * 切面类
 */
@Component(value = "myAspect") // 纳入 Spring IOC 容器当中管理
@Aspect // 开启事务通知
public class MyAspect {
    // 这就是需要增强的代码（通知）

    // 前置通知
    // 安全
    @Before("execution(* com.rainbowsea.spring6.service..*(..))")
    public void beforeAdvice() {
        System.out.println("前置通知");
    }


    // 后置通知
    @AfterReturning("execution(* com.rainbowsea.spring6.service..*(..))")
    public void afterReturningAdvice() {
        System.out.println("后置通知");
    }


    // 环绕通知（环绕是最大的通知，在前置通知之前，在后置通知之后）
    @Around("execution(* com.rainbowsea.spring6.service..*(..))")
    public void aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        // 前面的代码
        System.out.println("前环绕");

        // 执行目标
        joinPoint.proceed(); // 执行目标

        // 后面的代码
        System.out.println("后环绕");
    }


    // 异常通知
    @AfterThrowing("execution(* com.rainbowsea.spring6.service..*(..))")
    public void afterThrowignAdvice() {
        System.out.println("异常通知");

    }


    // 最终通知（finally 语句块中的通知）
    @After(("execution(* com.rainbowsea.spring6.service..*(..))"))
    public void afterAdvice() {
        System.out.println("最终通知");
    }

}

上述的缺点是：

1. 第一：切点表达式重复写了多次，没有得到复用。
2. 第二：如果要修改切点表达式，需要修改多处，难维护。

可以这样做：将切点表达式单独的定义出来，在需要的位置引入即可，如下：

我们可以使用：@Pointcut 注解来定义独立的切点表达式。
注意这个 @Pointcut 注解标注的方法随意，只是起到一个能够让@Pointcut注解编写的位置。

package com.rainbowsea.spring6.service;

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;

/**
 * 切面类
 */
@Component(value = "myAspect") // 纳入 Spring IOC 容器当中管理
@Aspect // 开启事务通知
public class MyAspect {
    // 这就是需要增强的代码（通知）

    // 定义通用的切点表达式
    @Pointcut("execution(* com.rainbowsea.spring6.service..*(..))")
    public void pointcut(){
        // 这个方法只是一个标记，方法名随意，方法体也不需要写任何代码。
    }

    // 前置通知
    // 安全
    @Before("pointcut()")
    public void beforeAdvice() {
        System.out.println("前置通知");
    }


    // 后置通知
    @AfterReturning("pointcut()")
    public void afterReturningAdvice() {
        System.out.println("后置通知");
    }


    // 环绕通知（环绕是最大的通知，在前置通知之前，在后置通知之后）
    @Around("pointcut()")
    public void aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        // 前面的代码
        System.out.println("前环绕");

        // 执行目标
        joinPoint.proceed(); // 执行目标

        // 后面的代码
        System.out.println("后环绕");
    }


    // 异常通知
    @AfterThrowing("pointcut()")
    public void afterThrowignAdvice() {
        System.out.println("异常通知");

    }


    // 最终通知（finally 语句块中的通知）
    @After(("pointcut()"))
    public void afterAdvice() {
        System.out.println("最终通知");
    }

}

3.2.5 Spring 全注解式开发ACP

就是编写一个类，在这个类上面使用大量注解来代替 spring.xml的配置文件，spring配置文件消失了，如下：

@Configuration // 代替spring.xml 文件
@ComponentScan(value = {"com.rainbowsea.spring6.service"})  // 组件扫描
@EnableAspectJAutoProxy(proxyTargetClass = true) // 启用 aspectj的自动代理机制

package com.rainbowsea.spring6.service;


import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration // 代替spring.xml 文件
@ComponentScan(value = {"com.rainbowsea.spring6.service"})  // 组件扫描
@EnableAspectJAutoProxy(proxyTargetClass = true) // 启用 aspectj的自动代理机制
public class Spring6Config {

}

测试程序也变化了：因为我这里是通过定义的一个配置类 代替 spring.xml 文件的需要用的是：new AnnotationConfigApplicationContext(配置类.class)，而不再是： new ClassPathXmlApplicationContext（）了。

public class AOPRealAppTest {


    @Test
    public void testAOPWithAllAnnotation() {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Spring6Config.class);
        AccountService accountService = applicationContext.getBean("accountService", AccountService.class);
        accountService.transfer();
    }

3.3 Spring 基于XML配置方式的AOP（了解）

第一步： 编写目标类。因为这里我们用的是 xml 配置方式的，不是注解的方式，所有就不用注解了。

package com.rainbowsea.spring6.service;

public class UserService {  // 目标对象

    public void logout() {  // 目标方法
        System.out.println("系统正在安全退出...");
    }
}

第二步： 编写切面类，并且编写通知

第三步： 编写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:context="http://www.springframework.org/schema/context"
       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/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">


<!--纳入 Spring ioc-->
    <bean id="userService" class="com.rainbowsea.spring6.service.UserService"></bean>
    <bean id="timerAspect" class="com.rainbowsea.spring6.service.TimerAspect"></bean>

<!--    aop 的配置-->
    <aop:config>
<!--        切点表达式-->
        <aop:pointcut id="mypointcut" expression="execution(* com.rainbowsea.spring6.service..*(..))"></aop:pointcut>
<!--        切面= 通知(具体代码)+切点(方法): 通知在方法里(方法中可以写具体的代码)-->
        <aop:aspect ref="timerAspect">
            <aop:around method="aroundAdvice" pointcut-ref="mypointcut"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

测试程序：

package com.rainbowsea.spring6.test;

import com.rainbowsea.spring6.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringAOPTest {


    @Test
    public void testXml() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml");
        UserService userService = applicationContext.getBean("userService", UserService.class);
        userService.logout();
    }
}

3.4 AOP 的实际案例：事务处理

项目中的事务控制是在所难免的。在一个业务流程当中，可能需要多条DML语句共同完成，为了保证数据的安全，这多条DML语句要么同时成功，要么同时失败。这就需要添加事务控制的代码。例如以下伪代码：

class 业务类1{
    public void 业务方法1(){
        try{
            // 开启事务
            startTransaction();
            
            // 执行核心业务逻辑
            step1();
            step2();
            step3();
            ....
            
            // 提交事务
            commitTransaction();
        }catch(Exception e){
            // 回滚事务
            rollbackTransaction();
        }
    }
    public void 业务方法2(){
        try{
            // 开启事务
            startTransaction();
            
            // 执行核心业务逻辑
            step1();
            step2();
            step3();
            ....
            
            // 提交事务
            commitTransaction();
        }catch(Exception e){
            // 回滚事务
            rollbackTransaction();
        }
    }
    public void 业务方法3(){
        try{
            // 开启事务
            startTransaction();
            
            // 执行核心业务逻辑
            step1();
            step2();
            step3();
            ....
            
            // 提交事务
            commitTransaction();
        }catch(Exception e){
            // 回滚事务
            rollbackTransaction();
        }
    }
}

class 业务类2{
    public void 业务方法1(){
        try{
            // 开启事务
            startTransaction();
            
            // 执行核心业务逻辑
            step1();
            step2();
            step3();
            ....
            
            // 提交事务
            commitTransaction();
        }catch(Exception e){
            // 回滚事务
            rollbackTransaction();
        }
    }
    public void 业务方法2(){
        try{
            // 开启事务
            startTransaction();
            
            // 执行核心业务逻辑
            step1();
            step2();
            step3();
            ....
            
            // 提交事务
            commitTransaction();
        }catch(Exception e){
            // 回滚事务
            rollbackTransaction();
        }
    }
    public void 业务方法3(){
        try{
            // 开启事务
            startTransaction();
            
            // 执行核心业务逻辑
            step1();
            step2();
            step3();
            ....
            
            // 提交事务
            commitTransaction();
        }catch(Exception e){
            // 回滚事务
            rollbackTransaction();
        }
    }
}
//......

可以看到，这些业务类中的每一个业务方法都是需要控制事务的，而控制事务的代码又是固定的格式，都是：

try{
    // 开启事务
    startTransaction();

    // 执行核心业务逻辑
    //......

    // 提交事务
    commitTransaction();
}catch(Exception e){
    // 回滚事务
    rollbackTransaction();
}

这个控制事务的代码就是和业务逻辑没有关系的 “交叉业务” 。以上伪代码当中可以看到这些交叉业务的代码没有得到复用，并且如果这些交叉业务代码需要修改，那必然需要修改多处，难维护，怎么解决？可以采用 AOP 思想解决。可以把以上控制事务的代码作为环绕通知 ，切入到目标类的方法当中，接下来我们做一下这件事，有两个业务类，如下：

package com.rainbowsea.spring6.service;


import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;


@Component(value = "accountService")
public class AccountService {  // 目标对象

    // 转账的业务方法
    public void transfer() {  // 目标方法
        System.out.println("银行账户正在完成转账操作...");

    }


    // 取帐的业务方法
    public void withdraw() { // 目标方法
        System.out.println("正在取款，请稍后...");
    }
}

package com.rainbowsea.spring6.service;

import org.springframework.stereotype.Service;

@Service(value = "orderService")  // 使用 @Service 注解，将该Bean交给 Spring IOC 容器管理
public class OrderService {  // 目标对象

    // 生成订单业务方法
    public void generate() {  // 目标方法
        System.out.println("正在生成订单...");
    }


    // 取消订单的业务的方法
    public void cancel() {  // 目标方法
        System.out.println("订单已取消");

    }
}

注意，以上两个业务类已经纳入spring bean的管理，因为都添加了@Component注解。
接下来我们给以上两个业务类的4个方法添加事务控制代码，使用AOP来完成：

package com.rainbowsea.spring6.service;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Component  // 交给Spring 管理
@Aspect  // 开始AOP
public class TransactionAspect {
    // 编程式事务解决方案
    @Around("execution(* com.rainbowsea.spring6.service..*(..))")  // 环绕通知
    public void aroundAdvice(ProceedingJoinPoint joinPoint) {
        // 执行目标
        try {
            // 前环绕
            System.out.println("开启事务");

            // 执行目标
            joinPoint.proceed();

            // 后环绕
            System.out.println("提交事务");

        } catch (Throwable throwable) {
            System.out.println("回滚事务");
            throwable.printStackTrace();
        }
    }
}

你看，这个事务控制代码是不是只需要写一次就行了，并且修改起来也没有成本。编写测试程序：

@Test
    public void testTransaction() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml");
        AccountService accountService = applicationContext.getBean("accountService", AccountService.class);
        OrderService orderService = applicationContext.getBean("orderService", OrderService.class);

        accountService.transfer();
        accountService.withdraw();

        orderService.generate();
        orderService.cancel();

    }

通过测试可以看到，所有的业务方法都添加了事务控制的代码。

关于Spring 对事务的支持使用，由于涉及到的篇幅比较多，大家可以移步至：✏️✏️✏️ (链接)

3.5 AOP 的实际案例：安全日志

需求是这样的：项目开发结束了，已经上线了。运行正常，客户提出了新的需求：凡事在系统中进行修改操作的，删除操作的，新增操作的，都要把这个人记录下来。因为这几个操作是属于危险行为。

package com.rainbowsea.spring6.service;


import org.springframework.stereotype.Service;

@Service(value = "userService")  // 被spring 管理
public class UserService {
    public void saveUser() {
        System.out.println("新增用户信息");
    }



    public void deleteUser() {
        System.out.println("删除用户信息");
    }


    public void modifyUser() {
        System.out.println("修改用户信息");
    }



    public void getUser() {
        System.out.println("获取用户信息");
    }
}

package com.rainbowsea.spring6.service;


import org.springframework.stereotype.Service;

@Service(value = "vipService")  // 被 spring管理
public class VipService {
    public void saveVip() {
        System.out.println("新增Vip用户信息");
    }



    public void deleteVip() {
        System.out.println("删除Vip用户信息");
    }


    public void modifyVip() {
        System.out.println("修改Vip用户信息");
    }



    public void getVip() {
        System.out.println("获取Vip用户信息");
    }
}

注意：已经添加了@Component注解。
接下来我们使用aop来解决上面的需求：编写一个负责安全的切面类。

这里我们可以联合使用，多个类当中的不同的方法名对应 AOP事务进行也给控制

package com.rainbowsea.spring6.service;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;


@Component(value = "securityLogAspect")  // 交给 spring 管理
@Aspect // 开启事务
public class SecurityLogAspect {

    // 在 com.rainbowsea.spring6.service..save*() 包下的任意类当中的，save* 开头的任意方法,参数任意
    @Pointcut("execution(* com.rainbowsea.spring6.service..save*(..))")
    public void savePointcut() {

    }

    // 在execution(* com.rainbowsea.spring6.service..delete*(..)) 包下的任意类当中的 delete*(..) 开头的任意方法，任意参数
    @Pointcut("execution(* com.rainbowsea.spring6.service..delete*(..))")
    public void deletePointcut() {

    }

    // execution(* com.rainbowsea.spring6.service..delete*(..)) 包下的任意类当中的modify*(..) 开头的任意方法，任意参数
    @Pointcut("execution(* com.rainbowsea.spring6.service..modify*(..))")
    public void modifyPointcut() {

    }





    // 联合使用，多个类当中的不同的方法名对应 AOP事务
    @Before("savePointcut() || deletePointcut() || modifyPointcut()")
    public void beforeAdvice(JoinPoint joinPoint) {
        // 系统时间
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss SSS");
        String nowTime = simpleDateFormat.format(new Date());

        // 输出日志信息
        System.out.println(nowTime + "zhangsan" + joinPoint.getSignature().getDeclaringTypeName()+
                "." + joinPoint.getSignature().getName());
    }
}

    @Test
    public void testSecurityLong() {
        ApplicationContext applicationContext =  new ClassPathXmlApplicationContext("spring6.xml");
        UserService userService = applicationContext.getBean("userService", UserService.class);
        VipService vipService = applicationContext.getBean("vipService", VipService.class);

        userService.saveUser();
        userService.deleteUser();
        userService.modifyUser();
        userService.getUser();


        vipService.saveVip();
        vipService.saveVip();
        vipService.modifyVip();
        vipService.getVip();
    }

4. 总结：

1. 简单的说AOP：就是将与核心业务 无关的代码抽离开来，形成一个独立的组件，然后，以横向 交叉的方式应用到业务流程当中的过程被称为 AOP
2. AOP的七大术语
3. AOP 的五种通知(通知叫增强，就是具体你要插入\添加 的代码。)的特点：及其对应的注解
4. AOP的切点表达式，所谓的切点表达式：就是用来定义通知（Advice） 往哪些方法上切入的。

execution([访问控制权限修饰符] 返回值类型 [全限定类名]方法名(形式参数列表) [异常])

1. 切面类也是要纳入Spirng IOC 容器当中管理的，因为你是在Spring 框架当中运用的AOP 编程，当然，需要被Spring 管理到，Spring 管理不到，又该让它如何使用呢。
2. 所有的五种通知上的使用都必须在该对应的类上，要在该切面类上添加上 @Aspect 开启事务的注解才行。同时也要纳入Spirng IOC 容器当中管理的。才行
3. 五种通知，可以配合上，同时使用上时
   1. 环绕通知是范围最大的(也是是说，环绕通知的(前环绕)是在所有通知的最前面执行的，而环绕通知的(后环绕)是在所有通知的最后面执行的)。
   2. 存在异常时，异常通知执行了，但是后面的：后置通知，环绕通知的(后环绕)通知，并不会执行，被异常给中断了。
4. 切面的先后顺序的设置：关于这一点：我们可以使用@Order 注解来标识切面类，为@Order注解的 value 指定一个整数型的数字，数字越小，优先级越高。
5. 切点表达式的优化：我们可以使用：@Pointcut 注解来定义独立的切点表达式。
   注意这个 @Pointcut 注解标注的方法随意，只是起到一个能够让@Pointcut注解编写的位置。
6. 第一种方式：Spring 框架结合 AspectJ框架实现的AOP，基于注解方式（该比较常用）。
7. 第二种方式：Spring框架结合AspectJ框架实现的AOP，基于XML方式。
8. 关于Spring 在事务上的支持上的使用，由于涉及的篇幅内容过多，所以就不在这里说明了，想要了解更多的可以移步至：✏️✏️✏️

切面类要不仅要加上 开始事务的注解，也要添加上 Spring IOC 容器管理的注解。