Spring 6.2.x中两个@Aspect如何通过共享数据实现协作？

在Spring 6.2.x中，当多个@Around切面作用于同一方法时，实现切面间信息传递可以采用以下几种实用方案。另外，你之前尝试的@DeclareParents引入特性确实不适合这种场景，它的设计目的是为目标对象动态添加接口实现，而非实现切面间的上下文传递，属于误用，放弃这个方向是正确的。

1. ThreadLocal上下文Bean（推荐） #

你提到的ThreadLocal方案其实是切面间传递上下文的标准做法，只要做好资源清理就不会有问题。可以封装一个独立的Spring Bean来管理ThreadLocal状态，避免直接在切面中写ThreadLocal逻辑，提升可维护性。

实现步骤： #

• 定义上下文Bean，封装ThreadLocal：

@Component
public class AspectContextHolder {
    private final ThreadLocal<FooAspectContext> fooContext = new ThreadLocal<>();

    public void setFooContext(FooAspectContext context) {
        fooContext.set(context);
    }

    public FooAspectContext getFooContext() {
        return fooContext.get();
    }

    public void clear() {
        fooContext.remove();
    }

    // 自定义上下文类，存储需要传递的信息
    public static class FooAspectContext {
        private String detail;
        // 其他需要传递的字段、构造器、getter/setter
        public FooAspectContext(String detail) {
            this.detail = detail;
        }

        public String getDetail() {
            return detail;
        }
    }
}

• 在FooAspect中注入上下文Bean，设置上下文信息：

@Aspect
public class FooAspect {
    private final AspectContextHolder contextHolder;

    // 构造注入
    public FooAspect(AspectContextHolder contextHolder) {
        this.contextHolder = contextHolder;
    }

    @Around("@annotation(foo)")
    public Object aroundFoo(ProceedingJoinPoint joinPoint, Foo foo) throws Throwable {
        try {
            // 记录Foo切面的特定信息到上下文
            String specificDetail = "根据Foo注解生成的细节";
            contextHolder.setFooContext(new AspectContextHolder.FooAspectContext(specificDetail));
            return joinPoint.proceed();
        } finally {
            // 确保上下文被清除，避免内存泄漏
            contextHolder.clear();
        }
    }
}

• 在ScheduledMethodLogger中读取上下文信息：

@Aspect
@Slf4j
public class ScheduledMethodLogger {
    private final AspectContextHolder contextHolder;

    public ScheduledMethodLogger(AspectContextHolder contextHolder) {
        this.contextHolder = contextHolder;
    }

    @Around("@annotation(annotation)")
    public Object aroundScheduledRun(ProceedingJoinPoint joinPoint, Scheduled annotation) throws Throwable {
        AspectContextHolder.FooAspectContext fooContext = contextHolder.getFooContext();
        String signature = joinPoint.getSignature().toString();
        try {
            if (fooContext != null) {
                log.debug("Starting {} with Foo detail: {}", signature, fooContext.getDetail());
            } else {
                log.debug("Starting {}", signature);
            }
            return joinPoint.proceed();
        } finally {
            if (fooContext != null) {
                log.debug("Completed {} with Foo detail: {}", signature, fooContext.getDetail());
            } else {
                log.debug("Completed {}", signature);
            }
        }
    }
}

注意事项： #

• 必须在finally块中清除ThreadLocal，避免线程池复用导致的上下文泄漏。
• 如果定时任务使用Spring的异步线程池，ThreadLocal会绑定到当前任务线程，不会互相干扰。

2. 利用JoinPoint传递自定义上下文对象 #

如果方法允许修改参数（或者可以通过包装参数传递），可以在FooAspect中把上下文信息放到JoinPoint的参数里，让ScheduledMethodLogger读取。这种方式不需要ThreadLocal，但仅适用于可以修改目标方法参数的场景。

示例： #

// FooAspect中修改proceed的参数
@Around("@annotation(foo)")
public Object aroundFoo(ProceedingJoinPoint joinPoint, Foo foo) throws Throwable {
    FooAspectContext context = new FooAspectContext("Foo细节");
    // 包装原参数，加入上下文对象
    Object[] newArgs = Arrays.copyOf(joinPoint.getArgs(), joinPoint.getArgs().length + 1);
    newArgs[newArgs.length - 1] = context;
    try {
        return joinPoint.proceed(newArgs);
    } finally {
        // 不需要清理，因为参数是单次请求的
    }
}

// ScheduledMethodLogger中读取参数里的上下文
@Around("@annotation(annotation)")
public Object aroundScheduledRun(ProceedingJoinPoint joinPoint, Scheduled annotation) throws Throwable {
    FooAspectContext fooContext = null;
    for (Object arg : joinPoint.getArgs()) {
        if (arg instanceof FooAspectContext) {
            fooContext = (FooAspectContext) arg;
            break;
        }
    }
    // 后续日志逻辑同前
    return joinPoint.proceed();
}

优缺点： #

• 优点：无ThreadLocal泄漏风险，实现简单。
• 缺点：需要修改目标方法的参数列表（或者参数需要支持动态添加），通用性较差，不适用于无法修改目标方法的场景。

3. 基于切面优先级的共享状态（仅适用于同步执行） #

如果切面的执行顺序是确定的（可以通过@Order注解指定优先级），可以在一个共享的请求作用域Bean中存储上下文信息。不过这种方式仅适用于同步执行的方法，定时任务如果是异步的话，请求作用域Bean可能不适用。

示例： #

• 定义请求作用域的上下文Bean：

@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestScopeAspectContext {
    private String fooDetail;
    // getter/setter
    public String getFooDetail() {
        return fooDetail;
    }

    public void setFooDetail(String fooDetail) {
        this.fooDetail = fooDetail;
    }
}

• 指定切面顺序：

@Aspect
@Order(1) // FooAspect先执行
public class FooAspect {
    private final RequestScopeAspectContext context;

    public FooAspect(RequestScopeAspectContext context) {
        this.context = context;
    }

    @Around("@annotation(foo)")
    public Object aroundFoo(ProceedingJoinPoint joinPoint, Foo foo) throws Throwable {
        context.setFooDetail("Foo细节");
        try {
            return joinPoint.proceed();
        } finally {
            context.setFooDetail(null);
        }
    }
}

@Aspect
@Order(2) // ScheduledMethodLogger后执行
public class ScheduledMethodLogger {
    private final RequestScopeAspectContext context;

    public ScheduledMethodLogger(RequestScopeAspectContext context) {
        this.context = context;
    }

    @Around("@annotation(annotation)")
    public Object aroundScheduledRun(ProceedingJoinPoint joinPoint, Scheduled annotation) throws Throwable {
        String fooDetail = context.getFooDetail();
        String signature = joinPoint.getSignature().toString();
        try {
            if (fooDetail != null) {
                log.debug("Starting {} with Foo detail: {}", signature, fooDetail);
            } else {
                log.debug("Starting {}", signature);
            }
            return joinPoint.proceed();
        } finally {
            if (fooDetail != null) {
                log.debug("Completed {} with Foo detail: {}", signature, fooDetail);
            } else {
                log.debug("Completed {}", signature);
            }
        }
    }
}

注意事项： #

• 仅适用于同步请求或非异步的定时任务，异步场景下请求作用域Bean会失效。
• 需要确保切面的执行顺序正确，否则无法获取到上下文信息。

4. 利用Spring的RequestAttributes（Web场景） #

如果是Web环境下的定时任务（或者方法处于Web请求上下文），可以使用RequestContextHolder来存储上下文信息。不过定时任务通常不在Web请求上下文内，所以这个方案局限性较大，仅适用于Web请求触发的定时任务。

示例： #

// FooAspect中设置属性
@Around("@annotation(foo)")
public Object aroundFoo(ProceedingJoinPoint joinPoint, Foo foo) throws Throwable {
    RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
    if (attributes != null) {
        attributes.setAttribute("foo_detail", "Foo细节", RequestAttributes.SCOPE_REQUEST);
    }
    try {
        return joinPoint.proceed();
    } finally {
        if (attributes != null) {
            attributes.removeAttribute("foo_detail", RequestAttributes.SCOPE_REQUEST);
        }
    }
}

// ScheduledMethodLogger中读取属性
@Around("@annotation(annotation)")
public Object aroundScheduledRun(ProceedingJoinPoint joinPoint, Scheduled annotation) throws Throwable {
    RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
    String fooDetail = null;
    if (attributes != null) {
        fooDetail = (String) attributes.getAttribute("foo_detail", RequestAttributes.SCOPE_REQUEST);
    }
    // 日志逻辑同前
    return joinPoint.proceed();
}

内容的提问来源于stack exchange，提问作者E-Riz