文章目录
1、Spring如何管理事务
Spring为事务管理提供了一致的编程模板，在高层次上建立了统一的事务抽象。也就是说，不管是选择 MyBatis、Hibernate、JPA还是Spring JDBC，Spring都可以让用户以统一的编程模型进行事务管理。
Spring支持两种事务编程模型：
- 编程式事务
Spring提供了TransactionTemplate模板，利用该模板我们可以通过编程的方式实现事务管理，而无需关注资源获取、复用、释放、事务同步及异常处理等操作。相对于声明式事务来说，这种方式相对麻烦一些，但是好在更为灵活，我们可以将事务管理的范围控制的更为精确。 - 声明式事务
Spring事务管理的亮点在于声明式事务管理，它允许我们通过声明的方式，在IoC配置中指定事务的边界和事务属性，Spring会自动在指定的事务边界上应用事务属性。相对于编程式事务来说，这种方式十分的方便，只需要在需要做事务管理的方法上，增加@Transactional注解，以声明事务特征即可。
2、编程式事务
在Spring框架中，TransactionTemplate是一个用于编程式事务管理的工具类。它提供了一种在代码中显式控制事务边界的方式，使开发人员可以在方法级别定义事务的开始和结束点。TransactionTemplate 简化了事务管理的操作，同时提供了一些附加功能，如事务传播行为和异常回滚。
1_基本用法
在使用TransactionTemplate之前，我们需要先配置一个事务管理器。事务管理器负责管理事务的生命周期，并与数据源进行关联。常用的事务管理器包括DataSourceTransactionManager、JpaTransactionManager等，根据具体的持久化技术选择相应的事务管理器。这可以在Spring 的配置文件中完成，只需要配置好数据源就可以使用了。也可以使用如下方式：
@Configuration
public class AppConfig {
@Bean
public DataSource dataSource() {
// 配置数据源
return new DriverManagerDataSource();
}
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}
@Bean
public TransactionTemplate transactionTemplate(PlatformTransactionManager transactionManager) {
return new TransactionTemplate(transactionManager);
}
}
2_创建TransactionTemplate实例
配置完事务管理器后，我们可以在需要进行事务管理的地方创建一个TransactionTemplate实例。TransactionTemplate提供了execute()方法，该方法接受一个TransactionCallback作为参数，并在事务的上下文中执行其中的代码。
//需要一个回调接口的实现执行内部具体的业务逻辑
public <T> T execute(TransactionCallback<T> action) throws TransactionException
下面是一个创建TransactionTemplate实例并使用execute()方法的示例。
@SpringBootTest
public class Test {
@Autowired
private TransactionTemplate transactionTemplate;
@Autowired
private EmpService empService;
@org.junit.jupiter.api.Test
public void test() {
transactionTemplate.setIsolationLevel(TransactionTemplate.ISOLATION_READ_COMMITTED);
transactionTemplate.execute(new TransactionCallback<Object>() {
@Override
public Object doInTransaction(TransactionStatus status) {
Emp build = Emp.builder().username("sheny").password("123456")
.name("shenyang").gender((short) 1)
.job((short) 3).entrydate(LocalDate.now())
.deptId(2)
.createTime(LocalDateTime.now())
.updateTime(LocalDateTime.now()).build();
empService.save(build);
int a = 1 / 0;
System.out.println(a);
return null;
}
});
}
@org.junit.jupiter.api.Test
public void test2() {
Emp build = Emp.builder().username("sheny").password("123456")
.name("shenyang").gender((short) 1)
.job((short) 3).entrydate(LocalDate.now())
.deptId(2)
.createTime(LocalDateTime.now())
.updateTime(LocalDateTime.now()).build();
empService.save(build);
int a = 1 / 0;
System.out.println(a);
}
}
在上述示例中，我们通过调用execute()方法来执行事务操作。TransactionCallback的doInTransaction()方法中的代码将在事务的上下文中执行。如果在doInTransaction()方法中发生了未捕获的异常，事务将被标记为回滚，并回滚到事务的起点；如果doInTransaction()方法正常完成，事务将被提交。
3_TransactionTemplate的内部结构
继承自 DefaultTransactionDefinition 内部具有事务定义相关的逻辑如：隔离级别、事务的传播行为。实现了TransactionOperations,和InitializingBean接口定义了了事务相关操作和bean生命周期中初始化的相关操作。
public class TransactionTemplate extends DefaultTransactionDefinition
implements TransactionOperations, InitializingBean {
@Nullable
private PlatformTransactionManager transactionManager;.
public TransactionTemplate(PlatformTransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
可以看到内部维护了一个 PlatformTransactionManager 变量，也就是说它封装了事务管理的细节，避免直接操作 PlatformTransactionManager 的复杂性，简化了事务的处理过程。开发者可以在编程式事务管理中以更简洁的方式处理事务逻辑。如下：
@Override
@Nullable
public <T> T execute(TransactionCallback<T> action) throws TransactionException {
Assert.state(this.transactionManager != null, "No PlatformTransactionManager set");
if (this.transactionManager instanceof CallbackPreferringPlatformTransactionManager cpptm) {
return cpptm.execute(this, action);
}
else {
TransactionStatus status = this.transactionManager.getTransaction(this);
T result;
try {
result = action.doInTransaction(status);
}
catch (RuntimeException | Error ex) {
// Transactional code threw application exception -> rollback
rollbackOnException(status, ex);
throw ex;
}
catch (Throwable ex) {
// Transactional code threw unexpected exception -> rollback
rollbackOnException(status, ex);
throw new UndeclaredThrowableException(ex, "TransactionCallback threw undeclared checked exception");
}
this.transactionManager.commit(status);
return result;
}
}
setIsolationLevel()方法可以设置事务的隔离级别、setPropagationBehavior()方法可以设置事务的传播行为（通常使用TransactionTemplate.PROPAGATION_REQUIRED这种方式设置）：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;
@Service
public class TransactionalService {
@Autowired
private TransactionTemplate transactionTemplate;
public void performTransactionalOperation() {
transactionTemplate.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRED);
transactionTemplate.setIsolationLevel(TransactionTemplate.ISOLATION_READ_COMMITTED);
transactionTemplate.execute(new TransactionCallback<Void>() {
public Void doInTransaction(TransactionStatus status) {
// 在这里执行事务操作
// 可以进行数据库操作、调用其他需要事务支持的方法等
return null;
}
});
}
}
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; // same as java.sql.Connection.TRANSACTION_READ_UNCOMMITTED;
int ISOLATION_READ_COMMITTED = 2; // same as java.sql.Connection.TRANSACTION_READ_COMMITTED;
int ISOLATION_REPEATABLE_READ = 4; // same as java.sql.Connection.TRANSACTION_REPEATABLE_READ;
int ISOLATION_SERIALIZABLE = 8; // same as java.sql.Connection.TRANSACTION_SERIALIZABLE;
}
4_总结
TransactionTemplate提供了一种在代码中进行编程式事务管理的方式，使开发人员能够在方法级别定义事务的开始和结束点。通过配置事务管理器并使用TransactionTemplate，我们可以方便地执行事务操作，并根据需要设置传播行为和隔离级别。希望本文能够帮助你更好地理解和应用Spring的事务管理功能。
3、声明式事务
声明式事务管理是基于AOP（面向切面编程）的，它通过配置来管理事务，而不是通过代码显式地控制。Spring的声明式事务管理使用@Transactional注解来简化事务管理的配置。
1_使用@Transactional注解
在Spring中，@Transactional注解用于标记那些需要事务管理的方法或类。Spring会在运行时自动为这些方法或类提供事务支持。以下是一个使用@Transactional注解的示例：
@Service
public class UserService {
@Transactional
public void updateUser(User user) {
// 执行业务操作
// 该方法的所有操作都在一个事务中执行
}
}
事务的打开、回滚和提交是由事务管理器来完成的，我们使用不同的数据库访问框架，就要使用与之对应的事务管理器。在Spring Boot中，当你添加了数据库访问框架的起步依赖时，它就会进行自动配置，即自动实例化正确的事务管理器。
对于声明式事务，是使用@Transactional进行标注的。这个注解可以标注在类或者方法上。当它标注在类上时，代表这个类所有公共（public）非静态的方法都将启用事务功能。当它标注在方法上时，代表这个方法将启用事务功能。
另外，在@Transactional注解上，我们可以使用isolation属性声明事务的隔离级别，使用propagation属性声明事务的传播机制，rollbackFor属性声明针对什么异常进行回滚。
2_事务的传播行为
当我们调用一个业务方法时，它的内部可能会调用其他的业务方法，以完成一个完整的业务操作。这种业务方法嵌套调用的时候，如果这两个方法都是要保证事务的，那么就要通过Spring的事务传播机制控制当前事务如何传播到被嵌套调用的业务方法中。
Spring在TransactionDefinition接口中规定了7种类型的事务传播行为，它们规定了事务方法和事务方法发生嵌套调用时如何进行传播，如下表：
| 属性值 | 含义 |
|---|---|
| REQUIRED | 【默认值】需要事务，有则加入，无则创建新事务 |
| REQUIRES_NEW | 需要新事务，无论有无，总是创建新事务 |
| SUPPORTS | 支持事务，有则加入，无则在无事务状态中运行 |
| NOT_SUPPORTED | 不支持事务，在无事务状态下运行,如果当前存在已有事务,则挂起当前事务 |
| MANDATORY | 必须有事务，否则抛异常 |
| NEVER | 必须没事务，否则抛异常 |
| NESTED | 当前存在事务，则在嵌套事务内执行；如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。 |
3_配置
真正开启事务支持的注解是@EnableTransactionManagement注解。但是如果我们引入 starter 起步依赖会采用自动装配的方式自动开启事务支持。
4_总结
Spring事务管理的亮点在于声明式事务管理，它允许我们通过声明的方式，在IoC配置中指定事务的边界和事务属性，Spring会自动在指定的事务边界上应用事务属性。相对于编程式事务来说，这种方式十分的方便，只需要在需要做事务管理的方法上，增加@Transactional注解，以声明事务特征即可。
