Springboot注解@Aspect（一）之@Aspect 作用和Aop关系详解

@Aspect的使用

配置

作用

通知相关的注解

例子

结果：

@Aspect作用和Spring Aop关系

示例

标签表达式

@Aspect的使用

配置

要启用 Spring AOP 和 @Aspect 注解，需要在 Spring 配置中启用 AspectJ 自动代理，但是在 Spring Boot 中，通常不需要显式地添加 @EnableAspectJAutoProxy，因为 Spring Boot 的自动配置特性已经包含了这一设置。：

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // ...
}

@Aspect 注解也要写@Component，或通过其他方式注册为 Spring Bean，以确保 Spring 容器能够识别并管理这个切面。

@Aspect
@Component
public class LoggingAspect {
}

作用

定义切面（Aspect）：
切面是跨多个类或对象的横切关注点的模块化。在 Spring AOP 中，切面是通过使用 @Aspect 注解的类来表示的。
切入点（Pointcut）：
使用 @Pointcut 注解来定义切入点表达式，指定切面应用的位置。切入点定义了切面应该在何处插入其横切逻辑，即切面应该应用的连接点（如方法执行）的集合。
通知（Advice）：

前置通知（Before advice）：在某连接点（方法执行等）之前执行，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）。
后置通知（After advice）：在某连接点之后执行，无论该连接点是正常完成还是抛出异常。
返回后通知（After-returning advice）：在某连接点正常完成后执行。
抛出异常后通知（After-throwing advice）：如果方法抛出异常退出，则执行通知。
环绕通知（Around advice）：在方法调用之前和之后执行，它将决定是否继续执行连接点或直接返回自己的返回值或抛出异常。

通知相关的注解

@Around：环绕增强: 就是既可以前置增强，也可以后置增强。环绕通知会影响到AfterThrowing通知的运行,不要同时使用。
@Before：标识一个前置增强方法，
@AfterReturning：后置增强，如无返回结果，此注解不会执行
@After:final增强，不管是抛出异常或者正常退出都会执行
@AfterThrowing：异常抛出增强

例子

假设我们有一个服务类 SampleService，我们想在其方法执行的不同阶段添加日志。

public class SampleService {
    public void performAction() {
        System.out.println("Performing action in SampleService");
    }
}

现在，我们定义一个切面 LoggingAspect 来添加日志：

@Aspect
@Component
public class LoggingAspect {

    // 前置通知：在方法执行之前执行
    @Before("execution(* SampleService.performAction(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Before executing: " + joinPoint.getSignature().getName());
    }

    // 后置通知：在方法执行之后执行（无论是否发生异常）
    @After("execution(* SampleService.performAction(..))")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("After executing: " + joinPoint.getSignature().getName());
    }

    // 返回后通知：在方法成功执行之后执行
    @AfterReturning("execution(* SampleService.performAction(..))")
    public void logAfterReturning(JoinPoint joinPoint) {
        System.out.println("After returning from: " + joinPoint.getSignature().getName());
    }

    // 异常后通知：在方法抛出异常后执行
    @AfterThrowing(pointcut = "execution(* SampleService.performAction(..))", throwing = "ex")
    public void logAfterThrowing(JoinPoint joinPoint, Throwable ex) {
        System.out.println("After throwing in: " + joinPoint.getSignature().getName() + ", Exception: " + ex);
    }

    // 环绕通知：在方法执行之前和之后执行
    @Around("execution(* SampleService.performAction(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Around before: " + joinPoint.getSignature().getName());
        Object result = joinPoint.proceed(); // 继续执行方法
        System.out.println("Around after: " + joinPoint.getSignature().getName());
        return result;
    }
}

结果：

就@Before来说，只要performAction方法被调用，那么第一步就是先执行这段代码：System.out.println("Before executing: " + joinPoint.getSignature().getName());执行完后在执行performAction方法。其他方法也是如此只是触发时机不同罢了。

@Aspect作用和Spring Aop关系

@Aspect 是 AspectJ 框架中的一个注解，它是面向切面编程（AOP）的一个关键部分。AspectJ 是一个独立的 AOP 框架，而 Spring 框架（包括 Spring Boot）则集成了 AspectJ 的一部分功能，使得开发者可以在 Spring 应用中方便地使用 AOP。

AOP 是一种编程范式（软件工程中的一类典型的编程风格。），用于增加程序的模块化，通过将横切关注点（如日志、安全、事务管理等）从业务逻辑中分离出来，提高代码的可重用性和可维护性。说白了其实我感觉就是动态代理，可以为相关方法前后等统一进行一些处理。

Spring Boot 作为 Spring 框架的一个扩展，继承了 Spring 的 AOP 功能。在 Spring Boot 应用中，AOP 使用代理模式来实现 AOP，其中 @Aspect 注解的类被当作一个带有通知（Advice）和切入点（Pointcut）的切面。

Spring AOP 使用代理模式来拦截对对象的方法调用。当在 Spring 应用中定义了 AOP 切面时，Spring 容器会为匹配切面指定的切入点的 Bean 创建一个代理对象。这个代理对象在调用原始方法之前或之后执行切面中定义的逻辑。

动态代理：如果一个 Bean 至少实现了一个接口，Spring AOP 默认会使用 JDK 的动态代理来创建这个 Bean 的代理。
CGLIB 代理：如果一个 Bean 没有实现任何接口，Spring AOP 会使用 CGLIB 库来创建代理。

虽然使用 @Aspect 注解和 @Before、@After 等注解定义了切面的行为，但这些注解本身并不负责拦截方法调用。真正的方法拦截是由 Spring AOP 在背后通过动态代理机制来实现的。当方法被调用时，实际上是先调用代理对象的对应方法，代理对象再根据 AOP 配置来决定是否调用原始对象的方法，以及在调用前后执行哪些额外的逻辑。

示例

假设有一个简单的服务类 MyService，我们想在其 performAction 方法执行前后添加日志：

public class MyService {
    public void performAction() {
        System.out.println("Performing action");
    }
}

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* MyService.performAction(..))")
    public void logBefore() {
        System.out.println("Before action");
    }

    @After("execution(* MyService.performAction(..))")
    public void logAfter() {
        System.out.println("After action");
    }
}

在这里，LoggingAspect 定义了在 MyService 的 performAction 方法执行前后要执行的日志操作。但实际上，当 performAction 方法被调用时，它是通过 MyService 的代理来调用的，代理负责根据 LoggingAspect 的配置执行相应的 AOP 逻辑。

发现通知参数中的joinPoint不知道做什么用，请看我的下一章 Springboot注解@Aspect（二）JoinPoint 使用详解