Cet article vous apporte une introduction pertinente à la gestion des transactions Spring (avec code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Transaction

Un ensemble logique d'opérations dont chaque partie réussit ou échoue

Caractéristiques de la transaction

Cohérence : L'intégrité des données reste cohérente avant et après la transaction
Atomicité : les transactions ne peuvent pas être divisées, soit toutes réussissent, soit toutes échouent
Isolement : l'exécution des transactions n'est pas affectée par d'autres transactions et est isolée les unes des autres
Persistance : Une fois qu'une transaction est terminée, elle sera enregistrée dans la base de données et n'est pas affectée par le système Impact de crash

Problèmes causés si les caractéristiques ne sont pas remplies

Problèmes causés par l'isolement :

Lire le numéro

Lecture sale : une transaction lit des données qui n'ont pas été validées par d'autres transactions
Lecture non répétable : une transaction lit mise à jour soumise par d'autres transactions Données , entraînant des résultats de requête incohérents
Lecture fantôme : une transaction lit les données d'insertion d'une autre transaction , ce qui entraîne des résultats de requête incohérents

Problème d'écriture

Opération perdue

Résoudre le problème de lecture

Définir le niveau d'isolement des transactions

Introduction pertinente à la gestion des transactions Spring (avec code)

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

Copier après la connexion

ISOLATION_DEFAULT : Représente la valeur par défaut de Spring, indiquant l'utilisation du niveau d'isolement par défaut de la base de données sous-jacente. Par exemple, MySQL utilise ISOLATION_REPEATABLE_READ et utilise ISOLATION_READ_COMMITTED
ISOLATION_READ_UNCOMMITTED : lecture non validée, ne peut pas résoudre le problème de lecture
ISOLATION_READ_COMMITTED : lecture validée, peut résoudre le sale problème Lire, ne peut pas résoudre les lectures fantômes et les lectures non répétables
ISOLATION_REPEATABLE_READ : les lectures répétées, peuvent résoudre les lectures sales et les lectures non répétables
ISOLATION_SERIALIZABLE : peut résoudre tous les problèmes de lecture, l'efficacité n'est pas élevée

API de gestion des transactions de Spring

PlatformTransactionManager : gestionnaire de transactions de plateforme
PlatformTransactionManager est une interface qui est utilisé par la couche inférieure de Spring Object pour gérer les transactions.
Introduction pertinente à la gestion des transactions Spring (avec code)

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

Copier après la connexion

Adresse du site officiel de Spring Thing
Les classes d'implémentation les plus courantes sont :

DataSourceTransactionManager : Couche inférieure Utiliser la gestion des transactions JDBC
HibernateTransactionManager : La couche inférieure utilise la gestion des transactions Hibernate

TransactionDefinition :
Définition de la transaction : OK Définir les informations relatives à la transaction, le comportement de propagation de la transaction, le niveau d'isolement, les informations de délai d'attente, s'il faut lire uniquement

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();
}

Copier après la connexion

TransactionStatus : Statut de la transaction
Statut de la transaction : objets qui enregistrent l'état de la transaction pendant le processus de gestion des transactions

Les sept types de comportements de propagation des transactions dans Spring

Les comportements de propagation des transactions sont utilisés pour résoudre le problème des appels mutuels entre méthodes métiers Problème

Portail du site officiel

Précondition :
Appeler la méthode A() dans la méthode B()

Transaction imbriquée

PROPAGATION_NESTED : Il y a une transaction dans A, et la transaction A est exécutée normalement. Une fois la transaction A exécutée, définissez un point de sauvegarde et effectuez l'opération B. Si B lève une exception, vous pouvez revenir à la position initiale ou revenir au point de sauvegarde

pour vous assurer que l'opération est dans la même Dans la transaction

PROPAGATION_REQUIRED : Si la méthode B appelle la méthode A et que la méthode A a une transaction, la méthode B utilisera la transaction dans A. S'il n'y a pas de transaction dans A, B créera une transaction
PROPAGATION_SUPPORTS : B appelle A, s'il y a une transaction dans A, la transaction dans A sera utilisée. S'il y a. aucune transaction dans A, B n'utilisera pas la transaction
PROPAGATION_MANDATORY : Si A a une transaction, utilisez la transaction dans A, et il n'y a pas de transaction dans A, lancez une exception

S'assurer que les opérations ne sont pas dans la même Dans la transaction

PROPAGATION_REQUIRES_NEW : Il y a une transaction dans A, suspendez la transaction A, et le La transaction ouverte de B ne comprend que ses propres opérations. Il n'y a pas de transaction dans A, et la transaction créée par B ne contient que sa propre opération
PROPAGATION_NOT_SUPPORTED : Il y a une transaction dans A, A est suspendu et B n'utilise pas la transaction
*PROPAGATION_NEVER : Il y a une transaction dans A et B est levée. Exception

Spring propose deux méthodes de gestion des transactions

Gestion déclarative des transactions : Traiter les transactions de manière déclarative dans le fichier de configuration Spring Pour remplacer le traitement des transactions basé sur le code (utilisé plus souvent)
Programmation de la gestion des transactions : le traitement des transactions basé sur le code nécessite l'écriture de code dans le programme
Gestion déclarative des transactions
est basée sur 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>

Copier après la connexion

save* représente une méthode commençant par save, utilise la propagation de transaction PROPATATION_REQUIRED et utilise la transaction REPEATABLE_READ isolement

基于注解

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

Copier après la connexion

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