Relevant introduction to Spring transaction management (with code)

This article brings you an introduction to Spring transaction management (with code). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

Transaction

A logical group of operations. Each part of the operation either succeeds or fails.

Characteristics of transactions

• Consistency: The data integrity before and after the transaction remains consistent

• Atomicity: The transaction cannot be divided, either all succeed or all fail

• Isolation: The execution of a transaction is not affected by other transactions and is isolated from each other

• Persistence: Once the transaction is completed, it will be saved to the database and is not affected by the system Impact of crash

Problems caused if the characteristics are not met

Problems caused by isolation:

Read the question

• Dirty read: A transaction reads data that has not been committed by other transactions

• Non-repeatable read: A transaction reads data submitted by other transactionsUpdate Data, resulting in inconsistent query results for multiple times

• Phantom reading: One transaction reads insert data from another transaction, resulting in inconsistent query results for multiple times

Write problem

• Lost operation

Solving the read problem

Set transaction isolation Level

   int ISOLATION_DEFAULT = -1;
    int ISOLATION_READ_UNCOMMITTED = 1;
    int ISOLATION_READ_COMMITTED = 2;
    int ISOLATION_REPEATABLE_READ = 4;
    int ISOLATION_SERIALIZABLE = 8;

• ISOLATION_DEFAULT: Represents the spring default value, indicating that the default isolation level of the underlying database is used. For example, mysql uses ISOLATION_REPEATABLE_READ and uses ISOLATION_READ_COMMITTED

• ISOLATION_READ_UNCOMMITTED: Uncommitted read, cannot solve the read problem

• ISOLATION_READ_COMMITTED: Committed read, can solve the dirty problem Read, cannot solve phantom reads and non-repeatable reads

• ISOLATION_REPEATABLE_READ: Repeated reads, can solve dirty reads and non-repeatable reads

• ##ISOLATION_SERIALIZABLE: Can Solve all reading problems, the efficiency is not high

Transaction management api in Spring

PlatformTransactionManager: Platform transaction manager

PlatformTransactionManager is an interface, used by the bottom layer of Spring Object to manage transactions.

public interface PlatformTransactionManager {
    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
    void commit(TransactionStatus status) throws TransactionException;
    void rollback(TransactionStatus status) throws TransactionException;
}

spring things official website addressThe more common implementation classes are:

1. DataSourceTransactionManager: The bottom layer uses JDBC Transaction management

2. HibernateTransactionManager: The bottom layer uses Hibernate transaction management

• TransactionDefinition:

  Transaction definition: transactions can be defined Related information, transaction propagation behavior, isolation level, timeout information, whether read-only
  

package org.springframework.transaction;

//可以看到事物的定义也是一个接口
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;
    int ISOLATION_READ_COMMITTED = 2;
    int ISOLATION_REPEATABLE_READ = 4;
    int ISOLATION_SERIALIZABLE = 8;

    //事物的超时时间，-1代表没有超时时间
    int TIMEOUT_DEFAULT = -1;

    int getPropagationBehavior();

    int getIsolationLevel();

    int getTimeout();

    boolean isReadOnly();

    String getName();
}

• TransactionStatus: Transaction status

  Transaction status: Record management transaction process Objects in transaction status
  

The seven types of transaction propagation behaviors in Spring

The transaction propagation behavior is used to solve the problem of mutual calls between business methods

Official website portal

Precondition:

Call method A() in method B()

Nested transaction

• PROPAGATION_NESTED: There is a transaction in A, and transaction A is executed normally. After the execution of transaction A is completed, set a save point and perform operation B. If B throws an exception, it can be rolled back to the initial position or rolled back to the save point.

Ensure that the operation is in the same

• PROPAGATION_REQUIRED in the transaction: If method B calls method A and method A has a transaction, method B will use the transaction in A. If there is no transaction in A, B will create a transaction

• PROPAGATION_SUPPORTS: B calls A. If there is a transaction in A, the transaction in A will be used. If there is no transaction in A, B will not use the transaction

• PROPAGATION_MANDATORY: If A has a transaction, use the transaction in A. If there is no transaction in A, an exception will be thrown.

Ensure that the operations are not in the same

• PROPAGATION_REQUIRES_NEW in the transaction: There is a transaction in A, suspend the A transaction, and the opened transaction of B only includes its own operations. There is no transaction in A, and the transaction created by B only contains its own operation

• PROPAGATION_NOT_SUPPORTED: There is a transaction in A, A is suspended, and B does not use the transaction

  *PROPAGATION_NEVER: There is a transaction in A and B is thrown Exception
  

Spring provides two transaction management methods

• Declarative transaction management: Process transactions declaratively in the Spring configuration file To replace code-based transaction processing (used more often)

• Programming transaction management: code-based transaction processing requires writing code in the program
  Declarative transactions Management
  Based on xml

<!--配置事务管理器-->
    <bean id="trancationManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" >
        <property name="dataSource" ref="dataSource" ></property>
    </bean>
<!--配置事务-->
    <tx:advice id="myAdvice" transaction-manager="trancationManager">
        <tx:attributes>
            <!--配置事务传播和事务隔离-->
            <tx:method name="save*" propagation="REQUIRED" isolation="REPEATABLE_READ"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED" />
        </tx:attributes>
    </tx:advice>
    <!--事务是利用aop实现的-->
    <aop:config>
        <aop:pointcut id="ponitcut" expression="execution(* com.amber.xml.service.AccountServiceImpl.transferMoney(..))"></aop:pointcut>
        <aop:advisor advice-ref="myAdvice" pointcut-ref="ponitcut" />
    </aop:config>

save* indicates a method starting with save, uses PROPATATION_REQUIRED transaction propagation, and uses REPEATABLE_READ transaction isolation

基于注解

<!--配置事务管理器-->
    <bean id="trancationManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" >
        <property name="dataSource" ref="dataSource" ></property>
    </bean>
    <!--开启注解事务-->
    <tx:annotation-driven transaction-manager="trancationManager" />

使用tx:annotation-driven 开启事务的注解后，在使用的时候只需要在类或者方法上加入@Transactional就可以开启注解

基于xml的事务和基于注解的事务对比

• 文件配置对比
  事务基于注解简化了xml中的

• 使用比较
  使用注解必须在类或者方法上添加@Trasactional，如果有多个业务类，则需要在每个业务类上添加
  使用xml只需要在配置文件中配置包名即可

事务github代码

The above is the detailed content of Relevant introduction to Spring transaction management (with code). For more information, please follow other related articles on the PHP Chinese website!