【SpringBoot3】面向切面 AspectJ AOP 使用详解

AspectJ是一个面向切面的框架，它扩展了Java语言，并定义了AOP（面向切面编程）语法。AspectJ支持数据埋点、日志记录、性能统计、安全控制、事务处理、异常处理等多种横切关注点。通过AspectJ，开发者可以更加直观地定义和理解代码的行为，减少对业务逻辑的干扰。

顽石九变

1984人浏览 · 2024-09-13 14:37:54

顽石九变 · 2024-09-13 14:37:54 发布

一、AspectJ介绍

AspectJ是一个面向切面的框架，它扩展了Java语言，并定义了AOP（面向切面编程）语法。

AspectJ支持数据埋点、日志记录、性能统计、安全控制、事务处理、异常处理等多种横切关注点。通过AspectJ，开发者可以更加直观地定义和理解代码的行为，减少对业务逻辑的干扰。

特点：

模块化：AspectJ允许开发者将横切关注点以模块化的方式进行管理和重用，提高了代码的可维护性和可读性。
声明式编程：AspectJ使用注解或XML配置的方式来声明横切关注点，减少了重复的样板代码。
细粒度控制：AspectJ提供了丰富的切点表达式语言，可以精确地选择需要横切的连接点，实现对代码的细粒度控制。
跨模块切面：AspectJ可以在不同的模块之间进行切面的织入，使得横切关注点可以跨越多个模块进行统一管理。
与Java语言的兼容性：AspectJ是基于Java语言的扩展，与Java语法完全兼容，可以无缝地与现有的Java代码进行集成和使用。

二、简单使用步骤

1、引入依赖

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

2、定义一个Aspect

import org.aspectj.lang.annotation.Aspect;  
import org.aspectj.lang.annotation.Before;  
import org.springframework.stereotype.Component;  
  
@Aspect  
@Component  
public class MyAspect {  
  
    // 定义切点，表示对哪些类的哪些方法进行拦截  
    // execution表达式指定了方法签名  
    // 第一个"*"表示任意返回类型，第二个"*"表示类中的任意方法  
    // ".."表示任意参数  
    // 这里的例子表示拦截UserService中的所有方法  
    @Before("execution(* com.example.service.UserService.*(..))")  
    public void beforeAdvice() {  
        System.out.println("Before method: Do something before.");  
    }  
}

3、开启AOP支持

在Spring Boot应用中，通常通过@SpringBootApplication注解启动应用，该注解包含了@EnableAspectJAutoProxy，因此默认情况下Spring Boot应用是支持AOP的。

如果你的应用配置较为特殊，确保你的配置类上（通常是主类）添加了@EnableAspectJAutoProxy注解以开启对AspectJ自动代理的支持。

三、AOP 核心概念

切面（Aspect）：AOP 的模块单元，封装了切点、通知以及类型间声明。在Spring AOP中，切面通过使用常规类或使用@Aspect注解的常规类（@AspectJ风格）来实现。
连接点（Join point）：程序流中指定的一点，如方法调用、方法执行、字段访问等。
通知（Advice）：切面在特定连接点上采取的动作。通知包括“环绕”、“前置”和“后置”通知。许多AOP框架，包括Spring，都将通知建模为拦截器，并在连接点周围维护一个拦截器链。
切点（Pointcut）：匹配连接点的谓词。通知与切点表达式相关联。Spring默认使用AspectJ切点表达式语言。
引入（Introduction）：代表一个类型声明额外的方法或字段。Spring AOP允许您向任何被通知的对象引入新接口（以及相应的实现）。例如，您可以使用引入来使bean实现IsModified接口，以简化缓存。
目标对象（Target object）：被一个或多个切面通知的对象。也称为“被通知对象”。由于Spring AOP是通过使用运行时代理实现的，因此这个对象总是一个代理对象。
AOP代理（AOP proxy）：由AOP框架创建的对象，用于实现切面契约（如通知方法的执行等）。在Spring框架中，AOP代理是JDK动态代理或CGLIB代理。
织入（Weaving）：将切面与其他应用类型或对象链接起来以创建被通知对象。这可以在编译时（例如，使用AspectJ编译器）、加载时或运行时完成。Spring AOP像其他纯Java AOP框架一样，在运行时执行织入。

Spring AOP包括以下类型的通知：

前置通知（Before advice）：在连接点之前运行的通知，但它没有能力阻止执行程序执行（除非它抛出异常）。
后置返回通知（After returning advice）：在连接点正常完成后运行的通知（例如，如果方法返回而没有抛出异常）。
后置异常通知（After throwing advice）：如果方法通过抛出异常退出时运行的通知。
后置（最终）通知（After (finally) advice）：无论连接点以何种方式退出（正常或异常返回）都要运行的通知。
环绕通知（Around advice）：围绕连接点（如方法调用）的通知。这是最强大的通知类型。环绕通知可以在方法调用之前和之后执行自定义行为。它还负责选择是否继续到连接点，或者通过返回自己的返回值或抛出异常来短路被通知方法的执行。

环绕通知是最通用的通知类型。由于Spring AOP像AspectJ一样提供了全范围的通知类型，因此建议您使用能够实现所需行为的最不强大的通知类型。例如，如果您只需要使用方法的返回值更新缓存，那么实现后置返回通知比实现环绕通知更好，尽管环绕通知也可以完成同样的事情。使用最具体的通知类型提供了更简单的编程模型，并且减少了出错的可能性。例如，您不需要在用于环绕通知的JoinPoint上调用proceed()方法，因此您不会忘记调用它。

所有通知参数都是静态类型的，因此您可以使用适当类型的通知参数（例如，方法执行的返回值的类型）而不是Object数组。

四、切点（Pointcut）

Spring AOP支持使用AspectJ切入点表达式来指定切点。这些表达式可以非常灵活地定义需要拦截的方法集合。以下是一些常用的切点指示符和示例：

1. execution

execution是最常用的切入点指示符，用于匹配方法执行的连接点。其语法结构如下：

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

modifiers-pattern（可选）：方法的修饰符，如public、private等。
ret-type-pattern：方法的返回类型，*表示任意类型。
declaring-type-pattern（可选）：声明方法的类，支持使用..来表示包及其子包下的所有类。
name-pattern：方法的名称。
param-pattern：方法的参数列表，..表示任意数量和类型的参数，*表示任意类型的一个参数，(*, String)表示第一个参数是任意类型，第二个参数是String类型。
throws-pattern（可选）：方法抛出的异常类型。

示例

匹配任意类的任意方法：execution(* *(..))
匹配com.example.service包下所有类的所有方法：execution(* com.example.service..*.*(..))
匹配MyService类中的doSomething方法：execution(* com.example.service.MyService.doSomething(..))
匹配任意类的save方法，且方法参数为java.lang.String类型：execution(* *.save(java.lang.String))

2. within

within用于匹配指定类型内的方法执行，包括指定的接口、类或包。

示例

匹配com.example.dao包下的所有类的所有方法：within(com.example.dao.*)
匹配com.example.dao包及其子包中所有类中的所有方法：within(com.example.dao..*)
匹配实现了UserService接口的类的所有方法：within(com.example.service.UserService+)

3. this & target

this：用于匹配当前AOP代理对象类型的执行方法，注意是AOP代理对象的类型匹配。
target：用于匹配当前目标对象类型的执行方法，注意是目标对象的类型匹配。

示例

匹配当前AOP代理对象类型为MyService的所有方法执行：this(com.example.service.MyService)
匹配当前目标对象类型为MyService的所有方法执行：target(com.example.service.MyService)

4. args & @args

args：用于匹配当前执行的方法传入的参数为指定类型的执行方法，参数类型列表中的参数必须是类型全限定名，通配符不支持。
@args：匹配方法传入的参数所属类上拥有指定的注解的情况。

示例

匹配方法参数为String类型的方法：args(java.lang.String)
匹配方法参数类型上拥有@MyAnnotation注解的方法调用：@args(com.example.MyAnnotation)

5. @within & @target & @annotation

@within：匹配类级别上应用了特定注解的类中的所有方法。
@target：匹配运行时目标对象（代理对象）的类型上应用了特定注解的方法（在Spring AOP中常用于代理对象的切点定义）。
@annotation：匹配方法级别上应用了特定注解的方法。

示例

匹配所有类上具体指定了@MyAnnotation注解的类内的所有方法：@within(com.example.MyAnnotation)
匹配当前目标对象类型持有@MyAnnotation注解的方法：@target(com.example.MyAnnotation)
匹配所有拥有@MyAnnotation注解的外部调用方法：@annotation(com.example.MyAnnotation)

五、通知（Advice）

Spring AOP提供了多种类型的Advice，包括：

@Before：在目标方法执行之前执行。
@AfterReturning：在目标方法正常执行完成后执行。
@AfterThrowing：在目标方法抛出异常时执行。
@After：无论目标方法执行结果如何，最终都会执行。
@Around：在目标方法执行前后执行，并可以控制目标方法的执行。

每种类型的Advice都需要与切入点表达式结合使用，以确定其应用的范围。

1. @Before 示例：日志记录

在方法执行之前记录日志，常用于跟踪方法的调用。

@Aspect
@Component
public class LoggingAspect {
    // 定义切点，表示对哪些类的哪些方法进行拦截
    // execution表达式指定了方法签名
    // 第一个"*"表示任意返回类型，第二个"*"表示类中的任意方法
    // ".."表示任意参数
    // 这里的例子表示拦截UserService中的所有方法
    @Before("execution(* com.example.service.UserService.*(..))")
    public void logBeforeMethodExecution(JoinPoint joinPoint) {
        System.out.println("Before executing method: " + joinPoint.getSignature().getName());
    }
    
    // 定义切点，表示对哪些类的哪些方法进行拦截
    // execution表达式指定了方法签名
    // 第一个"*"表示任意返回类型，第二个"*"表示类中的任意方法
    // 第一次".."表示包及其子包下的所有类
    // 第二次".."表示任意参数
    @Before("execution(* com.example..*(..))")
    public void logBeforeMethodExecutionAll(JoinPoint joinPoint) {
        System.out.println("Before executing method all: " + joinPoint.getSignature().getName());
    }
}

2. @AfterReturning 示例：处理返回值

在方法成功执行并返回后，对返回值进行处理或记录。

@Aspect
@Component
public class ReturnValueAspect {

    @AfterReturning(pointcut = "execution(* com.example.service.UserService.getUserById(..))", returning = "result")
    public void logReturnValue(Object result) {
        System.out.println("Method returned: " + result);
    }
}

3. @AfterThrowing 示例：异常处理

在方法抛出异常时捕获异常，并进行相应的处理或记录。

@Aspect
@Component
public class ExceptionHandlingAspect {

    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "ex")
    public void handleException(Exception ex) {
        System.err.println("An exception occurred: " + ex.getMessage());
    }
}

4. @After 示例：资源释放

无论方法执行结果如何，都会在方法执行后执行，常用于资源释放。

@Aspect
@Component
public class ResourceReleaseAspect {

    @After("execution(* com.example.service.*.*(..))")
    public void releaseResources() {
        System.out.println("Resources are released after method execution");
    }
}

5. @Around 示例：方法执行前后处理

在方法执行前后都进行处理，可以控制方法的执行或添加额外的逻辑。

@Aspect
@Component
public class AroundAdviceAspect {

    @Around("execution(* com.example.service.UserService.*(..))")
    public Object logAroundMethodExecution(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Before executing method: " + joinPoint.getSignature().getName());
        Object result = joinPoint.proceed(); // 执行目标方法
        System.out.println("After executing method: " + joinPoint.getSignature().getName());
        return result;
    }
}

6. 参数相关 Advice 示例：验证参数

在方法执行之前验证参数的有效性。

@Aspect
@Component
public class ParameterValidationAspect {

    @Before("execution(* com.example.service.UserService.addUser(com.example.model.User)) && args(user)")
    public void validateUserParameter(User user) {
        if (user == null || user.getName() == null || user.getName().isEmpty()) {
            throw new IllegalArgumentException("User parameter is invalid");
        }
    }
}

7. 注解相关 Advice 示例：基于注解的日志记录

根据方法上的注解来决定是否进行日志记录。可以使用注解全限定名或使用参数中的注解参数名。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Loggable {
}

@Aspect
@Component
public class AnnotationDrivenLoggingAspect {

    @Before("@annotation(com.example.aspect.Loggable)")
    public void logMethodWithAnnotation(JoinPoint joinPoint) {
        System.out.println("Executing loggable method: " + joinPoint.getSignature().getName());
    }
    
    // 使用参数中的注解
    @Before("@annotation(loggable)")
    public void logMethodWithAnnotationArg(JoinPoint joinPoint, Loggable loggable) {
        System.out.println("Executing loggable method: " + joinPoint.getSignature().getName());
    }
}

// 在需要日志记录的方法上使用@Loggable注解
@Service
public class MyService {

    @Loggable
    public void myLoggableMethod() {
        // ...
    }
}

8. @AfterThrowing 异常示例：特定异常处理

仅当方法抛出特定类型的异常时进行处理。

@Aspect
@Component
public class SpecificExceptionHandlingAspect {

    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "ex")
    public void handleSpecificException(CustomException ex) {
        System.err.println("A CustomException occurred: " + ex.getMessage());
    }
}

// 自定义异常类
public class CustomException extends RuntimeException {
    public CustomException(String message) {
        super(message);
    }
}

9. @Pointcut 单独定义切点，其他Advice直接引用

@Aspect
@Component
public class LoggingAspect {
    // 定义切点，表示对哪些类的哪些方法进行拦截
    // execution表达式指定了方法签名
    // 第一个"*"表示任意返回类型，第二个"*"表示类中的任意方法
    // ".."表示任意参数
    // 这里的例子表示拦截UserService中的所有方法
    @Pointcut("execution(* com.example.service.UserService.*(..))")
    private void service() {

    }
    @Before("service()")
    public void logBeforeMethodExecution(JoinPoint joinPoint) {
        System.out.println("Before executing method: " + joinPoint.getSignature().getName());
    }
    
}