前言
很多人都知道 Spring 包含声明式与编程式两种事务管理方式,通常来说这已经足够日常使用 Spring 事务了。然而,要掌握一门技术,我们还要关心这门技术出现的背景,解决了什么问题,Spring 的事务设计也有其历史原因。
最近回顾 Spring 事务相关知识,发现它的设计还是包含不少内容的,分享给大家,也便于大家更容易理解与掌握 Spring 事务。
Spring 事务管理设计目的
事务是数据库中的基础概念,早在 Spring 诞生之前就已经出现。如果你对事务的概念有所遗忘,可以参考《数据库事务基础知识》 了解更多。
Java 为了操作数据库,提出过 3 个规范,这三个规范都对事务进行了支持。
- JDBC:即 Java Database Connectivity,定义了访问数据库的基本操作。参见《Java 基础知识之 JDBC》了解更多。
- JTA:即 Java Transaction API,支持本地与全局事务。全局事务即分布式事务,主要使用两阶段提交实现。参见《Java 分布式事务规范 JTA 从入门到精通》了解更多。
- JPA:即 Java Persistence API,ORM 框架实现的规范,定义了 Java 类到数据库表之间的映射,可以用面向对象的方式操作数据库,而不用写 SQL,典型的实现是 Hibernate。
Spring 框架的目的是简化 Java 的开发工作,因此面对不同的事务 API,Spring 选择将其整合成一套,这样不管底层的实现是哪一套,都能以统一的方式使用,降低了学习成本。
Spring 事务管理设计思路
Java 中的事务可以简单分为本地事务与全局事务。
本地事务使用单个事务资源,资源通常为关系型数据库,不能跨多个事务资源使用,依赖于 JDBC 或 JPA 规范。
全局事务可以使用多个事务资源,资源可以为关系型数据库或消息队列,依赖于 JTA 规范。然而 JTA 规范要求 EJB 容器对事务管理器进行实现,这就意味着全局事务与 EJB 容器进行绑定。
为了同时支持本地事务与全局事务,Spring 事务的设计参考了 JTA 规范,并且消除或降低了全局事务对 EJB 容器的依赖。
这里总结了 Spring 事务管理的一些细节,它们均参考了 JTA,而非 Spring 首创。
1. 编程式事务与声明式事务
编程式事务以 API 的形式操作事务。事务对象由事务管理器进行管理,通过事务管理器或事务对象提交、回滚事务。事务管理器在 JTA 和 Spring 中的类名都是 TransactionManager
,根据使用的 JDBC、JTA、JPA、Hibernate 不同规范或框架,Spring 事务管理器有不同的实现。
JTA 编程式事务伪代码如下:
TransactionManager transactionManager = ...;
transactionManager.begin();
Transaction transaction = transactionManager.getTransaction();
try {
...数据库或消息队列操作
transaction.commit();
} catch (Exception e) {
transaction.rollback();
}
Spring 编程式事务伪代码如下:
PlatformTransactionManager transactionManager = ...;
TransactionStatus transaction = transactionManager.getTransaction(TransactionDefinition.withDefaults());
try {
...数据库或消息队列操作
transactionManager.commit(transaction);
} catch (Exception e) {
transactionManager.rollback(transaction);
}
声明式事务在 JTA 中由 EJB 容器实现,主要通过拦截对象方法的执行,在方法执行前后控制事务,并通过 @Transactional
声明事务行为。Spring 声明式事务同样通过 AOP 拦截 bean 方法,并提供了一个同名的 @Transactional
注解声明事务行为。
JTA 声明式事务注解配置示例如下:
@Transactional(value = Transactional.TxType.REQUIRES_NEW,
rollbackOn = Exception.class,
dontRollbackOn = RuntimeException.class)
public void doSomething() {
}
对应的 Spring 声明式事务注解配置示例如下:
@Transactional(propagation = Propagation.REQUIRES_NEW,
rollbackFor = Exception.class,
noRollbackFor = RuntimeException.class)
public void doSomething() {
}
2. 事务管理器
JTA 的事务管理器通常由 EJB 容器实现,限制了应用的运行环境。Spring 事务管理器不强制要求应用运行在 EJB 容器,标准环境下使用 JTA 可以引入第三方 JTA 实现,如 Atomikos。两者实现思路基本类似,后文对 Spring 事务管理器实现简单分析。
JTA 事务管理器接口如下:
public interface TransactionManager {
public Transaction getTransaction() throws SystemException;
public void commit() throws RollbackException,HeuristicMixedException,HeuristicRollbackException, SecurityException,IllegalStateException, SystemException;
public void rollback() throws IllegalStateException, SecurityException,SystemException;
... 省略其他事务操作代码
}
Spring 事务管理器接口定义如下:
public interface PlatformTransactionManager extends TransactionManager {
TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
throws TransactionException;
void commit(TransactionStatus status) throws TransactionException;
void rollback(TransactionStatus status) throws TransactionException;
可以看到,两者都具有获取事务对象、提交、回滚事务的能力。
3. 外部事务
外部事务是暴露给用户,用于在应用中操作事务的接口。在 JTA 中使用 UserTransaction
表示,Spring 提供了一个功能类似的 TransactionStatus
对象。
JTA UserTransaction
定义如下:
public interface UserTransaction {
void setRollbackOnly() throws IllegalStateException, SystemException;
int getStatus() throws SystemException;
void begin() throws NotSupportedException, SystemException;
void commit() throws RollbackException,HeuristicMixedException, HeuristicRollbackException, SecurityException,IllegalStateException, SystemException;
void rollback() throws IllegalStateException, SecurityException,SystemException;
void setTransactionTimeout(int seconds) throws SystemException;
}
Spring TransactionStatus
定义如下:
public interface TransactionExecution {
boolean isNewTransaction();
void setRollbackOnly();
boolean isRollbackOnly();
boolean isCompleted();
}
public interface TransactionStatus extends TransactionExecution, SavepointManager, Flushable {
boolean hasSavepoint();
@Override
void flush();
}
可以看到,JTA 的外部事务接口 UserTransaction
与 TransactionManager
存在很多相似的方法,包括提交、回滚事务、设置超时时间等。
Spring 认为事务操作应该由事务管理器来完成,因此 Spring 的外部事务接口 TransactionStatus
只存在一些获取或设置事务状态的方法。
4. 内部事务
内部事务是在事务管理器内部使用的事务接口,不暴露给用户。
JTA 使用 Transaction
表示事务管理器内部使用的事务,其接口定义与 UserTransaction
很相似,不再赘述。
对于 Spring 来说,由于它主要用来整合 JDBC、JTA、JPA、Hibernate,不同的规范或者实现事务有所不同,没有固定的类型来表示内部事务,对于 JDBC 来说事务对象是 DataSourceTransactionObject
,对于 JTA 事务对象则是 JtaTransactionObject
。
5. 事务关联资源
这里的事务为内部事务,与资源进行关联的目的是为了支持分布式事务,这样当全局事务提交时,所有的资源对应的事务分支都会提交。
JTA 使用 Transaction.enlistResource
和 Transaction.delistResource
方法关联和取消关联资源。
对于 Spring 来说,由于内部事务不固定,因此没有固定的方法,不过基于 JDBC、JPA、Hibernate 的事务对象都继承了 JdbcTransactionObjectSupport
类,这个类提供了 setConnectionHolder
方法设置连接对象。
public abstract class JdbcTransactionObjectSupport implements SavepointManager, SmartTransactionObject {
// Connection 持有者
@Nullable
private ConnectionHolder connectionHolder;
public void setConnectionHolder(@Nullable ConnectionHolder connectionHolder) {
this.connectionHolder = connectionHolder;
}
}
Spring 事务管理器获取内部事务时将触发事务与资源的关联。
6. 事务传播行为
事务传播行为是指声明式事务中,在一个事务方法中调用另一个事务方法,另一个事务方法的事务行为,加入现有事务、使用新的事务还是其他的行为。它们可以在 @Tranactional
注解中配置。
JTA 定义了 6 种事务传播行为,它们定义在 TxType 枚举类中,具体如下。
public enum TxType {
REQUIRED,
REQUIRES_NEW,
MANDATORY,
SUPPORTS,
NOT_SUPPORTED,
NEVER;
}
Spring 除了支持 JTA 定义的事务传播行为,还添加了支持嵌套事务的 NESTED
。
public enum Propagation {
REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),
SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),
MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),
REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),
NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),
NEVER(TransactionDefinition.PROPAGATION_NEVER),
NESTED(TransactionDefinition.PROPAGATION_NESTED);
}
关于 Spring 事务传播行为,如果你想了解更多,也可以参考《那些年面试官问过我的 Spring 事务传播行为》。
7. 事务回滚异常
声明式事务有两种方式控制事务回滚。
第一种是通过 API 的方式设置事务仅回滚,JTA 可以调用 UserTransaction.setRollbackOnly
方法,Spring 提供了相同功能的 TransactionStatus.setRollbackOnly
方法。
第二种是通过抛出特定的异常来回滚事务。默认情况下,JTA 和 Spring 都会在方法抛出 RuntimeException
或 Error
异常时才回滚异常。同时 JTA 和 Spring 都支持配置 @Transactional
属性来指定回滚的异常。
JTA @Transactional
事务回滚属性配置如下:
public @interface Transactional {
public Class[] rollbackOn() default {};
public Class[] dontRollbackOn() default {};
}
JTA @Transactional
事务回滚属性配置如下:
public @interface Transactional {
Class<? extends Throwable>[] rollbackFor() default {};
String[] rollbackForClassName() default {};
Class<? extends Throwable>[] noRollbackFor() default {};
String[] noRollbackForClassName() default {};
}
Spring 事务使用方式
目前,主要在 Spring Boot 环境下使用声明式的方式使用 Spring 事务。
首先引入 spring-boot-starter-jdbc
即可开启声明式事务。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
<version>2.2.7.RELEASE</version>
</dependency>
然后在 bean 方法或类上添加 @Transactional
注解即可,示例如下。
@Service
public class SpringService {
@Transactional(rollbackFor = Exception.class)
public void doSomething() {
}
}
更详细的 Spring 事务使用与实现方式,可以参考《如何正确打开 Spring 事务?》。
Spring 事务与 ORM 框架整合
Spring 支持第三方 ORM 框架集成 Spring 事务,以便以一致的方式使用 Spring 事务,降低用户学习成本。
资源与事务同步
第三方 ORM 框架的事务资源由框架自身控制,为了将 ORM 框架管理的资源交给 Spring 内部事务管理,Spring 提供了一些获取资源的方法,这些方法交由第三方框架直接调用即可,具体如下。
- JDBC:
DataSourceUtils.getConnection
。 - JPA:
EntityManagerFactoryUtils.getTransactionalEntityManager
- HIbernate:
SessionFactoryUtils.getDataSource
如果当前事务已经和资源建立同步关系,则这些方法直接返回资源实例,否则会创建新的资源对象并和事务建立关系。
如果你对 MyBatis 与 Spring 事务整合的原理感兴趣,可以参考 《MyBatis 与 Spring 整合原理分析》。
异常转换
Spring 提供了两个异常转换器,可以将事务操作时产生的异常统一转换为 DataAccessException
。
public interface SQLExceptionTranslator {
DataAccessException translate(String task, @Nullable String sql, SQLException ex);
}
public interface PersistenceExceptionTranslator {
DataAccessException translateExceptionIfPossible(RuntimeException ex);
}
前者 SQLExceptionTranslator
可以由 ORM 框架执行 SQL 时直接调用,后者 PersistenceExceptionTranslator
则由 ORM 框架实现,在其内部可以复用前者。MyBatis 使用的就是后者。示例如下:
public class CustomExceptionTranslator implements PersistenceExceptionTranslator {
private SQLExceptionTranslator exceptionTranslator = new SQLErrorCodeSQLExceptionTranslator();
@Override
public DataAccessException translateExceptionIfPossible(RuntimeException ex) {
if (ex instanceof CustomException) {
if (ex.getCause() instanceof SQLException) {
return exceptionTranslator.translate(ex.getMessage(), null, (SQLException) ex.getCause());
} else {
return new UncategorizedDataAccessException(ex.getMessage(), e);
}
}
return null;
}
}
为了使用 ORM 框架实现的 PersistenceExceptionTranslator
,还需要将其声明为 bean,并添加 PersistenceExceptionTranslationPostProcessor
bean,以便转换 @Repository
事务方法中抛出的 RuntimeException
。
Spring 事务实现浅析
Spring 事务的实现基本上遵照 JTA 规范,只是定义了自己的一套 API。
AbstractPlatformTransactionManager
提供了事务管理的整体流程,包括事务获取、挂起、恢复、提交、回滚等,重点在于事务获取时的事务传播行为管理,可以参见《Spring 事务传播行为》。
它主要使用了模板方法设计模式,并预留了一些方法供子类实现。由于其内容过于复杂,限于篇幅这里不对其一一分析。不过我们重点关注下事务是如何与资源关联的,这由子类进行控制。
以 DataSourceTransactionManager
为例,首先看其实现的父类获取内部事务对象的方法。
@Override
protected Object doGetTransaction() {
DataSourceTransactionObject txObject = new DataSourceTransactionObject();
txObject.setSavepointAllowed(isNestedTransactionAllowed());
// 从线程上下文中获取 ConnectionHolder,同一个 DataSource 只会对应一个 ConnectionHolder
ConnectionHolder conHolder =
(ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
txObject.setConnectionHolder(conHolder, false);
return txObject;
}
这里调用了 TransactionSynchronizationManager.getResource
方法获取 ConnectionHolder
,然后将其设置到了事务对象 DataSourceTransactionObject
中。TransactionSynchronizationManager
还有一个对应的 bindResource
,刚好一个获取,一个设置,最终会存在线程上下文 ThreadLocal
中。
public abstract class TransactionSynchronizationManager {
private static final ThreadLocal<Map<Object, Object>> resources =
new NamedThreadLocal<>("Transactional resources");
}
这样设计有何优势呢?还记得前面讲的 ORM 框架整合部分吗?ORM 框架调用的 DataSourceUtils.getConnection
方法内部就使用了 bindResource
方法将资源设置到线程上下文,然后 Spring 事务管理器就可以获取了,从而将 Spring 内部的事务与 ORM 框架管理的资源进行关联。
不过首次进入 @Transactional
方法时,ORM 框架可能还未将资源设置到线程上下文,这时事务如何与资源关联呢?
DataSourceTransactionManager
还关联了一个 DataSource
,当开启事务时,事务管理器会再次判断是否关联资源,如果未关联资源则从 DataSoruce
获取 Connection
并设置到线程上下文,相关代码如下。
protected void doBegin(Object transaction, TransactionDefinition definition) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
Connection con = null;
if (!txObject.hasConnectionHolder() ||
txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
Connection newCon = obtainDataSource().getConnection();
}
// 初始化 ConnectionHolder
txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
}
... 省略部分代码
if (txObject.isNewConnectionHolder()) {
// 资源设置到线程上下文
TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
}
}
由于 DataSourceTransactionManager
和 ORM 框架都从 DataSource
获取 Connection
,因此需要保证依赖的 DataSource
为同一个,这样 ORM 框架才能加入 Spring 事务。