轻松上手Spring AOP，掌握切面编程的核心技巧

文章目录

AOP 是什么
AspectJ
Spring AOP
切点表达式
- execution()
- - 语法结构
  - 示例
  - 注意事项
通知（Advice）类型
如何使用
- 准备阶段
- 定义切面
- 定义并使用切点
- 测试
总结

前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。

Spring框架是我们使用比较多的一个框架，而AOP又是Spring的核心特性之一，本篇文章将介绍一下AOP的切点表达式、通知等特性及如何使用Spring AOP。

AOP 是什么

AOP（Aspect-Oriented Programming，面向切面编程） 是一种编程范式，旨在将横切关注点与核心业务逻辑相分离，以提高代码的模块化性、可维护性和复用性。

在传统的面向对象编程中，程序的功能被模块化为类和方法，但某些功能可能会跨越多个类和方法，如日志记录、事务管理、安全控制等，这些功能不属于核心业务逻辑，但又必须在多个地方重复使用，导致代码重复和耦合性增加。

AOP提供了一种机制，可以将这些横切关注点单独定义，并在需要的地方插入到应用程序中，而不必修改核心业务逻辑。

AspectJ

AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP（面向切面编程） 语法，并拥有一个专门的编译器，用于生成遵守Java字节编码规范的Class文件。

AspectJ可以单独使用，也可以整合到其他框架中。当单独使用AspectJ时，需要使用专门的编译器ajc。AspectJ属于静态织入，通过修改代码来实现，包括编译期织入等多种织入时机。

Spring集成AspectJ，可以在Spring中方便的使用AOP。

Spring AOP

Spring AOP核心概念主要包括以下几个方面：

切面（Aspect）：切面是模块化横切关注点的机制，由切入点和通知组成。在Spring AOP中，一个切面可以定义在什么时候、什么地方以及如何应用某种特定的行为到目标对象上。
连接点（Joinpoint）：连接点是程序执行过程中的一个点，例如方法的调用、字段的访问等。在Spring AOP中，一个连接点总是代表一个方法的执行。连接点是AOP框架可以在其上 “织入” 切面的点。
通知（Advice）：通知定义了在切入点执行时要执行的代码，它是增强应用到连接点上的行为。通知有多种类型，包括前置通知（Before Advice）、后置通知（After Advice） 、环绕通知（Around Advice） 、异常通知（After Throwing Advice） 和 返回通知（After Returning Advice） 。这些通知类型决定了增强在连接点上的执行顺序和方式。
切点（Pointcut）：切点用于定义通知应该应用到哪些连接点上。它是一组连接点的集合，这些连接点共享相同的特性。切点表达式用于匹配连接点，从而确定哪些连接点应该接收通知。
目标对象（Target Object） ：被一个或多个切面所通知的对象。也被称为被通知（advised）对象。由于Spring AOP是通过代理模式实现的，因此在运行时，目标对象总是被代理对象所包裹。
织入（Weaving）：织入是将切面应用到目标对象并创建代理对象的过程。这是AOP框架在运行时或编译时完成的核心任务。
AOP代理（AOP Proxy）：AOP框架创建的对象，用于实现切面编程。在Spring中，AOP代理可以是JDK动态代理或CGLIB代理。
引入（Introduction）：用于向现有的类添加新的接口和实现，而不需要修改原始类的代码。Introduction允许在不修改现有类结构的情况下，向类引入新的功能和行为。在 AspectJ 社区中，引入称为类型间声明（inter-type declaration）。

这些核心概念共同构成了AOP的基础，使得我们能够模块化地处理横切关注点，从而提高代码的可维护性和可重用性。

切点表达式

Pointcut 表达式 是用来定义切入点的规则，它决定了哪些连接点（方法调用或方法执行）将会被通知所影响。在 Spring AOP 中，Pointcut 表达式通常由以下几种规则和通配符组成：

execution()： 用于匹配方法执行的连接点，它是最常用的切点指示器。它基于方法签名进行匹配，可以指定方法的返回类型、包名、类名、方法名以及参数列表等。比如： @Pointcut("execution(* com.example.myapp.service.*.*(..))") 表示匹配com.example.myapp.service包下所有类的所有方法执行。
within()： 匹配指定类型内的方法执行连接点。它通常用于匹配特定包或类中的所有方法。示例：@Pointcut("within(com.example.myapp.service.*)") 表示表示匹配com.example.myapp.service包下所有类的所有方法的执行。
this()： 匹配当前代理对象为指定类型的连接点。这用于限制切点只匹配特定类型的代理对象。示例：@Pointcut("this(com.example.myapp.service.MyService)") 表示匹配当前代理对象类型为com.example.myapp.service.MyService的所有方法的执行。
target()： 匹配目标对象为制定类型的连接点。与this()不同，target()是基于目标对象类型，而不是代理类型。示例：@Pointcut("target(com.example.myapp.service.MyServiceImpl)") 表示匹配目标对象类型为com.example.myapp.service.MyServiceImpl的所有方法的执行。
args()： 匹配方法执行时参数为特定类型的连接点。示例：@Pointcut("args(java.io.Serializable)") 表示匹配方法执行时至少有一个参数是java.io.Serializable类型的连接点。
@annotation()： 匹配执行的方法上带有指定注解的连接点。示例：@Pointcut("@annotation(com.example.myapp.annotation.MyAnnotation)") 表示匹配执行的方法上带有com.example.myapp.annotation.MyAnnotation注解的连接点。
@target：用于匹配所有带有特定注解的类或接口。这个指示器通常与execution表达式结合使用，以进一步细化匹配条件。示例：@Pointcut("@target(com.example.annotation.MyAnnotation)") 表示匹配目标对象类型上带有com.example.myapp.annotation.MyAnnotation注解的方法执行。
@within：匹配指定类型带有指定注解的连接点。与within()类似，但它是基于注解而不是包或类。示例： @Pointcut("@within(com.example.myapp.annotation.MyAnnotation)") 表示匹配带有MyAnnotation注解的类的方法执行。
bean()：匹配Spring容器中特定名称的bean的方法的执行。示例： @Pointcut("bean(myServiceImpl)") 表示匹配Spring容器中名称为myServiceImplbean的方法的执行。
@args()：用于限制匹配的方法的参数必须有指定的注解。

带有 @ 符的切点表达式都是需要指定注解的连接点。

这些规则可以通过逻辑运算符（如 &&、||、! ）进行组合，以实现更复杂的 Pointcut 匹配规则。我们可以根据自己的需求，灵活地使用这些规则来定义切入点表达式，实现对目标方法的精确匹配和监控。

execution()

execution() 表达式使用的比较多，最复杂的一个表达式，这里重点介绍一下。

语法结构

execution() 表达式的语法结构如下：

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

其中，各部分的含义如下：

modifiers-pattern: 方法的访问修饰符，如 public、protected 等，可以省略。
ret-type-pattern: 方法的返回类型，如 void、int 等。
declaring-type-pattern: 方法所属的类的类型模式，可以使用通配符 * 匹配任意字符。
name-pattern: 方法的名称模式，可以使用通配符 * 匹配任意字符。
param-pattern: 方法的参数模式，包括参数类型和个数。
throws-pattern: 方法抛出的异常类型。

示例

所有公共方法的执行

execution(public * *(..))

名称以 set 开头的所有方法的执行

execution(* set*(..))

AccountService 接口定义的任何方法的执行

execution(* com.xyz.service.AccountService.*(..))

service 包中定义的任何方法的执行

execution(* com.xyz.service.*.*(..))

service 包或其子包之一中定义的任何方法的执行

execution(* com.xyz.service..*.*(..))

执行指定类型参数的方法

execution(* com.example.service.MyService.myMethod(String, int))

注意事项

在 execution() 表达式中，通配符 * 可以用来匹配任意字符或任意个数的字符。
使用 execution() 表达式时，需要注意合理地组织表达式，以确保精准地匹配目标方法。
可以通过组合多个条件来更加灵活地定义切点，例如同时匹配方法的访问修饰符、返回类型、类名、方法名等。

总的来说，execution() 方法提供了一种灵活且强大的方式来定义切点表达式，从而精确定位需要添加通知的目标方法。

通知（Advice）类型

在 Spring AOP 中，通知（Advice）是在切入点（Pointcut）上执行的代码。Spring 提供了几种类型的通知，每种类型都对应着在连接点执行前、执行后或抛出异常时执行的不同代码逻辑。这些通知对应着不同的注解，常用的通知注解包括：

@Before： 在方法执行之前执行的通知。它有以下属性：
- value：要绑定的切点或者切点表达式。
- argNames：用于指定连接点表达式中方法参数的名称，以便在通知方法中通过参数名来获取方法参数的值。这样可以在前置通知中访问和处理方法参数的具体数值。该属性即使不指定也能获取参数。
@AfterReturning： 在方法执行成功返回结果后执行的通知。它比 @Before注解多了2个属性：
- pointcut：作用和value属性一样，当指定pointcut时，会覆盖value属性的值。
- returning：方法返回的结果将被绑定到此参数名，可以在通知中访问方法的返回值。
@AfterThrowing： 在方法抛出异常后执行的通知。它的属性前3个和 @AfterReturning注解一样，多了1个属性：
- throwing：指定方法抛出的异常将被绑定到此参数名，可以在通知中访问方法抛出的异常。
@After： 在方法执行后（无论成功或失败）执行的通知。属性同 @Before 注解。
@Around： 环绕通知，能够在方法执行前后都可以进行操作，具有最大的灵活性。属性同 @Before 注解。

通知的执行顺序为：@Around -> @Before -> @AfterReturning(不抛异常情况) 或者 @AfterThrowing(抛异常情况) -> @After

这些通知注解可以与 Pointcut 表达式结合使用，实现对目标方法的拦截和处理。通过选择合适的通知类型，开发者可以根据需求在不同的时间点插入自定义的逻辑，实现对方法调用的控制和增强。

如何使用

讲了那么多概念性的东西，下面来看怎么使用Spring AOP。

在Spring 中使用AOP也很简单，主要分3步：

定义切面
定义切点
在具体通知上使用切点

准备阶段

我这里使用的是Springboot 3.1.5、jdk 17，如果是Springboot低版本的可能需要引入 spring-boot-starter-aop 依赖，高版本的AOP已经包含在spring-boot-starter-web依赖中了：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

Spring官网中介绍，使用Spring AOP要在启动类或者配置类中加上 @EnableAspectJAutoProxy 注解开启 AspectJ 注解的支持，在我使用的这个版本中并不需要，如果你的项目中切面未生效可以尝试使用该注解。

定义一个接口，下面用于对这个接口及其实现类进行拦截：

public interface AopService {

    /**
     * 两数除法
     * @param a
     * @param b
     * @return
     */
    BigDecimal divide(BigDecimal a, BigDecimal b);

    /**
     * 两数加法
     * @param a
     * @param b
     * @return
     */
    BigDecimal add(BigDecimal a, BigDecimal b);
}

@Service
public class MyAopServiceImpl implements AopService{

    /**
     * 两数除法
     *
     * @param a
     * @param b
     * @return
     */
    @Override
    public BigDecimal divide(BigDecimal a, BigDecimal b) {
        return a.divide(b , RoundingMode.UP);
    }

    /**
     * 两数加法
     *
     * @param a
     * @param b
     * @return
     */
    @Override
    public BigDecimal add(BigDecimal a, BigDecimal b) {
        return a.add(b);
    }
}

定义切面

新建一个类，在类上加上@Aspect 注解，标记该类为切面。

@Component
@Aspect
public class AspectComponent {
}

定义并使用切点

在切面中使用@Pointcut注解定义切点表达式，然后在通知注解中使用定义好的切点。在该示例中主要对AopService#divide()方法进行拦截。

@Component
@Aspect
public class AspectComponent {

	/**
     * 匹配AopService接口的divide方法
     */
    @Pointcut("execution(* site.suncodernote.aop.AopService.divide(..))")
    void dividePointCut(){
    }

	/**
     * 匹配AopService接口的divide方法
     */
    @Pointcut("within(site.suncodernote.aop.AopService+)")
    void withinPointCut(){
    }

	/**
     * 匹配AopService接口的add方法 或者 divide方法
     */
    @Pointcut("execution(* site.suncodernote.aop.AopService.add(..)) || execution(* site.suncodernote.aop.AopService.divide(..))")
    void addOrDividePointCut(){
    }


	@Before("dividePointCut()")
    public void beforeDivide(JoinPoint joinPoint){
        System.out.println("---------------------@Before----------------");
        printJoinPoint(joinPoint);
    }

    @After("dividePointCut()")
    public void afterDivide(JoinPoint joinPoint){
        System.out.println("---------------------@After----------------");
        printJoinPoint(joinPoint);
    }

    @AfterReturning(pointcut = "dividePointCut()" , returning = "result")
    public void afterReturningDivide(JoinPoint joinPoint , BigDecimal result){
        System.out.println("---------------------@AfterReturning----------------");
        System.out.println("返回结果="+result);
        printJoinPoint(joinPoint);
    }

    @AfterThrowing(pointcut = "dividePointCut()" , throwing = "e")
    public void afterThrowingDivide(JoinPoint joinPoint ,Exception e){
        System.out.println("---------------------@AfterThrowing----------------");
        System.out.println("异常："+e.getMessage());
        printJoinPoint(joinPoint);
    }

    @Around("dividePointCut()")
    public Object aroundDivide(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("---------------------@Around----------------");
        printJoinPoint(joinPoint);
        Object[] args = joinPoint.getArgs();
        Object result = null;
        try {
            //执行方法
            result = joinPoint.proceed(args);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("返回值："+result);
        return result;
    }

    private void printJoinPoint(JoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        Signature signature = joinPoint.getSignature();
        System.out.println("方法名："+signature.getName());
        System.out.println("方法参数："+ Arrays.toString(args));
        System.out.println();
    }
}

测试

写个简单的单元测试，调用AopService#divide()方法，然后看一下输出结果。

@SpringBootTest
public class AOPTest {

    @Resource
    private AopService aopService;

    @Test
    public void testAOP() {
        BigDecimal a = new BigDecimal(1);
        BigDecimal b = new BigDecimal(2);

//        aopService.add(a, b);
        aopService.divide(a, b);
    }
}

测试结果：

---------------------@Around----------------
方法名：divide
方法参数：[1, 2]

---------------------@Before----------------
方法名：divide
方法参数：[1, 2]

---------------------@AfterReturning----------------
返回结果=1
方法名：divide
方法参数：[1, 2]

---------------------@After----------------
方法名：divide
方法参数：[1, 2]

返回值：1