本文相关源码包使用的是spring-tx-5.2.8.RELEASE.jar
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try {
// 注册 JDBC 驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// 打开连接
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?characterEncoding=utf-8&serverTimezone=UTC", "root", "xxx");
// 执行查询
stmt = conn.createStatement();
// 关闭自动提交
conn.setAutoCommit(false);
// 执行更新
String sql1 = "INSERT INTO test(id,user_name)values(1,'forlan1')";
stmt.executeUpdate(sql1);
String sql1 = "INSERT INTO test(id,user_name)values(2,'forlan2')";
stmt.executeUpdate(sql2);
// 事务提交
conn.commit(); // 上面两个操作都没有问题就提交
} catch (Exception e) {
e.printStackTrace();
// 事务回滚
conn.rollback();
} finally {
// 关闭资源,stmt.close();conn.close();
}
}
其实关键就是3个动作:关闭自动提交、commit、rollback
<bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
<property name="dataSource" ref="dataSource"/>
bean>
<tx:advice id="advice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="forlan*" propagation="REQUIRED"/>
tx:attributes>
tx:advice>
<aop:config>
<aop:pointcut expression="execution(* *..service.*.*(..))" id="tx"/>
<aop:advisor advice-ref="advice" pointcut-ref="tx"/>
aop:config>
@Autowired
private PlatformTransactionManager txManager;
public void forlanTest() {
// 1、创建事务定义
DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
// 2、根据定义开启事务
TransactionStatus transaction = txManager.getTransaction(definition);
try {
//TODO 业务逻辑、SQL操作
// 3、提交事务
txManager.commit(transaction);
} catch (Throwable e) {
e.printStackTrace();
// 4、异常了,回滚事务
txManager.rollback(transaction);
}
}
启动类加@EnableTransactionManagement,开启注解版本的事务
方法头部加@Transactional,开启事务
通过编程式事务的代码我们可以发现,关键在于PlatformTransactionManager,TransactionDefinition,TransactionStatus这几个接口,下面我们就来深挖下这几个接口是怎么设计的
顶层接口,空代码
public interface TransactionManager {}
这个是平台事务管理器,比较常用的,像我们一般的命令式编程就是用它
public interface PlatformTransactionManager extends TransactionManager {
TransactionStatus getTransaction(@Nullable TransactionDefinition var1) throws TransactionException;
void commit(TransactionStatus var1) throws TransactionException;
void rollback(TransactionStatus var1) throws TransactionException;
}
PlatformTransactionManager有个核心的实现抽象类AbstractPlatformTransactionManager,实现了公共的方法
- JtaTransactionManager:支持分布式事务【本身服务中的多数据源】
- DataSourceTransactionManager:数据源事务管理器,提供了相关事务操作的方法
响应式编程的事务管理器,响应式编程会用,一般比较少使用
事务定义,作为PlatformTransactionManager接口getTransactio()方法的入参,得到事务TransactionStatus;
public interface TransactionDefinition {
int PROPAGATION_REQUIRED = 0;
int PROPAGATION_SUPPORTS = 1;
int PROPAGATION_MANDATORY = 2;
int PROPAGATION_REQUIRES_NEW = 3;
int PROPAGATION_NOT_SUPPORTED = 4;
int PROPAGATION_NEVER = 5;
int PROPAGATION_NESTED = 6;
int ISOLATION_DEFAULT = -1;
int ISOLATION_READ_UNCOMMITTED = 1;
int ISOLATION_READ_COMMITTED = 2;
int ISOLATION_REPEATABLE_READ = 4;
int ISOLATION_SERIALIZABLE = 8;
int TIMEOUT_DEFAULT = -1;
default int getPropagationBehavior() {
return PROPAGATION_REQUIRED;
}
default int getIsolationLevel() {
return ISOLATION_DEFAULT;
}
default int getTimeout() {
return TIMEOUT_DEFAULT;
}
default boolean isReadOnly() {
return false;
}
@Nullable
default String getName() {
return null;
}
static TransactionDefinition withDefaults() {
return StaticTransactionDefinition.INSTANCE;
}
}
主要参数:传播行为、隔离级别,是否只读,超时时间
DefaultTransactionDefinition:是事务定义的默认实现
private int propagationBehavior = 0;// PROPAGATION_REQUIRED
private int isolationLevel = -1;// 跟随数据库
private int timeout = -1;// 无超时时间
private boolean readOnly = false;// 可读写
public interface TransactionStatus extends TransactionExecution, SavepointManager, Flushable {
boolean hasSavepoint(); //是否有保存点
void flush(); // 刷新
}
public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
throws TransactionException {
// 如果未给出事务定义,则使用默认值
TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());
// 关键方法1:获取数据源事务对象DataSourceTransactionObject(是否允许保存点,ConnectionHolder)
Object transaction = doGetTransaction();
boolean debugEnabled = logger.isDebugEnabled();
/**
* 判断当前线程是否存在事务:connectionHolder != null && transactionActive
* 第1次调用,connectionHolder为null
* 第2次调用,connectionHolder的transactionActive=true
*/
if (isExistingTransaction(transaction)) {
// Existing transaction found -> check propagation behavior to find out how to behave.
// 关键方法4:处理已经存在的事务
return handleExistingTransaction(def, transaction, debugEnabled);
}
// 超时,抛出异常
if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
}
// 传播行为是PROPAGATION_MANDATORY且当前线程不存在事务,就抛出异常
if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
throw new IllegalTransactionStateException(
"No existing transaction found for transaction marked with propagation 'mandatory'");
}
else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
// 关键方法2:挂起事务
SuspendedResourcesHolder suspendedResources = suspend(null);
if (debugEnabled) {
logger.debug("Creating new transaction with name [" + def.getName() + "]: " + def);
}
try {
// 关键方法3:创建新事务,transaction = xxx;newTransaction = true;newSynchronization = true
return startTransaction(def, transaction, debugEnabled, suspendedResources);
}
catch (RuntimeException | Error ex) {
// 恢复挂起的事务
resume(null, suspendedResources);
throw ex;
}
}
else {// PROPAGATION_SUPPORTS、PROPAGATION_NOT_SUPPORTED、PROPAGATION_NEVER这些传播行为进到这里
if (def.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
logger.warn("Custom isolation level specified but no actual transaction initiated; " +
"isolation level will effectively be ignored: " + def);
}
boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
// 创建空事务,transaction = null;newTransaction = true;newSynchronization = true
return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
}
}
protected boolean isExistingTransaction(Object transaction) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
return (txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive());
}
创建一个数据源事务对象DataSourceTransactionObject,设置SavepointAllowed和ConnectionHolder,ConnectionHolder里面会存放的是JDBC连接(第一次进来是null)
protected Object doGetTransaction() {
// 创建一个数据源事务对象
DataSourceTransactionManager.DataSourceTransactionObject txObject = new DataSourceTransactionManager.DataSourceTransactionObject();
// 设置是否允许保存点,DataSourceTransactionManager里面为true
txObject.setSavepointAllowed(this.isNestedTransactionAllowed());
/**
* TransactionSynchronizationManager是事务同步管理器对象,用来保存当前事务信息
* 第一次进来获取的话,因为是通过数据源去获取,但事务同步管理器中还没有存放,所以此时获取的conHolder为null
*/
ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(this.obtainDataSource());
// 非新创建连接则写false,newConnectionHolder=false
txObject.setConnectionHolder(conHolder, false);
return txObject;
}
挂起事务,暂停事务同步或解绑数据源的数据库连接对象,返回这些资源
protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException {
if (TransactionSynchronizationManager.isSynchronizationActive()) {// 事务和同步中有东西,说明事务和同步都激活
// 暂停所有当前同步并停用当前线程的事务同步,返回挂起的事务同步对象列表
List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
try {
Object suspendedResources = null;
if (transaction != null) {
// 解绑数据源的数据库连接,返回该连接
suspendedResources = doSuspend(transaction);
}
String name = TransactionSynchronizationManager.getCurrentTransactionName();
TransactionSynchronizationManager.setCurrentTransactionName(null);
boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);
boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();
TransactionSynchronizationManager.setActualTransactionActive(false);
// 返回挂起的ResourcesHolder
return new SuspendedResourcesHolder(
suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);
}
catch (RuntimeException | Error ex) {
// 挂起失败,重新激活当前线程的事务同步并恢复所有给定的同步
doResumeSynchronization(suspendedSynchronizations);
throw ex;
}
}
else if (transaction != null) {// 事务激活,但没激活同步
// 解绑数据源的数据库连接,返回该连接
Object suspendedResources = doSuspend(transaction);
// 返回挂起的ResourcesHolder
return new SuspendedResourcesHolder(suspendedResources);
}
else {
// 事务和同步都没激活
return null;
}
}
private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =
new NamedThreadLocal<>("Transaction synchronizations");
public static boolean isSynchronizationActive() {
return (synchronizations.get() != null);
}
创建TransactionStatus实例,填充属性值,获取数据库连接,关闭自动提交,绑定数据源和数据库连接到当前线程,激活事务+同步
private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled, @Nullable AbstractPlatformTransactionManager.SuspendedResourcesHolder suspendedResources) {
// 这里的transactionSynchronization = 0,所以newSynchronization =true
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 创建指定参数的TransactionStatus实例,true指的是newTransaction,创建后,事务提交和回滚状态都为false
DefaultTransactionStatus status = newTransactionStatus(
definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
// 获取数据库连接,关闭自动提交,绑定数据源和数据库连接到当前线程,激活事务
doBegin(transaction, definition);
// newSynchronization=true,激活事务+同步
prepareSynchronization(status, definition);
return status;
}
1、newTransactionStatus方法:创建TransactionStatus实例,填充属性值
/**
* status = {DefaultTransactionStatus@10391}
* completed = false
* debug = false
* newSynchronization = true
* newTransaction = true
* readOnly = false
* rollbackOnly = false
* savepoint = null
* suspendedResources = null
* transaction = {DataSourceTransactionManager$DataSourceTransactionObject@10383}
* connectionHolder = null
* mustRestoreAutoCommit = false
* newConnectionHolder = false
* previousIsolationLevel = null
* readOnly = false
* savepointAllowed = true
*/
protected DefaultTransactionStatus newTransactionStatus(
TransactionDefinition definition, @Nullable Object transaction, boolean newTransaction,
boolean newSynchronization, boolean debug, @Nullable Object suspendedResources) {
// newSynchronization = true并且之前没激活同步(synchronizations线程对象没东西)
boolean actualNewSynchronization = newSynchronization &&
!TransactionSynchronizationManager.isSynchronizationActive();
return new DefaultTransactionStatus(
transaction, newTransaction, actualNewSynchronization,
definition.isReadOnly(), debug, suspendedResources);
}
public DefaultTransactionStatus(
@Nullable Object transaction, boolean newTransaction, boolean newSynchronization,
boolean readOnly, boolean debug, @Nullable Object suspendedResources) {
this.transaction = transaction;
this.newTransaction = newTransaction;
this.newSynchronization = newSynchronization;
this.readOnly = readOnly;
this.debug = debug;
this.suspendedResources = suspendedResources;
}
2、doBegin方法:获取数据库连接,关闭自动提交,绑定数据源和ConnectionHolder到当前线程,设置DataSourceTransactionObject 信息(激活事务、同步),
可能的操作(设置只读、隔离解绑)
protected void doBegin(Object transaction, TransactionDefinition definition) {
DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject
Connection con = null;
try {
// ConnectionHolder为空 或 已经激活事务同步
if (!txObject.hasConnectionHolder() || txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
// 通过数据源获取数据库连接对象
Connection newCon = this.obtainDataSource().getConnection();
if (this.logger.isDebugEnabled()) {
this.logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
}
// 把数据库连接对象包装为ConnectionHolder对象,然后设置到txObject对象中
txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
}
// 设置ConnectionHolder的synchronizedWithTransaction为true
txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
// 获取数据库连接对象
con = txObject.getConnectionHolder().getConnection();
// 如果有是否只读和隔离级别!=-1,设置con.setReadOnly(true);con.setTransactionIsolation(xxx);
Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
// 设置txObject的隔离级别
txObject.setPreviousIsolationLevel(previousIsolationLevel);
// 设置txObject是否只读
txObject.setReadOnly(definition.isReadOnly());
if (con.getAutoCommit()) {// 如果是自动提交
txObject.setMustRestoreAutoCommit(true);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
}
con.setAutoCommit(false);// 关闭自动提交
}
// 准备事务连接,如果“enforceReadOnly”标志设置为true,并且事务定义指示只读事务,则默认实现将执行“SET TRANSACTION IONLY”语句
prepareTransactionalConnection(con, definition);
// 设置ConnectionHolder的transactionActive为true,表示已经存在事务,后面就会进入有事务的逻辑
txObject.getConnectionHolder().setTransactionActive(true);
int timeout = this.determineTimeout(definition);
if (timeout != -1) {
txObject.getConnectionHolder().setTimeoutInSeconds(timeout);// 设置事务超时时间
}
if (txObject.isNewConnectionHolder()) {
// 将资源绑定到当前线程,key=数据源,value=ConnectionHolder
TransactionSynchronizationManager.bindResource(this.obtainDataSource(), txObject.getConnectionHolder());
}
} catch (Throwable var7) {
if (txObject.isNewConnectionHolder()) {
// 关闭数据库连接
DataSourceUtils.releaseConnection(con, this.obtainDataSource());
txObject.setConnectionHolder((ConnectionHolder)null, false);
}
throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", var7);
}
}
3、prepareSynchronization方法:如果newSynchronization = true,初始化事务同步管理器
protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
if (status.isNewSynchronization()) {
TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(
definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ?
definition.getIsolationLevel() : null);
TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
TransactionSynchronizationManager.initSynchronization();
}
}
处理存在事务的情况下,不同传播行为的逻辑,主要看是否抛出异常,是否挂起资源,是执行startTransaction
startTransaction和prepareTransactionStatus的区别,startTransaction多执行了doBegin()方法,开启了新事物,返回的参数为true(newSynchronization,newTransaction,mustRestoreAutoCommit,newConnectionHolder)
说明:newTransaction:true表示新开事务,false参与到当前事务
newSynchronization:后面提交和回滚有用
private TransactionStatus handleExistingTransaction(
TransactionDefinition definition, Object transaction, boolean debugEnabled)
throws TransactionException {
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
// 当前存在事务,则抛出异常
throw new IllegalTransactionStateException(
"Existing transaction found for transaction marked with propagation 'never'");
}
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
if (debugEnabled) {
logger.debug("Suspending current transaction");
}
// 挂起当前事务,返回挂起资源
Object suspendedResources = suspend(transaction);
boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
// 创建空事务,并携带挂起资源,transaction = null;suspendedResources=xxx; newTransaction = false;newSynchronization = true;
return prepareTransactionStatus(
definition, null, false, newSynchronization, debugEnabled, suspendedResources);
}
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
if (debugEnabled) {
logger.debug("Suspending current transaction, creating new transaction with name [" +
definition.getName() + "]");
}
// 挂起当前事务,返回挂起资源
SuspendedResourcesHolder suspendedResources = suspend(transaction);
try {
// 创建新事务,并携带挂起资源,transaction = xxx;suspendedResources=xxx; newTransaction = true;newSynchronization = true;
return startTransaction(definition, transaction, debugEnabled, suspendedResources);
}
catch (RuntimeException | Error beginEx) {
resumeAfterBeginException(transaction, suspendedResources, beginEx);
throw beginEx;
}
}
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
if (!isNestedTransactionAllowed()) {// 不允许嵌套事务就报错
throw new NestedTransactionNotSupportedException(
"Transaction manager does not allow nested transactions by default - " +
"specify 'nestedTransactionAllowed' property with value 'true'");
}
if (debugEnabled) {
logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
}
if (useSavepointForNestedTransaction()) {
// Create savepoint within existing Spring-managed transaction,
// through the SavepointManager API implemented by TransactionStatus.
// Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
// 创建新事务,不挂起资源,transaction = xxx;suspendedResources=null; newTransaction = false;newSynchronization = false;
DefaultTransactionStatus status =
prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
// 创建保存点,savepoint=xxx
status.createAndHoldSavepoint();
return status;
}
else {
// Nested transaction through nested begin and commit/rollback calls.
// Usually only for JTA: Spring synchronization might get activated here
// in case of a pre-existing JTA transaction.
// 创建新事务
return startTransaction(definition, transaction, debugEnabled, null);
}
}
// Assumably PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.
if (debugEnabled) {
logger.debug("Participating in existing transaction");
}
if (isValidateExistingTransaction()) {
if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) {
Constants isoConstants = DefaultTransactionDefinition.constants;
throw new IllegalTransactionStateException("Participating transaction with definition [" +
definition + "] specifies isolation level which is incompatible with existing transaction: " +
(currentIsolationLevel != null ?
isoConstants.toCode(currentIsolationLevel, DefaultTransactionDefinition.PREFIX_ISOLATION) :
"(unknown)"));
}
}
if (!definition.isReadOnly()) {
if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
throw new IllegalTransactionStateException("Participating transaction with definition [" +
definition + "] is not marked as read-only but existing transaction is");
}
}
}
// 传播行为:PROPAGATION_REQUIRED,PROPAGATION_SUPPORTS,PROPAGATION_MANDATORY,会走到这里的逻辑
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 创建新事务,不挂起资源,transaction = xxx;suspendedResources=null; newTransaction = false;newSynchronization = false;
return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
}
我们通过以下代码来分析源码做了什么
@Transactional/*(propagation = Propagation.SUPPORTS)*/
public void m1(){
forlanDao.update(xxx);
forlanService.m2();
}
@Transactional(propagation = Propagation.REQUIRED)
// @Transactional(propagation = Propagation.NESTED)
// @Transactional(propagation = Propagation.REQUIRES_NEW)
// @Transactional(propagation = Propagation.NOT_SUPPORTED)
public void m2(){
forlanDao.insert(xxx);
}
transactionStatus = {DefaultTransactionStatus@10569}
transaction = {DataSourceTransactionManager$DataSourceTransactionObject@10398}
newConnectionHolder = true
mustRestoreAutoCommit = true
connectionHolder = {ConnectionHolder@10577}
previousIsolationLevel = null
readOnly = false
savepointAllowed = true
newTransaction = true
newSynchronization = true
readOnly = false
debug = false
suspendedResources = null
rollbackOnly = false
completed = false
savepoint = null
放开注释的话,返回的TransactionStatus对象,内容如下:
transactionStatus = {DefaultTransactionStatus@10421}
transaction = null
newTransaction = true
newSynchronization = true
readOnly = false
debug = false
suspendedResources = null
rollbackOnly = false
completed = false
savepoint = null
主要区别在于transaction是否为空,为null表示没有事务,否则就是有事务
1)REQUIRED的话,返回的TransactionStatus对象,内容如下:
transactionStatus = {DefaultTransactionStatus@10678}
transaction = {DataSourceTransactionManager$DataSourceTransactionObject@10652}
newConnectionHolder = false
mustRestoreAutoCommit = false
connectionHolder = {ConnectionHolder@10683}
previousIsolationLevel = null
readOnly = false
savepointAllowed = true
suspendedResources = null
newTransaction = false
newSynchronization = false
readOnly = false
debug = false
rollbackOnly = false
completed = false
savepoint = null
注:SUPPORTS,MANDATORY也是一样内容
2)NESTED的话,返回的TransactionStatus对象,内容如下:
transactionStatus = {DefaultTransactionStatus@10675}
transaction = {DataSourceTransactionManager$DataSourceTransactionObject@10652}
newConnectionHolder = false
mustRestoreAutoCommit = false
connectionHolder = {ConnectionHolder@10695}
previousIsolationLevel = null
readOnly = false
savepointAllowed = true
suspendedResources = null
newTransaction = false
newSynchronization = false
readOnly = false
debug = false
rollbackOnly = false
completed = false
savepoint = {MysqlSavepoint@10692}
savepointName = "SAVEPOINT_1"
exceptionInterceptor = null
3)REQUIRES_NEW的话,返回的TransactionStatus对象,内容如下:
transactionStatus = {DefaultTransactionStatus@10672}
transaction = {DataSourceTransactionManager$DataSourceTransactionObject@10652}
newConnectionHolder = true
mustRestoreAutoCommit = true
connectionHolder = {ConnectionHolder@10678}
previousIsolationLevel = null
readOnly = false
savepointAllowed = true
suspendedResources = {AbstractPlatformTransactionManager$SuspendedResourcesHolder@10677}
suspendedResources = {ConnectionHolder@10679}
suspendedSynchronizations = {Collections$UnmodifiableRandomAccessList@10680} size = 1
name = "cn.lw.service.impl.ShiwuServiceImpl.insert"
readOnly = false
isolationLevel = null
wasActive = true
newTransaction = true
newSynchronization = true
readOnly = false
debug = false
rollbackOnly = false
completed = false
savepoint = null
4)NOT_SUPPORTED的话,返回的TransactionStatus对象,内容如下:
transactionStatus = {DefaultTransactionStatus@10678}
transaction = null
suspendedResources = {AbstractPlatformTransactionManager$SuspendedResourcesHolder@10666}
suspendedResources = {ConnectionHolder@10681}
connectionHandle = {SimpleConnectionHandle@10687} "SimpleConnectionHandle: HikariProxyConnection@961058126 wrapping com.mysql.jdbc.JDBC4Connection@4d0128fe"
currentConnection = {HikariProxyConnection@10688} "HikariProxyConnection@961058126 wrapping com.mysql.jdbc.JDBC4Connection@4d0128fe"
transactionActive = true
savepointsSupported = null
savepointCounter = 0
synchronizedWithTransaction = true
rollbackOnly = false
deadline = null
referenceCount = 1
isVoid = false
suspendedSynchronizations = {Collections$UnmodifiableRandomAccessList@10682} size = 1
name = "cn.lw.service.impl.ShiwuServiceImpl.insert"
readOnly = false
isolationLevel = null
wasActive = true
newTransaction = false
newSynchronization = true
readOnly = false
debug = false
rollbackOnly = false
completed = false
savepoint = null
总的区别:
属性值区别:
transaction表示是否以事务的方式执行,newConnectionHolder表示是否开启新事物
public final void commit(TransactionStatus status) throws TransactionException {
if (status.isCompleted()) {// completed=true,说明之前已经提交或回滚
throw new IllegalTransactionStateException(
"Transaction is already completed - do not call commit or rollback more than once per transaction");
}
DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
if (defStatus.isLocalRollbackOnly()) {// rollbackOnly=true,请求回滚
if (defStatus.isDebug()) {
logger.debug("Transactional code has requested rollback");
}
processRollback(defStatus, false);
return;
}
if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
if (defStatus.isDebug()) {
logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
}
processRollback(defStatus, true);
return;
}
processCommit(defStatus);
}
处理提交
private void processCommit(DefaultTransactionStatus status) throws TransactionException {
try {
boolean beforeCompletionInvoked = false;
try {
boolean unexpectedRollback = false;
// 为提交做准备,空方法,交给子类去实现
prepareForCommit(status);
// newSynchronization=true,执行TransactionSynchronization子类的beforeCommit方法,提供给我们扩展实现,actualTransactionActive有东西的话,提交Connection、Session
triggerBeforeCommit(status);
// newSynchronization=true,执行TransactionSynchronization子类的beforeCompletion方法,提供给我们扩展实现,不被其它资源引用,(referenceCount=0)的话,解绑本地线程的resources,holderActive=false,关闭Connection、Session
triggerBeforeCompletion(status);
beforeCompletionInvoked = true;
if (status.hasSavepoint()) {
if (status.isDebug()) {
logger.debug("Releasing transaction savepoint");
}
unexpectedRollback = status.isGlobalRollbackOnly();
// releaseSavepoint,设置savepoint=null
status.releaseHeldSavepoint();
}
else if (status.isNewTransaction()) {// newTransaction=true
if (status.isDebug()) {
logger.debug("Initiating transaction commit");
}
unexpectedRollback = status.isGlobalRollbackOnly();// 是否需要回滚
doCommit(status);// 执行commit方法
}
else if (isFailEarlyOnGlobalRollbackOnly()) {
unexpectedRollback = status.isGlobalRollbackOnly();
}
// Throw UnexpectedRollbackException if we have a global rollback-only
// marker but still didn't get a corresponding exception from commit.
if (unexpectedRollback) {
throw new UnexpectedRollbackException(
"Transaction silently rolled back because it has been marked as rollback-only");
}
}
catch (UnexpectedRollbackException ex) {
// can only be caused by doCommit
triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
throw ex;
}
catch (TransactionException ex) {
// can only be caused by doCommit
if (isRollbackOnCommitFailure()) {
doRollbackOnCommitException(status, ex);
}
else {
triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
}
throw ex;
}
catch (RuntimeException | Error ex) {
if (!beforeCompletionInvoked) {
triggerBeforeCompletion(status);
}
doRollbackOnCommitException(status, ex);
throw ex;
}
// Trigger afterCommit callbacks, with an exception thrown there
// propagated to callers but the transaction still considered as committed.
try {
// newSynchronization=true的话,在提交之后触发,空方法,交给子类去实现
triggerAfterCommit(status);
}
finally {
// newSynchronization=true,清除当前线程的synchronizations,TransactionSynchronization子类的afterCompletion方法,给我们提供的扩展
triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);
}
}
finally {
// 设置TransactionStatus的completed=true,可能需要清除本地线程信息,重置connection,关闭连接,恢复挂起资源
cleanupAfterCompletion(status);
}
}
提交事务
protected void doCommit(DefaultTransactionStatus status) {
DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject)status.getTransaction();
// 获取Connection对象
Connection con = txObject.getConnectionHolder().getConnection();
if (status.isDebug()) {
this.logger.debug("Committing JDBC transaction on Connection [" + con + "]");
}
try {
// 执行提交
con.commit();
} catch (SQLException var5) {
throw new TransactionSystemException("Could not commit JDBC transaction", var5);
}
}
private void cleanupAfterCompletion(DefaultTransactionStatus status) {
status.setCompleted();// 设置completed=true
if (status.isNewSynchronization()) {
// 清除当前线程的事务信息,仅保留事务资源ConnectionHolder
TransactionSynchronizationManager.clear();
}
if (status.isNewTransaction()) {
// 移除当前线程的ConnectionHolder,重置connection
doCleanupAfterCompletion(status.getTransaction());
}
if (status.getSuspendedResources() != null) {// 有挂起资源
if (status.isDebug()) {
logger.debug("Resuming suspended transaction after completion of inner transaction");
}
Object transaction = (status.hasTransaction() ? status.getTransaction() : null);
// 恢复挂起的资源,绑定到本地线程resources;恢复挂起的TransactionSynchronization
resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());
}
}
// TransactionSynchronizationManager.java
public static void clear() {
synchronizations.remove();
currentTransactionName.remove();
currentTransactionReadOnly.remove();
currentTransactionIsolationLevel.remove();
actualTransactionActive.remove();
}
protected void doCleanupAfterCompletion(Object transaction) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
// Remove the connection holder from the thread, if exposed.
if (txObject.isNewConnectionHolder()) {
// 移除当前线程的ConnectionHolder
TransactionSynchronizationManager.unbindResource(obtainDataSource());
}
// Reset connection.
Connection con = txObject.getConnectionHolder().getConnection();
try {
if (txObject.isMustRestoreAutoCommit()) {// mustRestoreAutoCommit=true,恢复自动提交
con.setAutoCommit(true);
}
// 重置隔离级别和是否只读,con.setTransactionIsolation(上一个隔离级别);con.setReadOnly(false);
DataSourceUtils.resetConnectionAfterTransaction(
con, txObject.getPreviousIsolationLevel(), txObject.isReadOnly());
}
catch (Throwable ex) {
logger.debug("Could not reset JDBC Connection after transaction", ex);
}
if (txObject.isNewConnectionHolder()) {
if (logger.isDebugEnabled()) {
logger.debug("Releasing JDBC Connection [" + con + "] after transaction");
}
// 如果当前是事务连接,设置ConnectionHolder.currentConnection=null,否则关闭连接con.close()
DataSourceUtils.releaseConnection(con, this.dataSource);
}
// 清空ConnectionHolder和ResourceHolder事务状态
txObject.getConnectionHolder().clear();
}
public void clear() {
this.synchronizedWithTransaction = false;
this.rollbackOnly = false;
this.deadline = null;
this.transactionActive = false;
this.savepointsSupported = null;
this.savepointCounter = 0;
}
调用processCommit
外层方法默认是REQUIRED,表示有事务,没有事务的情况下就不用演示了,就是走我们的单事务逻辑,接下来我们还是分析以下代码,来看看不同传播行为的提交方式
@Transactional
public void m1(){
forlanDao.update(xxx);
forlanService.m2();
}
@Transactional(propagation = Propagation.REQUIRED)
// @Transactional(propagation = Propagation.NESTED)
// @Transactional(propagation = Propagation.REQUIRES_NEW)
// @Transactional(propagation = Propagation.NOT_SUPPORTED)
public void m2(){
forlanDao.insert(xxx);
}
REQUIRED,SUPPORTS,MANDATORY三者是一样的,都是有事务就加入当前事务,调用getTransaction方法得到的TransactionStatus是一样的。
先调用m2()方法的commitTransactionAfterReturning,执行过程如下:
再调用m1()方法的commitTransactionAfterReturning
先调用m2()方法的commitTransactionAfterReturning,执行过程如下:
再调用m1()方法的commitTransactionAfterReturning
先调用m2()方法的commitTransactionAfterReturning,执行过程如下:
再调用m1()方法的commitTransactionAfterReturning
先调用m2()方法的commitTransactionAfterReturning,执行过程如下:
再调用m1()方法的commitTransactionAfterReturning
public final void rollback(TransactionStatus status) throws TransactionException {
if (status.isCompleted()) {
throw new IllegalTransactionStateException(
"Transaction is already completed - do not call commit or rollback more than once per transaction");
}
DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
processRollback(defStatus, false);
}
执行回滚
private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
try {
boolean unexpectedRollback = unexpected;
try {
// newSynchronization=true,执行TransactionSynchronization子类的beforeCompletion方法,提供给我们扩展实现,不被其它资源引用,(referenceCount=0)的话,解绑本地线程的resources,holderActive=false,关闭Connection、Session
triggerBeforeCompletion(status);
if (status.hasSavepoint()) {
if (status.isDebug()) {
logger.debug("Rolling back transaction to savepoint");
}
status.rollbackToHeldSavepoint();
}
else if (status.isNewTransaction()) {
if (status.isDebug()) {
logger.debug("Initiating transaction rollback");
}
// 事务回滚,con.rollback();
doRollback(status);
}
else {
// Participating in larger transaction
if (status.hasTransaction()) {
if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
if (status.isDebug()) {
logger.debug("Participating transaction failed - marking existing transaction as rollback-only");
}
// 设置ResourceHolder的rollbackOnly=true
doSetRollbackOnly(status);
}
else {
if (status.isDebug()) {
logger.debug("Participating transaction failed - letting transaction originator decide on rollback");
}
}
}
else {
logger.debug("Should roll back transaction but cannot - no transaction available");
}
// Unexpected rollback only matters here if we're asked to fail early
if (!isFailEarlyOnGlobalRollbackOnly()) {
unexpectedRollback = false;
}
}
}
catch (RuntimeException | Error ex) {
triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
throw ex;
}
// newSynchronization=true,清除当前线程的synchronizations,TransactionSynchronization子类的afterCompletion方法,给我们提供的扩展
triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
// Raise UnexpectedRollbackException if we had a global rollback-only marker
if (unexpectedRollback) {
throw new UnexpectedRollbackException(
"Transaction rolled back because it has been marked as rollback-only");
}
}
finally {
// 设置TransactionStatus的completed=true,可能需要清除本地线程信息,重置connection,关闭连接,恢复挂起资源
cleanupAfterCompletion(status);
}
}
调用processRollback
外层方法默认是REQUIRED,表示有事务,没有事务的情况下就不用演示了,就是走我们的单事务逻辑,接下来我们还是分析以下代码,来看看不同传播行为的回滚方式
@Transactional
public void m1(){
forlanDao.update(xxx);
forlanService.m2();
}
@Transactional(propagation = Propagation.REQUIRED)
// @Transactional(propagation = Propagation.NESTED)
// @Transactional(propagation = Propagation.REQUIRES_NEW)
// @Transactional(propagation = Propagation.NOT_SUPPORTED)
public void m2(){
forlanDao.insert(xxx);
int i = 1/0;
}
REQUIRED,SUPPORTS,MANDATORY三者是一样的,都是有事务就加入当前事务,调用getTransaction方法得到的TransactionStatus是一样的。
先调用m2()方法的completeTransactionAfterThrowing,执行过程如下:
再调用m1()方法的completeTransactionAfterThrowing
先调用m2()方法的completeTransactionAfterThrowing,执行过程如下:
再调用m1()方法的completeTransactionAfterThrowing
特殊,如果我们在m1()方法中捕获了异常,这时候m1()方法怎么执行?
@Transactional
public void insert(ForlanA forlanA, ForlanB forlanB) {
forlanADao.insert(forlanA);
try {
forlanBService.insert(forlanB);
} catch (Exception e) {
System.out.println("报错了");
}
}
这时候m1()方法会调用commitTransactionAfterReturning,执行processCommit提交事务,会不会把我们的m2()方法执行的一起提交?
答案肯定是不会的,什么叫嵌套事务,内部回滚是不会影响外部的,前面我们说到,有保存点,会调用rollbackToHeldSavepoint,就是在这里面回滚到了保存点,我们看下源码
public void rollbackToHeldSavepoint() throws TransactionException {
Object savepoint = getSavepoint();
if (savepoint == null) {
throw new TransactionUsageException(
"Cannot roll back to savepoint - no savepoint associated with current transaction");
}
// 关键就在这,会进行事务回滚到保存点,使用的
getSavepointManager().rollbackToSavepoint(savepoint);
getSavepointManager().releaseSavepoint(savepoint);
setSavepoint(null);
}
/**
* This implementation rolls back to the given JDBC 3.0 Savepoint.
* @see java.sql.Connection#rollback(java.sql.Savepoint)
*/
public void rollbackToSavepoint(Object savepoint) throws TransactionException {
ConnectionHolder conHolder = getConnectionHolderForSavepoint();
try {
// 回滚到保存点,调用了Connection.rollback(savepoint)
conHolder.getConnection().rollback((Savepoint) savepoint);
conHolder.resetRollbackOnly();
}
catch (Throwable ex) {
throw new TransactionSystemException("Could not roll back to JDBC savepoint", ex);
}
}
先调用m2()方法的completeTransactionAfterThrowing,执行过程如下:
再调用m1()方法的completeTransactionAfterThrowing
假设父方法中报错了,此时m2()方法已经执行了commitTransactionAfterReturning, 事务已经提交,不会回滚
先调用m2()方法的completeTransactionAfterThrowing,执行过程如下:
再调用m1()方法的completeTransactionAfterThrowing
调试代码,打断点
可以看到,调用了 TransactionInterceptor 的 invoke 方法,这里就是开始处理事务的起点
@Nullable
public Object invoke(MethodInvocation invocation) throws Throwable {
// 获取目标类
Class<?> targetClass = invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null;
// 获取目标方法
Method var10001 = invocation.getMethod();
invocation.getClass();
return this.invokeWithinTransaction(var10001, targetClass, invocation::proceed);
}
调用了 TransactionAspectSupport 的 invokeWithinTransaction 方法
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
final InvocationCallback invocation) throws Throwable {
// 如果事务属性为空,则该方法是非事务性的
TransactionAttributeSource tas = getTransactionAttributeSource();
// 通过事务属性源对象拿到方法的事务属性信息:propagationBehavior,readOnly...
final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
// 获取事务管理器对象
final TransactionManager tm = determineTransactionManager(txAttr);
if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
// 响应式编程逻辑
....
}
// 将事务管理器强制转为平台事务管理器
PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
// 获取连接点唯一标识:目前方法具体路径
final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
// 创建事务
TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
Object retVal;
try {
// 调用目标对象方法
retVal = invocation.proceedWithInvocation();
}
catch (Throwable ex) {
// target invocation exception
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
finally {
// 清除事务信息
cleanupTransactionInfo(txInfo);
}
if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
// Set rollback-only in case of Vavr failure matching our rollback rules...
TransactionStatus status = txInfo.getTransactionStatus();
if (status != null && txAttr != null) {
retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
}
}
// // 执行commit操作
commitTransactionAfterReturning(txInfo);
return retVal;
}
else {
// CallbackPreferringPlatformTransactionManager的实例,才执行的逻辑
...
}
}
调用了 TransactionAspectSupport的createTransactionIfNecessary方法,方法里面又调用了AbstractPlatformTransactionManager的 getTransaction方法,这个就是我们前面分析过的核心方法了,到这里已经关联上了
protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
// If no name specified, apply method identification as transaction name.
if (txAttr != null && txAttr.getName() == null) {
// 设置targetDefinition和targetAttribute属性值,和TransactionAttribute的一样,设置joinpointIdentification
txAttr = new DelegatingTransactionAttribute(txAttr) {
@Override
public String getName() {
return joinpointIdentification;
}
};
}
TransactionStatus status = null;
if (txAttr != null) {
if (tm != null) {
status = tm.getTransaction(txAttr);
}
else {
if (logger.isDebugEnabled()) {
logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +
"] because no transaction manager has been configured");
}
}
}
// 创建TransactionInfo并填充属性,并绑定到transactionInfoHolder线程对象中
return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}
private static final ThreadLocal<TransactionInfo> transactionInfoHolder =
new NamedThreadLocal<>("Current aspect-driven transaction");
TransactionAttribute继承TransactionDefinition,propagationBehavior、isolationLevel,readOnly等属性会因我们注解填写的不同而不同 TransactionStatus会根据是单事务还是双事务,设置不同的属性值
TransactionInterceptor
就是事务处理的 advice,AOP中的增强方法
1)我们点击开启注解事务的注解@EnableTransactionManagement,可以看到里面@的Import
2)进入到TransactionManagementConfigurationSelector类,可以看到里面注入了ProxyTransactionManagementConfiguration类
3)进入到ProxyTransactionManagementConfiguration类,可以看到里面把TransactionInterceptor设置给advisor
@Transactional就是我们说的声明式事务,其实就是把编程式事务的公共代码抽取出来去AOP实现,要在方法前后增强,所以用环绕通知,出现异常,异常通知进行回滚
// 进行前置增强:获取数据库连接,关闭自动提交,绑定Map<数据源,数据库连接>到线程对象
// @Transactional的信息其实会被解析为TransactionDefinition,最终得到TransactionStatus对象
TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
Object retVal;
try {
// 调用目标对象方法
retVal = invocation.proceedWithInvocation();
}
catch (Throwable ex) {
// 出现异常,执行rollback操纵
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
finally {
// 设置之前的事务消息到当前线程transactionInfoHolder.set(this.oldTransactionInfo)
cleanupTransactionInfo(txInfo);
}
// 执行commit操作
commitTransactionAfterReturning(txInfo);
return retVal;
如果需要了解不同传播行为的效果,可以查看这里
对于不同的传播行为,前面创建事务的时候,我们得到了TransactionStatus对象,关键在于里面的值不同,代码会去实现不同的效果
NEVER的话,是不会得到TransactionStatus,直接就抛异常了
其它情况得到的对象内部如下:
主要区别就在于上面这些值,我们来分析下是怎么提交和回滚的
这三者得到的TransactionStatus对象是一样的,执行情况也是一样,我们来分析下
它存在一个特殊的值,那就是savepoint,其他值基本和REQUIRED的一样,说明加入外层事务一起提交或回滚,真的是这样?savepoint有什么用?
那就是出现异常时,内层事务会直接进行回滚,Connection.rollback(savepoint),说明内外层是不同事务,但是正常执行的话,是等最终才一起提交的,这种属于嵌套事务,比较特殊的是,内层事务异常的话,外层事务捕获了,外层事务是正常提交的
首先transaction不为null,表示以事务的方式执行,newConnectionHolder=true,说明是新起事务执行,相对于内外层是两个不同的事务