Spring事务高级支持

接口

public interface TransactionalService {
	void executeWithNewTransactional(Execute execute);

    <T>T executeWithNewTransactional(ExecuteWithReturn<T> execute);

    void executeWithTransactional(Execute execute);

    <T>T executeWithTransactional(ExecuteWithReturn<T> execute);

    void executeBeforeCommit(Execute execute);

    void executeAfterCommit(Execute execute);

    interface Execute{
        void doExecute();
    }

    interface ExecuteWithReturn <T>{
        T doExecute();
    }
}

实现类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationAdapter;
import org.springframework.transaction.support.TransactionSynchronizationManager;

public class TransactionalServiceImpl implements TransactionalService {

    private Logger logger = LoggerFactory.getLogger(TransactionalServiceImpl.class);

    /**
     * 使用新的事务提交
     * @param execute
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void executeWithNewTransactional(Execute execute) {
        execute.doExecute();
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public <T> T executeWithNewTransactional(ExecuteWithReturn<T> execute) {
        return execute.doExecute();
    }

    /**
     * 如果当前有事务则用当前事务,没有则开启新的事务提交
     * @param execute
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void executeWithTransactional(Execute execute) {
        execute.doExecute();
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public <T> T executeWithTransactional(ExecuteWithReturn<T> execute) {
        return execute.doExecute();
    }

    /**
     * 在前面的事务完成后执行此例外线程事务
     * 比如:用户注册后,给用户发激活邮件(可能邮件服务器比较耗时),这种场景就能用到了
     * @param execute
     */
    @Override
    public void executeAfterCommit(final Execute execute) {
        if(!TransactionSynchronizationManager.isSynchronizationActive()){
            logger.debug("Execute immediately without active Synchronization");
            execute.doExecute();
            return;
        }
        logger.debug("Register to transactionSynchronizationManager");
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {

            @Override
            public void afterCommit() {
                logger.debug("Execute after commit");
                execute.doExecute();
            }
        });
    }

    /**
     * 在前面的事务执行之前执行此例外线程事务
     * @param execute
     */
    @Override
    public void executeBeforeCommit(final Execute execute) {
        if(!TransactionSynchronizationManager.isSynchronizationActive()){
            logger.debug("Execute immediately without active Synchronization");
            execute.doExecute();
            return;
        }
        logger.debug("Register to transactionSynchronizationManager");
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
            @Override
            public void beforeCommit(boolean readOnly) {
                logger.debug("Execute before commit");
                execute.doExecute();
            }
        });
    }
}

需要配置spring bean  (省略)

调用方式

transactionalService.executeWithNewTransactional(new Execute() {
                @Override
                public void doExecute() {
                    //todo something 业务代码
                }
            });