【Spring Framework】Spring AOP 面相切面编程

Spring AOP（Aspect-Oriented Programming，面向切面编程）是 Spring 框架的重要组成部分之一，它通过在不修改业务逻辑代码的情况下提供横切关注点的处理能力，使得代码更加简洁、模块化和易于维护。AOP 可以用来处理常见的功能，如日志记录、事务管理、权限控制等。

一、Spring AOP 的基本概念

在 Spring AOP 中，以下是一些关键概念：

切面（Aspect）：模块化的横切关注点，例如日志记录、事务管理等。切面可以用类来实现，并使用 @Aspect 注解标记。
通知（Advice）：切面在特定连接点执行的动作（方法）。Spring AOP 支持以下几种类型的通知：
- 前置通知（Before Advice）：在目标方法执行之前执行。
- 后置通知（After Advice）：在目标方法执行之后执行。
- 返回通知（After Returning Advice）：在目标方法正常返回后执行。
- 异常通知（After Throwing Advice）：在目标方法抛出异常时执行。
- 环绕通知（Around Advice）：在目标方法执行之前和之后都执行，可以控制方法的执行。
连接点（Joinpoint）：程序执行的某个特定点，如方法调用或异常抛出。Spring AOP 只支持方法连接点。
切点（Pointcut）：一组连接点的集合，通过表达式来定义这些连接点。切点定义了通知应该在何时何地执行。
目标对象（Target Object）：被通知的对象，也就是实际的业务逻辑类。
代理（Proxy）：AOP 框架创建的对象，包含目标对象的功能和增强的功能。Spring AOP 使用 JDK 动态代理或 CGLIB 代理来实现。
织入（Weaving）：将切面与目标对象连接的过程。Spring AOP 是在运行时织入的。

Spring AOP 的优点

解耦业务逻辑和横切关注点：通过 AOP，将日志、事务等横切关注点从业务逻辑中分离出来，提高代码的可读性和可维护性。
提高代码复用性：将通用的逻辑提取到切面中，避免在多个地方重复相同的代码。
降低代码耦合度：业务逻辑和切面是相互独立的，修改切面不会影响业务逻辑。

二、Spring AOP 注解

Spring AOP 提供了一组注解用于定义切面、切点和通知：

@Aspect：用于定义一个类为切面类。
@Before：用于定义前置通知。
@After：用于定义后置通知。
@AfterReturning：用于定义返回通知。
@AfterThrowing：用于定义异常通知。
@Around：用于定义环绕通知。
@Pointcut：用于定义切点表达式。

切点表达式的语法

切点表达式用于匹配连接点，以下是常用的切点表达式语法：

execution(* com.example.service.*.*(..))：匹配 com.example.service 包下的所有方法。
within(com.example.service..*)：匹配 com.example.service 包及其子包下的所有方法。
@annotation(org.springframework.transaction.annotation.Transactional)：匹配所有被 @Transactional 注解的方法。
this(com.example.service.UserService)：匹配当前代理对象是 UserService 的所有方法。
target(com.example.service.UserService)：匹配目标对象是 UserService 的所有方法。

三、Spring AOP 的使用

下面是一个使用 Spring AOP 注解的完整示例。

3.1 项目结构

src└── main├── java│   └── com│       └── example│           ├── aspect│           │   └── LoggingAspect.java│           ├── service│           │   ├── UserService.java│           │   └── UserServiceImpl.java│           └── MainApp.java└── resources└── applicationContext.xml

3.2 添加依赖

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

<dependencies><!-- Spring Core --><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>5.3.9</version></dependency><!-- Spring AOP --><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>5.3.9</version></dependency><!-- AspectJ --><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.6</version></dependency><!-- Spring Context --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.9</version></dependency><!-- Spring Context Support --><dependency><groupId>org.springframework</groupId><artifactId>spring-context-support</artifactId><version>5.3.9</version></dependency><!-- Log4j for logging --><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-core</artifactId><version>2.17.1</version></dependency><dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-api</artifactId><version>2.17.1</version></dependency>
</dependencies>

3.3 定义业务逻辑类

UserService 接口

定义一个简单的用户服务接口 UserService：

package com.example.service;public interface UserService {void addUser(String name);void deleteUser(String name);String findUser(String name);
}

UserServiceImpl 实现类

实现接口的具体类 UserServiceImpl：

package com.example.service;import org.springframework.stereotype.Service;@Service
public class UserServiceImpl implements UserService {@Overridepublic void addUser(String name) {System.out.println("Adding user: " + name);}@Overridepublic void deleteUser(String name) {System.out.println("Deleting user: " + name);}@Overridepublic String findUser(String name) {return "User found: " + name;}
}

3.4 定义切面类

LoggingAspect 切面

定义一个切面类 LoggingAspect，用于在方法执行之前和之后记录日志：

package com.example.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 {// 定义切点，匹配com.example.service包及其子包下的所有方法@Pointcut("execution(* com.example.service..*(..))")public void serviceLayer() {}// 前置通知，在目标方法执行之前执行@Before("serviceLayer()")public void beforeAdvice(JoinPoint joinPoint) {System.out.println("Before method: " + joinPoint.getSignature().toShortString());}// 后置通知，在目标方法执行之后执行@After("serviceLayer()")public void afterAdvice(JoinPoint joinPoint) {System.out.println("After method: " + joinPoint.getSignature().toShortString());}// 返回通知，在目标方法正常返回后执行@AfterReturning(pointcut = "serviceLayer()", returning = "result")public void afterReturningAdvice(JoinPoint joinPoint, Object result) {System.out.println("After returning method: " + joinPoint.getSignature().toShortString() + " with result: " + result);}// 异常通知，在目标方法抛出异常时执行@AfterThrowing(pointcut = "serviceLayer()", throwing = "exception")public void afterThrowingAdvice(JoinPoint joinPoint, Throwable exception) {System.out.println("After throwing method: " + joinPoint.getSignature().toShortString() + " with exception: " + exception);}// 环绕通知，在目标方法执行之前和之后执行@Around("serviceLayer()")public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {System.out.println("Around before method: " + proceedingJoinPoint.getSignature().toShortString());Object result = proceedingJoinPoint.proceed();  // 调用目标方法System.out.println("Around after method: " + proceedingJoinPoint.getSignature().toShortString());return result;}
}

3.5 Spring 配置

Java 配置类

使用 Java 配置类启用 AOP 功能：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;@Configuration
@ComponentScan(basePackages = "com.example")
@EnableAspectJAutoProxy
public class AppConfig {// 可以选择在这里定义Bean
}

XML 配置

也可以通过 XML 配置启用 AOP 功能：

<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!-- 开启AOP支持 --><aop:aspectj-autoproxy/><!-- 扫描包，自动注册Bean --><context:component-scan base-package="com.example"/><!-- 注册切面Bean --><bean id="loggingAspect" class="com.example.aspect.LoggingAspect"/>
</beans>

3.6 测试 AOP

MainApp 类

创建一个测试类 MainApp 来测试 AOP 功能：

package com.example;import com.example.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class MainApp {public static void main(String[] args) {ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);UserService userService = context.getBean(UserService.class);userService.addUser("Alice");userService.deleteUser("Bob");System.out.println(userService.findUser("Charlie"));}
}

输出结果

Before method: UserService.addUser(..)
Adding user: Alice
After method: UserService.addUser(..)
Around before method: UserService.deleteUser(..)
Deleting user: Bob
Around after method: UserService.deleteUser(..)
Before method: UserService.findUser(..)
After returning method: UserService.findUser(..) with result: User found: Charlie
User found: Charlie