手动事务的几个类

主要的几个类

TransactionManager

PlatformTransactionManager

TransactionStatus

TransactionDefinition，TransactionTemplate

TransactionTemplate主要依赖于execute(TransactionCallback<T> action)方法执行事务管理

再来分析分析execute方法的参数 TransactionCallback

查看接口TransactionCallback.java 发现其仅有一个方法：

public interface TransactionCallback<T> {
    T doInTransaction(TransactionStatus var1);
}

并且有一个抽象类 TransactionCallbackWithoutResult实现了接口 TransactionCallback

所以当我们借助TransactionTemplate.execute( ... )执行事务管理的时候，传入的参数有两种选择：

1、TransactionCallback
2、TransactionCallbackWithoutResult

两种区别从命名看就相当明显了，一个是有返回值，一个是无返回值。这个的选择就取决于你是读还是写了

传入 TransactionCallback

public Object getObject(String str) {
        /*
         *  执行带有返回值<Object>的事务管理
         */
        transactionTemplate.execute(new TransactionCallback<Object>() {
            @Override
            public Object doInTransaction(TransactionStatus transactionStatus) {

                try {
                      ...
                    //.......   业务代码
                    return new Object();
                } catch (Exception e) {
                    //回滚
                    transactionStatus.setRollbackOnly();
                    return null;
                }
            }
        });
}

传入 TransactionCallbackWithoutResult

public void update(String str) {

         /*
         *  执行无返回值的事务管理
         */
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {

                try {

                    // ....  业务代码
                } catch (Exception e){
                    //回滚
                    transactionStatus.setRollbackOnly();
                }

            }
        });
}

使用 lamd 表达式

import org.springframework.transaction.support.TransactionTemplate;
// 执行数据库操作
@Autowired
private TransactionTemplate transactionTemplate;
public T methodName(T parameter1, T parameter2, ...) {
 Object result = (Object)transactionTemplate.execute(status->
   try{
        ...
        // 执行回滚
        if (不满足事务要求)
          status.setRollbackOnly();
        ...
   } catch (Exception e) {
       e.printStackTrace();
       status.setRollbackOnly();
   });             
}

@Service
public class TestServiceImpl {
    @Resource
    private TransactionTemplate transactionTemplate;
 
    public Object testTransaction() {
        //数据库查询
        dao.select(1);
        return transactionTemplate.execute(status -> {
            //数据库新增
            dao.insert(2);
            dao.insert(3);
            return new Object();
        });
    }
}

示例

@Service
public class MyService{
    @Autowired
    DataSourceTransactionManager transactionManager;
    
    public ResultMap lockStockWhenNewOrder(List<StockChangeByOrderDto> goodsModels) {
        //2.获取事务定义
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        //3.设置事务隔离级别，开启新事务
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
        //4.获得事务状态，相当于开启事物
        TransactionStatus transactionStatus = transactionManager.getTransaction(def);
        try{
            //insert or update ...
            transactionManager.commit(transactionStatus);
        } catch (InterruptedException e) {
            transactionManager.rollback(transactionStatus);
        }
    }
}

创建一个控制事务的工具类，并交给spring管理

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

@Component
public class TransationUtils {

    @Autowired
    private PlatformTransactionManager platformTransactionManager;

    private TransactionStatus transactionStatus;

    /**
     * 开启事务
     *
     * @return
     */
    public TransactionStatus beginTransaction() {
        transactionStatus = platformTransactionManager.getTransaction(new DefaultTransactionDefinition());
        return transactionStatus;
    }

    /**
     * 提交事务
     */
    public void commitTransaction() {
        if (!transactionStatus.isCompleted()) {
            platformTransactionManager.commit(transactionStatus);
        }
    }

    /**
     * 回滚事务
     */
    public void rollbackTransaction() {
        if (!transactionStatus.isCompleted()) {
            platformTransactionManager.rollback(transactionStatus);
        }
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.DefaultTransactionAttribute;
 
//编程事务（需要手动begin 手动回滚  手都提交）
@Component
public class TransactionUtils {
 
    // 获取事务源
    @Autowired
    private DataSourceTransactionManager dataSourceTransactionManager;
 
    // 开启事务
    public TransactionStatus begin() {
        TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
        return transaction;
    }
 
    // 提交事务
    public void commit(TransactionStatus transaction) {
        dataSourceTransactionManager.commit(transaction);
    }
 
    // 回滚事务
    public void rollback(TransactionStatus transaction) {
        dataSourceTransactionManager.rollback(transaction);
    }
 
}

在需要使用到事务的类中注入该工具类,并使用

@Autowired
TransationUtils transationUtils;

public void test(){

	//开启事务
	transationUtils.beginTransaction();

	try {
		·············
		//操作成功提交事务
		transationUtils.commitTransaction();
	} catch (Exception e) {
		//捕获异常回滚事务
		transationUtils.rollbackTransaction();
		throw new RuntimeException("失败！");
	}
}

动开启事务的方法，原理就是在各种情况下判断事务有没有正常结束，如果捕获异常的话就回滚，正常的话就提交

注解事务 @Transactional

springboot 的话可以直接在方法上使用注释 @Transactional(rollbackFor = Exception.class)

自动开启事务，当出现异常时会自动回滚，但是如果使用 try catch 时事务会失效，需要手动回滚事务 ，具体操作如下

try {
      ······················
}catch (Exception e) {
   	//手动回滚
    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}

参考

Spring 事务
手动事务及多线程事务