Spring AOP 举例 2024年7月24日
后端开发
0 条评论

非原创、ChatGPT 问答生成

https://docs.spring.io/spring-boot/reference/features/aop.html

Spring AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，旨在通过分离横切关注点（cross-cutting concerns）来提高代码的模块化。常见的横切关注点包括日志记录、安全、事务管理等。在 Spring 中，AOP 的实现主要依赖于动态代理机制。

以下是一个简单的 Spring AOP 示例，演示如何使用 AOP 来记录方法执行的时间。

步骤 1：添加依赖

在使用 Spring AOP 之前，需要在项目的构建文件中添加 Spring AOP 的依赖。如果使用 Maven，可以在 pom.xml 文件中添加以下依赖：

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

如果使用 Gradle，可以在 build.gradle 文件中添加以下依赖：

implementation 'org.springframework.boot:spring-boot-starter-aop'

步骤 2：定义业务逻辑类

首先，定义一个简单的业务逻辑类，例如 UserService：

import org.springframework.stereotype.Service;

@Service
public class UserService {

    public void createUser(String username) {
        System.out.println("User " + username + " is created.");
    }
}

步骤 3：定义切面（Aspect）

接下来，定义一个切面类，用于记录方法的执行时间。使用 @Aspect 注解标记该类，并定义一个切点和通知：

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

@Aspect
@Component
public class LoggingAspect {

    @Around("execution(* com.example.demo.UserService.*(..))")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();

        Object proceed = joinPoint.proceed(); // 执行目标方法

        long executionTime = System.currentTimeMillis() - start;
        System.out.println(joinPoint.getSignature() + " executed in " + executionTime + "ms");

        return proceed;
    }
}

步骤 4：配置 Spring 应用

确保 Spring 能够扫描到你的切面类和业务逻辑类。可以在 Spring Boot 主应用类中使用 @SpringBootApplication 注解：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

步骤 5：测试 AOP 功能

编写一个简单的测试类或控制器来调用业务逻辑类的方法，验证 AOP 切面是否生效：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class TestRunner implements CommandLineRunner {

    @Autowired
    private UserService userService;

    @Override
    public void run(String... args) throws Exception {
        userService.createUser("John");
    }
}

运行应用程序后，你应该会在控制台上看到类似以下的输出：

User John is created.
void com.example.demo.UserService.createUser(String) executed in 10ms

详细解析

  1. 业务逻辑类（UserService）：这是一个普通的 Spring 服务类，包含一个 createUser 方法。
  2. 切面类（LoggingAspect）：
    • @Aspect：标记这个类为切面。
    • @Component：将这个类注册为 Spring 容器中的一个 Bean。
    • @Around("execution( com.example.demo.UserService.(..))")：定义一个环绕通知，切点是 UserService 类中的所有方法。
    • logExecutionTime 方法：记录方法的执行时间，并在方法执行前后打印日志。
  3. 主应用类（DemoApplication）：Spring Boot 的主类，用于启动应用。
  4. 测试类（TestRunner）：一个简单的测试类，用于触发 UserService 的方法，验证 AOP 功能。

这个示例展示了如何使用 Spring AOP 来实现方法执行时间的日志记录。通过这种方式，可以将日志记录这样的横切关注点从业务逻辑中分离出来，使代码更加清晰和可维护。