CompletableFuture封装异步回滚事务

• 封装CompletableFutureUtil类

package com.rjyx.hdis.utils;

import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;

@Component
public class CompletableFutureUtil {

    private final PlatformTransactionManager transactionManager;

    public CompletableFutureUtil(PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    /**
     * 封装一个支持事务且无返回值的 CompletableFuture 任务
     *
     * @param task  业务逻辑代码
     * @return CompletableFuture<T> 异步任务
     */
    public CompletableFuture<Void> runAsync(Runnable task) {
        return CompletableFuture.runAsync(() -> {
            DefaultTransactionDefinition def = new DefaultTransactionDefinition();
            // 开启新事务
            def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
            // 获取事务状态
            TransactionStatus status = transactionManager.getTransaction(def);
            try {
                // 执行任务
                task.run();
                // 提交事务
                transactionManager.commit(status);
            } catch (Exception e) {
                // 回滚事务并抛出异常
                transactionManager.rollback(status);
                throw new RuntimeException(e);
            }
        });
    }

    /**
     * 封装一个支持事务且有返回值的 CompletableFuture 任务
     *
     * @param task  业务逻辑代码
     * @param <T>   返回值类型
     * @return CompletableFuture<T> 异步任务
     */
    public <T> CompletableFuture<T> runAsync(Supplier<T> task) {
        return CompletableFuture.supplyAsync(() -> {
            DefaultTransactionDefinition def = new DefaultTransactionDefinition();
            // 开启新事务
            def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
            // 获取事务状态
            TransactionStatus status = transactionManager.getTransaction(def);
            try {
                // 执行任务并返回结果
                T result = task.get();
                // 提交事务
                transactionManager.commit(status);
                return result;
            } catch (Exception e) {
                // 回滚事务并抛出异常
                transactionManager.rollback(status);
                throw new RuntimeException(e);
            }
        });
    }
}

• 示例

	@Autowired
    private CompletableFutureUtil completableFutureUtil;
    
	@Transactional(rollbackFor = Exception.class)
    public void completableFutureDispose() {
        try {
            CompletableFuture<String> cf1 = completableFutureUtil.runAsync(() ->
               //代码片段
            );
            CompletableFuture<String> cf2 = completableFutureUtil.runAsync(() ->
                //代码片段
            );
            CompletableFuture<String> cf3 = completableFutureUtil.runAsync(() ->
               //代码片段
            );
            CompletableFuture<String> cf4 = completableFutureUtil.runAsync(() ->
                //代码片段
            );
            // 等待所有任务完成
            CompletableFuture.allOf(cf1, cf2, cf3, cf4);
            // 处理结果......
        } catch (Exception e) {
            logger.error("执行发生未知异常: {}", e.getMessage(), e);
            throw new RuntimeException("执行失败", e);
        }
    }