前言
在Spring中，事務管理主要通過AOP功能實現，對方法前后進行攔截，將事務處理的功能編織到攔截的方法中，Spring支持編程式事務管理和聲明式事務管理兩種方式。
- 聲明式事務
- @Transactional
- 編程式事務
TransactionTemplate
TransactionManager
四大特性
- 原子性（Atomicity）：一個事務中的所有操作，要么都完成，要么都不執行。對于一個事務來說，不可能只執行其中的一部分。
- 一致性（Consistency）：數據庫總是從一個一致性的狀態轉換到另外一個一致性狀態，事務前后數據的完整性必須保持一致。。
- 隔離性（Isolation）：一個事務所做的修改在最終提交以前，對其它事務是不可見的，多個事務之間的操作相互不影響。
- 持久性（Durability）：持久性是指一個事務一旦被提交，它對數據庫中數據的改變就是永久性的，接下來即使數據庫發生故障也不應該對其有任何影響。
隔離級別
- Read Uncommitted（讀取未提交內容）：一個事務可以看到其他事務已執行但是未提交的結果。本隔離級別很少用于實際應用，因為它的性能也不比其他級別好多少，并且存在臟讀問題。
- Read Committed（讀取已提交內容）：一個事務只能看到其他事務已執行并已提交的結果（Oracle、SQL Server默認隔離級別）。這種隔離級別支持不可重復讀，因為同一事務的其他實例在該實例處理期間可能會有新的commit，所以同一select可能返回不同結果。
- Repeatable Read（可重讀）：同一事務的多個實例在并發讀取數據時，會看到同樣的數據行（MySQL的默認事務隔離級別）。InnoDB和Falcon存儲引擎通過多版本并發控制（MVCC）機制解決了不可重復讀問題，存在幻讀問題。
- Serializable（可串行化）：最高的隔離級別，它通過強制事務排序，使之不可能相互沖突，從而解決幻讀問題。它是在每個讀的數據行上加上共享鎖。在這個級別，可能導致大量的超時現象和鎖競爭。
隔離級別 | 臟讀 | 不可重復讀 | 幻讀 |
Read Uncommitted | √ | √ | √ |
Read Committed | × | √ | √ |
Repeatable Read | × | × | √ |
Serializable | × | × | × |
傳播級別
傳播級別 | 含義 |
PROPAGATION_REQUIRED | 支持當前事務，如果當前沒有事務，則新建一個事務 |
PROPAGATION_SUPPORTS | 支持當前事務，如果當前沒有事務，則以非事務進行 |
PROPAGATION_MANDATORY | 支持當前事務，如果當前沒有事務，則拋異常 |
PROPAGATION_REQUIRES_NEW | 新建事務，如果當前存在事務，則把當前事務掛起 |
PROPAGATION_NESTED | 如果當前存在事務，則在嵌套事務內執行。如果沒有，則進行與PROPAGATION_REQUIRED類似操作 |
PROPAGATION_NOT_SUPPORTED | 以非事務進行，如果當前存在事務，則掛起事務，執行當前邏輯，結束后恢復上下文的事務 |
PROPAGATION_NEVER | 以非事務進行，如果當前存在事務，則拋異常 |
案例
導入相關依賴
數據源、數據庫驅動、spring-jdbc模塊
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.3.12.RELEASE</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.44</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.10</version>
</dependency>配置數據源
配置數據源、JdbcTemplate（Spring提供的簡化數據庫操作的工具）操作數據
@Bean
public DataSource dataSource(){
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUsername("root");
dataSource.setPassword("root");
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/scp");
return dataSource;
}
@Bean
public JdbcTemplate jdbcTemplate(){
//Spring對@Configuration類會特殊處理；給容器中加組件的方法，多次調用都只是從容器中找組件
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource());
return jdbcTemplate;
}數據訪問
@Repository
public class UserDao {
@Autowired
private JdbcTemplate jdbcTemplate;
@Transactional
public void insert(){
String sql = "INSERT INTO user (name,age) VALUES(?,?)";
String username = UUID.randomUUID().toString().substring(0, 5);
jdbcTemplate.update(sql, username,19);
int a = 1/0;
}
}開啟事務，配置事務管理器
@EnableTransactionManagement // 開啟事務
@ComponentScan("org.yian")
@Configuration
public class TxConfig {
//數據源
@Bean
public DataSource dataSource(){
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUsername("root");
dataSource.setPassword("root");
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/scp");
return dataSource;
}
@Bean
public JdbcTemplate jdbcTemplate(){
//Spring對@Configuration類會特殊處理；給容器中加組件的方法，多次調用都只是從容器中找組件
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource());
return jdbcTemplate;
}
//注冊事務管理器在容器中
@Bean
public PlatformTransactionManager transactionManager(){
return new DataSourceTransactionManager(dataSource());
}
}測試類
@Test
public void test01(){
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(TxConfig.class);
UserService userService = applicationContext.getBean(UserService.class);
userService.insertUser();
applicationContext.close();
}原理
Spring 事務管理的實現原理主要涉及兩個方面：事務管理器和代理機制：
- 事務管理器（Transaction Manager）:
Spring通過PlatformTransactionManager接口定義了事務管理器的標準。這個接口有多個實現，包括常用的DataSourceTransactionManager、JpaTransactionManager、HibernateTransactionManager等，每個都專門用于不同的持久化技術。
事務管理器的主要職責是開始、提交或回滾事務。當使用聲明式事務管理時，開發者只需要配置相應的事務管理器，而不必親自編寫事務管理的代碼
- 代理機制：
Spring 通過代理機制為事務管理提供支持。它使用AOP來在方法調用前后添加額外的邏輯，即切面。在事務管理中，這個額外的邏輯包括開啟、提交或回滾事務。
當使用聲明式事務管理時，Spring 會動態創建一個代理對象，該代理對象包裝了目標對象（擁有業務邏輯的對象）。在方法調用時，代理對象會在執行前后添加事務管理的邏輯
@EnableTransactionManagement：
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({TransactionManagementConfigurationSelector.class})
public @interface EnableTransactionManagement {
boolean proxyTargetClass() default false;
AdviceMode mode() default AdviceMode.PROXY;
int order() default Integer.MAX_VALUE;
}TransactionManagementConfigurationSelector：
public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {
public TransactionManagementConfigurationSelector() {
}
protected String[] selectImports(AdviceMode adviceMode) {
switch (adviceMode) {
case PROXY:
return new String[]{AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()};
case ASPECTJ:
return new String[]{this.determineTransactionAspectClass()};
default:
return null;
}
}
private String determineTransactionAspectClass() {
return ClassUtils.isPresent("javax.transaction.Transactional", this.getClass().getClassLoader()) ? "org.springframework.transaction.aspectj.AspectJJtaTransactionManagementConfiguration" : "org.springframework.transaction.aspectj.AspectJTransactionManagementConfiguration";
}
}EnableTransactionManagement 會利用 TransactionManagementConfigurationSelector 給容器中會導入兩個組件 AutoProxyRegistrar、 ProxyTransactionManagementConfiguration
AutoProxyRegistrar：
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
boolean candidateFound = false;
Set<String> annTypes = importingClassMetadata.getAnnotationTypes();
Iterator var5 = annTypes.iterator();
while(var5.hasNext()) {
String annType = (String)var5.next();
AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
if (candidate != null) {
Object mode = candidate.get("mode");
Object proxyTargetClass = candidate.get("proxyTargetClass");
if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() && Boolean.class == proxyTargetClass.getClass()) {
candidateFound = true;
if (mode == AdviceMode.PROXY) {
AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
if ((Boolean)proxyTargetClass) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
return;
}
}
}
}
}AutoProxyRegistrar 給容器中注冊一個 InfrastructureAdvisorAutoProxyCreator 組件，利用后置處理器機制在對象創建以后，包裝對象，返回一個代理對象（增強器），代理對象執行方法利用攔截器鏈進行調用
ProxyTransactionManagementConfiguration：
public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) {
BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
advisor.setTransactionAttributeSource(transactionAttributeSource);
advisor.setAdvice(transactionInterceptor);
if (this.enableTx != null) {
advisor.setOrder((Integer)this.enableTx.getNumber("order"));
}
return advisor;
}ProxyTransactionManagementConfiguration 給容器中注冊事務增強器
public TransactionAttributeSource transactionAttributeSource() {
return new AnnotationTransactionAttributeSource();
}事務增強器要用事務注解的信息，AnnotationTransactionAttributeSource解析事務注解
public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {
TransactionInterceptor interceptor = new TransactionInterceptor();
interceptor.setTransactionAttributeSource(transactionAttributeSource);
if (this.txManager != null) {
interceptor.setTransactionManager(this.txManager);
}
return interceptor;
}事務攔截器TransactionInterceptor保存了事務屬性信息，事務管理器，并且實現了 MethodInterceptor，在目標方法執行的時候執行攔截器鏈（事務攔截器）
TransactionAspectSupport：
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass, InvocationCallback invocation) throws Throwable {
TransactionAttributeSource tas = this.getTransactionAttributeSource();
TransactionAttribute txAttr = tas != null ? tas.getTransactionAttribute(method, targetClass) : null;
TransactionManager tm = this.determineTransactionManager(txAttr);
Object retVal;
if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
boolean isSuspendingFunction = KotlinDetector.isSuspendingFunction(method);
boolean hasSuspendingFlowReturnType = isSuspendingFunction && "kotlinx.coroutines.flow.Flow".equals((new MethodParameter(method, -1)).getParameterType().getName());
ReactiveTransactionSupport txSupport = (ReactiveTransactionSupport)this.transactionSupportCache.computeIfAbsent(method, (key) -> {
Class<?> reactiveType = isSuspendingFunction ? (hasSuspendingFlowReturnType ? Flux.class : Mono.class) : method.getReturnType();
ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(reactiveType);
if (adapter == null) {
throw new IllegalStateException("Cannot apply reactive transaction to non-reactive return type: " + method.getReturnType());
} else {
return new ReactiveTransactionSupport(adapter);
}
});
retVal = txSupport.invokeWithinTransaction(method, targetClass, invocation, txAttr, (ReactiveTransactionManager)tm);
return isSuspendingFunction ? (hasSuspendingFlowReturnType ? TransactionAspectSupport.KotlinDelegate.asFlow((Publisher)retVal) : TransactionAspectSupport.KotlinDelegate.awaitSingleOrNull((Publisher)retVal, ((CoroutinesInvocationCallback)invocation).getContinuation())) : retVal;
} else {
PlatformTransactionManager ptm = this.asPlatformTransactionManager(tm);
String joinpointIdentification = this.methodIdentification(method, targetClass, txAttr);
.............................
.............................
.............................
- 先獲取事務相關的屬性
- 再獲取PlatformTransactionManager，如果事先沒有添加指定任何transactionmanger，最終會從容器中按照類型獲取一個PlatformTransactionManager
- 執行目標方法，如果異常，獲取到事務管理器，利用事務管理回滾操作；如果正常，利用事務管理器，提交事務
