如何使用AspectJ控制切面执行顺序和阻止后续切面执行

在基于Spring的项目开发中，AspectJ是实现面向切面编程的常用工具，当项目中存在多个切面时，切面的执行顺序往往会影响业务逻辑的正确性，同时在某些场景下我们还需要根据条件阻止后续切面的执行，避免不必要的逻辑处理。

AspectJ控制切面执行顺序的方法

方法一：使用@Order注解指定顺序

@Order注解是Spring提供的用于控制组件执行顺序的注解，也可以直接用在AspectJ的切面类上，注解中的值越小，切面的优先级越高，越先执行。

示例代码如下：

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

// 优先级最高的切面，Order值为1
@Aspect
@Component
@Order(1)
public class FirstAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object aroundFirst(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("第一个切面前置逻辑");
        Object result = joinPoint.proceed();
        System.out.println("第一个切面后置逻辑");
        return result;
    }
}

// 优先级次之的切面，Order值为2
@Aspect
@Component
@Order(2)
public class SecondAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object aroundSecond(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("第二个切面前置逻辑");
        Object result = joinPoint.proceed();
        System.out.println("第二个切面后置逻辑");
        return result;
    }
}

上述代码中，FirstAspect的Order值为1，SecondAspect的Order值为2，所以执行目标方法时，会先执行FirstAspect的前置逻辑，再执行SecondAspect的前置逻辑，目标方法执行完成后，先执行SecondAspect的后置逻辑，再执行FirstAspect的后置逻辑。

方法二：实现Ordered接口指定顺序

除了使用@Order注解，切面类还可以实现Spring的Ordered接口，重写getOrder方法返回顺序值，效果和使用@Order注解一致。

示例代码如下：

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

@Aspect
@Component
public class ThirdAspect implements Ordered {

    @Override
    public int getOrder() {
        // 返回顺序值，值越小优先级越高
        return 3;
    }

    @Around("execution(* com.example.service.*.*(..))")
    public Object aroundThird(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("第三个切面前置逻辑");
        Object result = joinPoint.proceed();
        System.out.println("第三个切面后置逻辑");
        return result;
    }
}

阻止后续切面执行的实现方式

方式一：不调用ProceedingJoinPoint的proceed方法

在Around通知中，如果不调用joinPoint.proceed()方法，那么目标方法以及后续切面的逻辑都不会执行，这是最直接的阻止后续切面执行的方式。

示例代码如下：

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

@Aspect
@Component
@Order(1)
public class StopAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 满足特定条件时不执行后续逻辑
        String methodName = joinPoint.getSignature().getName();
        if ("testMethod".equals(methodName)) {
            System.out.println("满足条件，阻止后续切面执行");
            // 不调用proceed方法，后续切面和目标方法都不会执行
            return null;
        }
        // 不满足条件时正常执行后续逻辑
        return joinPoint.proceed();
    }
}

方式二：抛出异常中断执行流程

在切面逻辑中抛出异常，如果没有被捕获，那么后续切面的逻辑和目标方法都不会执行，也可以通过自定义异常的方式实现中断。

示例代码如下：

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

@Aspect
@Component
@Order(1)
public class ExceptionStopAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        if ("errorMethod".equals(methodName)) {
            System.out.println("方法存在异常风险，抛出异常阻止后续执行");
            throw new RuntimeException("方法执行被拦截");
        }
        return joinPoint.proceed();
    }
}

方式三：通过上下文状态控制执行

可以将执行状态存储在ThreadLocal中，后续切面读取状态判断是否需要执行逻辑，这种方式不会直接中断流程，但是可以让后续切面跳过核心逻辑。

示例代码如下：

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

@Aspect
@Component
@Order(1)
public class ContextStopAspect {

    private static final ThreadLocal<Boolean> STOP_FLAG = ThreadLocal.withInitial(() -> false);

    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        if ("skipMethod".equals(methodName)) {
            System.out.println("设置跳过标志，后续切面不执行核心逻辑");
            STOP_FLAG.set(true);
            return joinPoint.proceed();
        }
        return joinPoint.proceed();
    }

    // 获取跳过标志的方法，供其他切面调用
    public static boolean isStop() {
        return STOP_FLAG.get();
    }
}

@Aspect
@Component
@Order(2)
public class FollowAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        if (ContextStopAspect.isStop()) {
            System.out.println("检测到跳过标志，不执行当前切面核心逻辑");
            return null;
        }
        System.out.println("第二个切面正常执行逻辑");
        return joinPoint.proceed();
    }
}

注意事项

• 使用@Order注解或Ordered接口时，同一个切面类上不要同时两种方式，避免顺序冲突。
• 不调用proceed方法时，需要根据业务场景返回合适的默认值，避免调用方出现空指针异常。
• 使用异常中断流程时，需要考虑异常是否会被全局异常处理器捕获，避免影响正常的异常提示。
• ThreadLocal存储的状态需要在执行完成后及时清理，避免内存泄漏和线程复用导致的状态混乱。

AspectJ切面执行顺序切面拦截spring_aop修改时间：2026-06-30 04:51:20