springboot项目使用aop

步骤 1: 创建Spring Boot项目

首先，创建一个新的Spring Boot项目。你可以使用Spring Initializr（https://start.spring.io/）来快速初始化一个项目。

选择以下依赖：

• Spring Web
• Spring AOP

点击“Generate”下载项目的压缩包，并解压到你的工作目录。

步骤 2: 定义业务逻辑类

在src/main/java/com/example/demo目录下，创建一个新的Java类CalculatorService.java。这个类将提供基本的数学运算功能。

package com.example.demo;

import org.springframework.stereotype.Service;

@Service
public class CalculatorService {

    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }
}

步骤 3: 创建切面类

接下来，创建一个切面类CalculatorAspect.java。这个类将包含我们需要的横切关注点逻辑。

package com.example.demo;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class CalculatorAspect {

    @Around("execution(* com.example.demo.CalculatorService.*(..))")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        try {
            return joinPoint.proceed();
        } finally {
            long executionTime = System.currentTimeMillis() - start;
            System.out.println("Method " + joinPoint.getSignature().getName() +
                    " executed in " + executionTime + " ms");
        }
    }

    @Before("execution(* com.example.demo.CalculatorService.*(..))")
    public void logBeforeExecution() {
        System.out.println("Executing method...");
    }

    @AfterReturning(pointcut = "execution(* com.example.demo.CalculatorService.add(int, int))", returning = "result")
    public void logResult(Object result) {
        System.out.println("Addition result: " + result);
    }
}

步骤 4: 配置AOP

为了启用AOP，需要在Spring Boot的配置类上添加@EnableAspectJAutoProxy注解。

打开主类（通常是DemoApplication.java），添加以下内容：

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@SpringBootApplication
@EnableAspectJAutoProxy
public class DemoApplication {

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

步骤 5: 创建测试类

为了验证AOP是否生效，创建一个测试类CalculatorControllerTest.java。

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class CalculatorControllerTest {

    @Autowired
    private CalculatorService calculatorService;

    @Test
    public void testAdd() {
        int result = calculatorService.add(10, 5);
        System.out.println("Result of add: " + result);
    }

    @Test
    public void testSubtract() {
        int result = calculatorService.subtract(10, 5);
        System.out.println("Result of subtract: " + result);
    }
}

步骤 6: 运行测试

运行测试类中的方法，观察控制台输出。

你应该会看到类似以下的输出：

Executing method...
Method add executed in 123 ms
Result of add: 15
Addition result: 15

Executing method...
Method subtract executed in 45 ms
Result of subtract: 5

解释

• @Aspect: 标记这是一个切面类。
• @Component: 将这个切面类注册为Spring组件，使其能够被扫描到。
• @Around: 定义一个环绕通知，用于在目标方法执行前后添加逻辑。在这里，我们记录了方法的执行时间。
• @Before: 在目标方法执行前执行的通知。这里用于打印日志，表示即将执行某个方法。
• @AfterReturning: 方法成功返回后执行的通知。这里用于记录加法运算的结果。

总结

通过以上步骤，我们在Spring Boot项目中成功地实现了AOP功能。切面类中的各个通知在目标方法的不同生命周期阶段被触发，从而达到了横切关注点与业务逻辑分离的目的。这不仅提高了代码的可维护性，还使得日志记录、性能监控等功能更加轻松和高效。

如果你希望进一步探索，可以尝试添加更多的横切关注点（如事务管理），或者使用不同的通知类型来满足项目的需求。