Springboot多线程事务回滚（改良版）

前段时间发过此类demo，后经大神改版，学到了一点，遂记录一下

    /**
     * 利用线程池起两个任务
     */
    public String thredSubmit(String uuidStr, List<VariationMapIn> mapIns, List<ApproveHis> hisList, String[] ids,
            Long guToJuPartyId) {
        SubmitToPer submitToPerTask = new SubmitToPer(uuidStr, hisList, mapIns,
                JtCommonUtil.getUserView().getPartyId());

        XianSubmit xianianSubmitTask = new XianSubmit(JtCommonUtil.getUserView().getOrganization().getGroupCode(),
                mapIns, JtCommonUtil.getUserView().getPartyId());

        String result = SynTaskUtils.doWork(Arrays.asList(submitToPerTask, xianianSubmitTask), transactionManager);
        return result;
    }

/**
 * 第一个任务
 */
public class SubmitToPer extends BaseCallBack {

    private String uuidStr;
    private List<ApproveHis> hisList;
    private List<VariationMapIn> mapIns;
    private Long partyId;

    public SubmitToPer(String uuidStr, List<ApproveHis> hisList, List<VariationMapIn> mapIns, Long partyId) {
        super();
        this.uuidStr = uuidStr;
        this.hisList = hisList;
        this.mapIns = mapIns;
        this.partyId = partyId;
    }

    @Override
    protected void doWork() {
        // 业务处理开始
        MapInDealService mapInDealService = (MapInDealService) ApplicationUtil.getBean("mapInDealService");
        mapInDealService.submitToPer(uuidStr, mapIns, hisList, partyId);
    }

}

/**
 * 第二个任务
 */
public class XianSubmit extends BaseCallBack {

    private String groupCode;
    private List<VariationMapIn> mapIns;
    private Long partyId;

    public XianSubmit(String groupCode, List<VariationMapIn> mapIns, Long partyId) {
        super();
        this.groupCode = groupCode;
        this.mapIns = mapIns;
        this.partyId = partyId;
    }

    @Override
    protected void doWork() {
        SpanCheckService spanCheckService = (SpanCheckService) ApplicationUtil.getBean("spanCheckService");
        String str = spanCheckService.xianCheckIn(mapIns, partyId, groupCode);
        if (!Constant.SUCCESS_STR.equals(str))
            throw new RuntimeException(str);
    }

}

/**
 * 带回滚的异步任务回调
 * 基类
 * @author Administrator
 *
 */
public abstract class BaseCallBack implements Callable<String> {

    private static Logger logger = LoggerFactory.getLogger(BaseCallBack.class);
    /**
     * 需要回滚计数器
     */
    protected CountDownLatch rollBackLatch;
    /**
     * 主线程等待计数器
     */
    protected CountDownLatch mainThreadLatch;
    /**
     * 是否需要回滚
     */
    protected AtomicBoolean rollbackFlag;
    /**
     * 事务
     */
    protected PlatformTransactionManager transactionManager;

    protected abstract void doWork();

    @Override
    public String call() throws Exception {
        if (rollbackFlag.get()) {
            logger.info("需要回滚，直接不用执行了");
            mainThreadLatch.countDown();
            return Constant.ERROR_STR; // 如果其他线程已经报错 就停止线程
        }
        // 设置一个事务
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); // 事物隔离级别，开启新事务，这样会比较安全些。
        TransactionStatus status = transactionManager.getTransaction(def); // 获得事务状态
        try {
            logger.info("业务开始处理：{}", this.getClass().getName());
            this.doWork();
            logger.info("业务处理结束：{}", this.getClass().getName());
            // 业务处理结束
            mainThreadLatch.countDown();
            logger.info("线程内正常 mainThreadLatch.countDown();");
            rollBackLatch.await();// 线程等待
            if (rollbackFlag.get()) {
                logger.info("回滚事务：{}", this.getClass().getName());
                transactionManager.rollback(status);
            } else {
                logger.info("提交事务：{}", this.getClass().getName());
                transactionManager.commit(status);
            }
            return Constant.SAVE_SUCCESS;
        } catch (Exception e) {
            e.printStackTrace();
            // 如果出错了 就放开锁 让别的线程进入提交/回滚 本线程进行回滚
            rollbackFlag.set(true);
            transactionManager.rollback(status);
            rollBackLatch.countDown();
            mainThreadLatch.countDown();
            logger.info("线程内异常 mainThreadLatch.countDown();");
            return "操作失败：" + e.getMessage();
        }
    }

    public CountDownLatch getRollBackLatch() {
        return rollBackLatch;
    }

    public void setRollBackLatch(CountDownLatch rollBackLatch) {
        this.rollBackLatch = rollBackLatch;
    }

    public CountDownLatch getMainThreadLatch() {
        return mainThreadLatch;
    }

    public void setMainThreadLatch(CountDownLatch mainThreadLatch) {
        this.mainThreadLatch = mainThreadLatch;
    }

    public AtomicBoolean getRollbackFlag() {
        return rollbackFlag;
    }

    public void setRollbackFlag(AtomicBoolean rollbackFlag) {
        this.rollbackFlag = rollbackFlag;
    }

    public PlatformTransactionManager getTransactionManager() {
        return transactionManager;
    }

    public void setTransactionManager(PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

}

/**
 * 异步线程执行器 携带回滚
 * 
 * @author Administrator
 *
 */
public class SynTaskUtils {

    /**
     * 日志
     */
    private static Logger logger = LoggerFactory.getLogger(SynTaskUtils.class);

    public static String doWork(List<? extends BaseCallBack> tasks, PlatformTransactionManager transactionManager) {
        if (tasks == null || tasks.size() <= 0) {
            return Constant.SUCCESS_STR;
        }
        logger.info("开始执行一组线程..........................................................");
        CountDownLatch rollBackLatch = new CountDownLatch(1);
        CountDownLatch mainThreadLatch = new CountDownLatch(tasks.size());
        AtomicBoolean rollbackFlag = new AtomicBoolean(false);
        List<Future<String>> list = new ArrayList<Future<String>>();
        for (BaseCallBack task : tasks) {
            task.setMainThreadLatch(mainThreadLatch);
            task.setRollbackFlag(rollbackFlag);
            task.setRollBackLatch(rollBackLatch);
            task.setTransactionManager(transactionManager);
            logger.info("添加任务:{}", task.getClass().getName());
            Future<String> future = TestExecutorUtil.getInstance().getExecutor().submit(task);
            list.add(future);
        }
        // 主线程业务执行完毕 如果其他线程也执行完毕 且没有报异常 正在阻塞状态中 唤醒其他线程 提交所有的事务
        // 如果其他线程或者主线程报错 则不会进入if 会触发回滚
        try {
            logger.info("主线程开始等待。");
            mainThreadLatch.await();
            logger.info("主线程等待结束。");
            if (!rollbackFlag.get()) {
                logger.info("不需要回滚。");
                rollBackLatch.countDown();
                return Constant.SUCCESS_STR;
            } else {
                logger.info("需要回滚。");
                for (Future<String> f : list) {
                    String result = f.get();
                    if (!Constant.SAVE_SUCCESS.equals(result)) {
                        logger.info("返回值：{}", result);
                        return result;
                    }
                }
                return Constant.SUCCESS_STR;
            }
        } catch (Exception e) {
            return "操作出现异常。";
        }finally {
            logger.info("结束执行一组线程..........................................................");
        }
    }

}

/**
 * 公用线程池
 * 
 * @author Administrator
 *
 */
public class TestExecutorUtil {

    /**
     * 线程池
     */
    private ExecutorService executor = Executors.newFixedThreadPool(10);

    /**
     * 单利
     * 
     * @author Administrator
     *
     */
    private static class Instance {
        private static final TestExecutorUtil instance = new TestExecutorUtil();
    }

    private TestExecutorUtil() {
    }

    public static TestExecutorUtil getInstance() {
        return Instance.instance;
    }

    public TestExecutorService getExecutor() {
        return executor;
    }

}