Spring 事务三大核心接口深度解析
Spring 事务管理基于三个核心接口构建：PlatformTransactionManager、TransactionDefinition 和 TransactionStatus。这三个接口共同构成了 Spring 事务抽象的基础框架，提供了统一的事务管理模型。
一、核心接口详解
1. PlatformTransactionManager - 事务管理器
PlatformTransactionManager 是 Spring 事务管理的核心接口，定义了事务的基本操作：获取事务、提交事务和回滚事务。
接口定义：
public interface PlatformTransactionManager {
// 获取事务状态（根据事务定义）
TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
// 提交事务
void commit(TransactionStatus status) throws TransactionException;
// 回滚事务
void rollback(TransactionStatus status) throws TransactionException;
}
核心实现类：
| 实现类 | 适用场景 |
|---|---|
DataSourceTransactionManager | JDBC、MyBatis 等基于数据源的事务 |
JpaTransactionManager | JPA 持久化框架 |
HibernateTransactionManager | Hibernate ORM 框架 |
JtaTransactionManager | 分布式事务（JTA） |
源码解析（以 DataSourceTransactionManager 为例）：
public class DataSourceTransactionManager extends AbstractPlatformTransactionManager {
// 获取事务状态
@Override
protected Object doGetTransaction() {
DataSourceTransactionObject txObject = new DataSourceTransactionObject();
// 获取当前线程绑定的连接
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
txObject.setConnectionHolder(conHolder, false);
return txObject;
}
// 开启事务
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
Connection con = null;
try {
// 获取数据库连接
con = obtainDataSource().getConnection();
// 设置事务隔离级别、只读等属性
Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
txObject.setPreviousIsolationLevel(previousIsolationLevel);
// 关闭自动提交
con.setAutoCommit(false);
// 将连接绑定到当前线程
TransactionSynchronizationManager.bindResource(obtainDataSource(), new ConnectionHolder(con));
txObject.setConnectionHolder(new ConnectionHolder(con), true);
} catch (Throwable ex) {
// 处理异常
}
}
// 提交事务
@Override
protected void doCommit(DefaultTransactionStatus status) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
Connection con = txObject.getConnectionHolder().getConnection();
try {
con.commit();
} catch (SQLException ex) {
throw new TransactionSystemException("Could not commit JDBC transaction", ex);
}
}
// 回滚事务
@Override
protected void doRollback(DefaultTransactionStatus status) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
Connection con = txObject.getConnectionHolder().getConnection();
try {
con.rollback();
} catch (SQLException ex) {
throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
}
}
}
2. TransactionDefinition - 事务定义
TransactionDefinition 定义了事务的属性，包括隔离级别、传播行为、超时时间等。
接口定义：
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 = Connection.TRANSACTION_READ_UNCOMMITTED;
int ISOLATION_READ_COMMITTED = Connection.TRANSACTION_READ_COMMITTED;
int ISOLATION_REPEATABLE_READ = Connection.TRANSACTION_REPEATABLE_READ;
int ISOLATION_SERIALIZABLE = Connection.TRANSACTION_SERIALIZABLE;
int TIMEOUT_DEFAULT = -1;
// 获取传播行为
int getPropagationBehavior();
// 获取隔离级别
int getIsolationLevel();
// 获取超时时间
int getTimeout();
// 是否只读
boolean isReadOnly();
// 获取事务名称
String getName();
}
传播行为详解：
| 传播行为 | 说明 |
|---|---|
PROPAGATION_REQUIRED | 如果当前没有事务，则新建一个事务；如果已存在事务，则加入该事务（默认值） |
PROPAGATION_SUPPORTS | 支持当前事务，如果当前没有事务，则以非事务方式执行 |
PROPAGATION_MANDATORY | 必须在事务中运行，否则抛出异常 |
PROPAGATION_REQUIRES_NEW | 新建事务，如果当前存在事务，则挂起当前事务 |
PROPAGATION_NOT_SUPPORTED | 以非事务方式执行，如果当前存在事务，则挂起当前事务 |
PROPAGATION_NEVER | 以非事务方式执行，如果当前存在事务，则抛出异常 |
PROPAGATION_NESTED | 如果当前存在事务，则在嵌套事务内执行（部分数据库支持） |
源码示例（DefaultTransactionDefinition）：
public class DefaultTransactionDefinition implements TransactionDefinition, Serializable {
private int propagationBehavior = PROPAGATION_REQUIRED;
private int isolationLevel = ISOLATION_DEFAULT;
private int timeout = TIMEOUT_DEFAULT;
private boolean readOnly = false;
private String name;
// 设置传播行为
public void setPropagationBehavior(int propagationBehavior) {
this.propagationBehavior = propagationBehavior;
}
@Override
public int getPropagationBehavior() {
return this.propagationBehavior;
}
// 设置隔离级别
public void setIsolationLevel(int isolationLevel) {
this.isolationLevel = isolationLevel;
}
@Override
public int getIsolationLevel() {
return this.isolationLevel;
}
// 其他方法类似...
}
3. TransactionStatus - 事务状态
TransactionStatus 表示事务的当前状态，用于控制事务的执行和查询事务的状态。
接口定义：
public interface TransactionStatus extends SavepointManager {
// 是否是新事务
boolean isNewTransaction();
// 是否有保存点（用于嵌套事务）
boolean hasSavepoint();
// 设置事务回滚
void setRollbackOnly();
// 是否已标记为回滚
boolean isRollbackOnly();
// 事务是否已完成
boolean isCompleted();
}
源码解析（DefaultTransactionStatus）：
public class DefaultTransactionStatus extends AbstractTransactionStatus {
private final Object transaction;
private final boolean newTransaction;
private final boolean newSynchronization;
private final boolean readOnly;
private final boolean debug;
private final Object suspendedResources;
public DefaultTransactionStatus(Object transaction, boolean newTransaction,
boolean newSynchronization, boolean readOnly,
boolean debug, Object suspendedResources) {
this.transaction = transaction;
this.newTransaction = newTransaction;
this.newSynchronization = newSynchronization;
this.readOnly = readOnly;
this.debug = debug;
this.suspendedResources = suspendedResources;
}
@Override
public boolean isNewTransaction() {
return this.newTransaction;
}
@Override
public boolean hasSavepoint() {
return (this.savepoint != null);
}
@Override
public void setRollbackOnly() {
this.rollbackOnly = true;
}
@Override
public boolean isRollbackOnly() {
return this.rollbackOnly;
}
// 其他方法...
}
二、事务工作流程源码解析
1. 事务执行流程
2. 核心源码：TransactionAspectSupport
Spring 事务拦截器的核心逻辑位于 TransactionAspectSupport 类中：
public abstract class TransactionAspectSupport implements BeanFactoryAware {
protected Object invokeWithinTransaction(Method method, Class<?> targetClass,
final InvocationCallback invocation) throws Throwable {
// 获取事务属性
TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
// 获取事务管理器
PlatformTransactionManager tm = determineTransactionManager(txAttr);
// 创建事务
TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
Object retVal;
try {
// 执行业务方法
retVal = invocation.proceedWithInvocation();
} catch (Throwable ex) {
// 异常处理：回滚或提交
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
} finally {
cleanupTransactionInfo(txInfo);
}
// 提交事务
commitTransactionAfterReturning(txInfo);
return retVal;
}
protected void completeTransactionAfterThrowing(TransactionInfo txInfo, Throwable ex) {
// 判断是否需要回滚
if (txInfo.transactionAttribute.rollbackOn(ex)) {
try {
txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
} catch (TransactionSystemException ex2) {
// 处理回滚异常
}
} else {
// 提交事务
try {
txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
} catch (TransactionSystemException ex2) {
// 处理提交异常
}
}
}
}
三、高级特性与最佳实践
1. 编程式事务管理
直接使用三大接口进行事务控制：
@Service
public class OrderService {
@Autowired
private PlatformTransactionManager transactionManager;
public void createOrder(Order order) {
// 定义事务属性
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
def.setTimeout(30); // 30秒超时
// 获取事务状态
TransactionStatus status = transactionManager.getTransaction(def);
try {
// 执行业务逻辑
orderDao.save(order);
inventoryService.deductStock(order.getItems());
// 提交事务
transactionManager.commit(status);
} catch (Exception ex) {
// 回滚事务
transactionManager.rollback(status);
throw ex;
}
}
}
2. 声明式事务管理（推荐）
使用 @Transactional 注解简化事务管理：
@Service
public class OrderService {
@Transactional(
propagation = Propagation.REQUIRED,
isolation = Isolation.READ_COMMITTED,
timeout = 30,
rollbackFor = {BusinessException.class}
)
public void createOrder(Order order) {
orderDao.save(order);
inventoryService.deductStock(order.getItems());
}
}
3. 事务传播行为实战
场景：订单创建（外层事务）与日志记录（内层事务）
@Service
public class OrderService {
@Transactional(propagation = Propagation.REQUIRED)
public void createOrder(Order order) {
// 订单核心逻辑...
orderLogService.recordOrderLog(order); // 调用日志服务
}
}
@Service
public class OrderLogService {
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void recordOrderLog(Order order) {
// 日志记录逻辑（独立事务）
}
}
4. 事务同步器（TransactionSynchronization）
在事务生命周期中插入自定义逻辑：
@Component
public class AuditTransactionSynchronization implements TransactionSynchronization {
@Override
public void beforeCommit(boolean readOnly) {
// 提交前执行
System.out.println("准备提交事务");
}
@Override
public void afterCompletion(int status) {
// 事务完成后执行（成功或失败）
if (status == STATUS_COMMITTED) {
System.out.println("事务已提交");
} else if (status == STATUS_ROLLED_BACK) {
System.out.println("事务已回滚");
}
}
}
// 注册同步器
TransactionSynchronizationManager.registerSynchronization(new AuditTransactionSynchronization());
四、常见问题与解决方案
1. 事务不生效的常见原因
- 方法非 public：
@Transactional只能用于 public 方法 - 自调用问题：同一个类中方法调用不会经过代理
- 异常类型不匹配：默认只回滚 RuntimeException 和 Error
- 数据库引擎不支持：如 MyISAM 引擎不支持事务
2. 事务超时控制
@Transactional(timeout = 5) // 单位：秒
public void processLargeData() {
// 长时间操作
}
3. 只读事务优化
@Transactional(readOnly = true)
public Order getOrderDetails(Long orderId) {
// 查询操作
}
4. 分布式事务处理
使用 JTA 事务管理器：
@Bean
public PlatformTransactionManager transactionManager() {
return new JtaTransactionManager();
}
五、总结
Spring 事务管理的三大核心接口构成了其强大的事务抽象层：
PlatformTransactionManager：事务管理的核心，负责事务的生命周期TransactionDefinition：定义事务的属性，控制事务行为TransactionStatus：表示事务的当前状态，用于精细控制
通过理解这三个接口的协作机制，开发者可以：
- 深入掌握 Spring 事务的工作原理
- 灵活选择编程式或声明式事务管理
- 优化事务性能（如只读事务）
- 处理复杂的事务传播场景
- 实现分布式事务控制
在实际应用中，推荐使用声明式事务管理（@Transactional），它通过 AOP 实现了事务逻辑与业务逻辑的解耦，使代码更加简洁清晰。同时，理解底层原理有助于在复杂场景下进行问题排查和性能优化。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
