深入解析Spring事務原理，一文帶你全面理解

作者：一安 2023-12-26 08:08:02

數據庫 MySQL

? 同一事務的多個實例在并發讀取數據時，會看到同樣的數據行（MySQL的默認事務隔離級別）。InnoDB和Falcon存儲引擎通過多版本并發控制（MVCC）機制解決了不可重復讀問題，存在幻讀問題。

前言

在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
執行目標方法，如果異常，獲取到事務管理器，利用事務管理回滾操作；如果正常，利用事務管理器，提交事務

責任編輯：武曉燕來源：一安未來

Spring 事務 MySQL