多线程AOP去获取设置获取参数如何做

Question

AOP管理多线程事物有什么思路吗？

目前想法时通过2个注解来注释主方法，和子方法。在用AOP来处理事物逻辑

    @ManTransaction()
    public void syncAnnotation(){

    }
    
    @SonTransaction()
    public void syncAnnotation2(){}

但是遇到问题我需要在@ManTransaction注释的方法通过AOP设置3个变量。且需要在@SonTransaction()注释的方法中能取到这3个变量

```java
    private CountDownLatch manLatch;
    private CountDownLatch souLatch;
    private AtomicBoolean rollback;

    @Around("@annotation(com.example.mybaitsplus.aop.ManTransaction)")
    public Object man(ProceedingJoinPoint joinPoint) throws Throwable {
// 在此处设置3个变量 
        return  null;
    }

    @Around("@annotation(com.example.mybaitsplus.aop.SonTransaction)")
    public Object sou(ProceedingJoinPoint joinPoint) throws Throwable {
// 这里需要能取到主任务设置的变量操作
        return  null;
    }

Answer 1

引用 皆我百晓生 小程序回复内容作答：
在使用AOP管理多线程事务时，你可以通过以下思路来实现：

1. 定义两个注解：@ManTransaction和@SonTransaction，分别用于注释主方法和子方法。

2. 在@ManTransaction注解的方法中，通过AOP设置三个变量。你可以使用ThreadLocal来保存这些变量，确保每个线程都能独立访问自己的变量。

3. 在@SonTransaction注解的方法中，通过AOP获取主任务设置的变量。你可以通过ThreadLocal来获取主任务线程设置的变量。

下面是一个示例代码：

public class TransactionContextHolder {
    private static ThreadLocal<CountDownLatch> manLatchThreadLocal = new ThreadLocal<>();
    private static ThreadLocal<CountDownLatch> sonLatchThreadLocal = new ThreadLocal<>();
    private static ThreadLocal<AtomicBoolean> rollbackThreadLocal = new ThreadLocal<>();

    public static void setManLatch(CountDownLatch latch) {
        manLatchThreadLocal.set(latch);
    }

    public static CountDownLatch getManLatch() {
        return manLatchThreadLocal.get();
    }

    public static void setSonLatch(CountDownLatch latch) {
        sonLatchThreadLocal.set(latch);
    }

    public static CountDownLatch getSonLatch() {
        return sonLatchThreadLocal.get();
    }

    public static void setRollback(AtomicBoolean rollback) {
        rollbackThreadLocal.set(rollback);
    }

    public static AtomicBoolean getRollback() {
        return rollbackThreadLocal.get();
    }
}

@Aspect
@Component
public class TransactionAspect {
    @Around('@annotation(com.example.mybaitsplus.aop.ManTransaction)')
    public Object man(ProceedingJoinPoint joinPoint) throws Throwable {
        // 在此处设置3个变量
        CountDownLatch manLatch = new CountDownLatch(1);
        CountDownLatch sonLatch = new CountDownLatch(1);
        AtomicBoolean rollback = new AtomicBoolean(false);
        TransactionContextHolder.setManLatch(manLatch);
        TransactionContextHolder.setSonLatch(sonLatch);
        TransactionContextHolder.setRollback(rollback);

        try {
            // 执行主任务
            Object result = joinPoint.proceed();

            // 等待子任务完成
            sonLatch.await();

            // 判断是否需要回滚
            if (rollback.get()) {
                // 执行回滚操作
            } else {
                // 提交事务
            }

            return result;
        } finally {
            // 释放资源
            TransactionContextHolder.setManLatch(null);
            TransactionContextHolder.setSonLatch(null);
            TransactionContextHolder.setRollback(null);
        }
    }

    @Around('@annotation(com.example.mybaitsplus.aop.SonTransaction)')
    public Object son(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取主任务设置的变量
        CountDownLatch manLatch = TransactionContextHolder.getManLatch();
        CountDownLatch sonLatch = TransactionContextHolder.getSonLatch();
        AtomicBoolean rollback = TransactionContextHolder.getRollback();

        try {
            // 执行子任务
            Object result = joinPoint.proceed();

            // 子任务完成
            sonLatch.countDown();

            return result;
        } catch (Exception e) {
            // 子任务出现异常，设置回滚标志
            rollback.set(true);
            throw e;
        }
    }
}

在上述代码中，TransactionContextHolder类使用ThreadLocal来保存三个变量。TransactionAspect类使用@Aspect注解来定义切面，通过@Around注解来拦截@ManTransaction和@SonTransaction注解的方法，并在方法执行前后进行处理。在@ManTransaction注解的方法中，设置三个变量，并在方法执行后根据需要进行事务提交或回滚。在@SonTransaction注解的方法中，获取主任务设置的变量，并在方法执行后通知主任务子任务已完成。

请注意，这只是一个示例代码，你可以根据实际需求进行修改和扩展。同时，确保在使用多线程和AOP时，考虑线程安全和事务一致性的问题。