AOP 概念 - 通知类型 - 前置、后置等通知

Java - Web - Spring 《AOP 概念 - 通知类型 - 前置、后置等通知》

一、AOP 概念引入

在软件开发中，我们常常会遇到一些与核心业务逻辑无关，但又贯穿于多个业务模块的功能，比如日志记录、事务管理、权限验证等。传统的编程方式会导致这些功能代码分散在各个业务方法中，造成代码的冗余和可维护性降低。AOP（Aspect-Oriented Programming，面向切面编程）应运而生，它可以将这些横切关注点（如日志、事务等）从业务逻辑中分离出来，以一种模块化的方式进行管理。

AOP 基本术语

切面（Aspect）：包含了多个通知和切入点的模块，它定义了横切关注点的行为。
通知（Advice）：切面中的具体执行代码，也就是在特定连接点上执行的操作。
连接点（Join Point）：程序执行过程中可以插入切面的点，如方法调用、异常抛出等。
切入点（Pointcut）：用于匹配连接点的表达式，指定了在哪些连接点上应用通知。
目标对象（Target）：被通知的对象，也就是包含核心业务逻辑的对象。
代理对象（Proxy）：通过 AOP 框架生成的对象，它包含了目标对象的功能和切面的功能。

二、通知类型

Spring AOP 提供了多种通知类型，每种通知类型在不同的时机执行。下面我们详细介绍几种常见的通知类型。

1. 前置通知（Before Advice）

前置通知在目标方法执行之前执行，通常用于进行一些预处理操作，如权限验证、参数检查等。

2. 后置通知（After Advice）

后置通知在目标方法执行之后执行，无论目标方法是否抛出异常都会执行，常用于资源清理等操作。

3. 返回通知（After Returning Advice）

返回通知在目标方法正常返回后执行，它可以访问目标方法的返回值。

4. 异常通知（After Throwing Advice）

异常通知在目标方法抛出异常时执行，常用于记录异常信息等操作。

5. 环绕通知（Around Advice）

环绕通知是最强大的通知类型，它可以在目标方法执行前后都进行操作，甚至可以决定是否执行目标方法。

三、演示代码

1. 创建 Maven 项目并添加依赖

在 pom.xml 中添加 Spring AOP 相关依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.23</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.3.23</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.7</version>
    </dependency>
</dependencies>

2. 创建目标对象

创建一个简单的业务类 UserService：

package com.example.demo.service;
public class UserService {
    public String addUser(String username) {
        System.out.println("Adding user: " + username);
        return "User added successfully";
    }
}

3. 创建切面类

创建一个切面类 LoggingAspect，包含各种通知类型：

package com.example.demo.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class LoggingAspect {
    // 前置通知
    @Before("execution(* com.example.demo.service.UserService.addUser(..))")
    public void beforeAdvice(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }
    // 后置通知
    @After("execution(* com.example.demo.service.UserService.addUser(..))")
    public void afterAdvice(JoinPoint joinPoint) {
        System.out.println("After method: " + joinPoint.getSignature().getName());
    }
    // 返回通知
    @AfterReturning(pointcut = "execution(* com.example.demo.service.UserService.addUser(..))", returning = "result")
    public void afterReturningAdvice(JoinPoint joinPoint, Object result) {
        System.out.println("Method returned: " + result);
    }
    // 异常通知
    @AfterThrowing(pointcut = "execution(* com.example.demo.service.UserService.addUser(..))", throwing = "ex")
    public void afterThrowingAdvice(JoinPoint joinPoint, Exception ex) {
        System.out.println("Method threw exception: " + ex.getMessage());
    }
    // 环绕通知
    @Around("execution(* com.example.demo.service.UserService.addUser(..))")
    public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Around advice before method");
        Object result = joinPoint.proceed();
        System.out.println("Around advice after method");
        return result;
    }
}

4. 创建 Spring 配置类

package com.example.demo.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration
@ComponentScan(basePackages = "com.example.demo")
@EnableAspectJAutoProxy
public class AppConfig {
}

5. 测试代码

package com.example.demo;
import com.example.demo.config.AppConfig;
import com.example.demo.service.UserService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = context.getBean(UserService.class);
        String result = userService.addUser("John");
        System.out.println("Final result: " + result);
        context.close();
    }
}

代码解释

LoggingAspect 类使用 @Aspect 注解标记为切面类，@Component 注解将其注册为 Spring 组件。
@Before、@After、@AfterReturning、@AfterThrowing 和 @Around 注解分别定义了前置通知、后置通知、返回通知、异常通知和环绕通知。
execution(* com.example.demo.service.UserService.addUser(..)) 是切入点表达式，表示匹配 UserService 类的 addUser 方法。

四、运行结果

运行 Main 类，输出结果如下：

Around advice before method
Before method: addUser
Adding user: John
Around advice after method
After method: addUser
Method returned: User added successfully
Final result: User added successfully

从输出结果可以看出，各种通知类型按照预期的顺序执行。环绕通知在目标方法执行前后都有输出，前置通知在目标方法执行前输出，后置通知在目标方法执行后输出，返回通知在目标方法正常返回后输出。

通过本文的介绍和示例代码，你应该对 Spring AOP 的通知类型有了更深入的理解。AOP 可以帮助我们将横切关注点从业务逻辑中分离出来，提高代码的可维护性和可复用性。