Quels sont les deux types de transactions dans Java Spring ?

1. Méthode de contrôle des transactions dans Spring

Le contrôle des transactions de Spring peut être divisé en Transactions programmatiques #🎜 🎜#Contrôle et Transactions déclaratives Contrôle.

Programmatic

Les développeurs associent directement le code de transaction et le code métier, ce qui n'est pas utilisé dans le développement réel.

Declarative

Les développeurs utilisent la configuration pour contrôler les transactions, dissocier le code métier et le code de transaction et utiliser AOP Thought.

2. Objets liés au contrôle programmatique des transactions

2.1PlatformTransactionManager

L'interface PlatformTransactionManager est l'interface du gestionnaire de transactions de Spring, qui fournit notre méthode couramment utilisée pour gérer les transactions. .

2.2TransactionDefinition

L'interface TransactionDefinition fournit des informations de définition de transaction ( Niveau d'isolement des transactions, comportement de propagation des transactions, etc.) 🎜#Définissez le niveau d'isolement pour résoudre les problèmes causés par la concurrence des transactions, tels que les lectures sales, les lectures non répétables et les lectures virtuelles (lectures fantômes).

Remarque : Utilisez le niveau par défaut de la base de données. Si la base de données est MySQL, la valeur par défaut est une lecture répétable, Oracle est validé en lecture.

ISOLATION_DEFAULT Utiliser le niveau par défaut de la base de données ISOLATION_READ_UNCOMMITTED Lire non validé

ISOLATION_READ_COMMITTED Lecture validée (peut résoudre le problème de lecture sale)

ISOLATION_REPEATABLE_READ Lecture répétable (peut résoudre le problème de lecture sale, lecture non répétable)#🎜 🎜# ISOLATION_SERIALIZABLE La sérialisation

peut être résolue : ISOLATION_DEFAULT 使用数据库默认级别

ISOLATION_READ_UNCOMMITTED 读未提交

ISOLATION_READ_COMMITTED 读已提交（可解决脏读问题）

ISOLATION_REPEATABLE_READ 可重复读 （可解决脏读、不可重复读）

ISOLATION_SERIALIZABLE 串行化

可解决：

（2）事务传播行为

事务传播行为指的就是当一个业务方法【被】另一个业务方法调用时，应该如何进行事务控制。

重点：

• read-only（是否只读）：建议查询时设置为只读

• timeout（超时时间）：默认值是-1，没有超时限制。如果有，以秒为单位进行设置

2.3 TransactionStatus

TransactionStatus 接口提供的是事务具体的运行状态。

可以简单的理解三者的关系：事务管理器通过读取事务定义参数进行事务管理，然后会产生一系列的事务状态。

Spring中的事务控制主要就是通过这三个API实现的

PlatformTransactionManager 负责事务的管理，它是个接口，其子类负责具体工作

TransactionDefinition 定义了事务的一些相关参数

TransactionStatus

(2) Comportement de propagation des transactions Le comportement de propagation des transactions fait référence à la manière dont le contrôle des transactions doit être effectué lorsqu'une méthode métier est appelée par une autre méthode métier.

Point clé :

• lecture seule (lecture seule ou non) : Il est recommandé de le définir en lecture seule lors de l'interrogation de

• timeout (délai d'expiration ) : La valeur par défaut est -1, il n'y a pas de limite de délai d'attente. Si tel est le cas, définissez-le en secondes

2.3 TransactionStatus
L'interface TransactionStatus fournit l'état d'exécution spécifique de la transaction.


Vous pouvez simplement comprendre la relation entre les trois : le gestionnaire de transactions effectue la gestion des transactions en lisant les paramètres de définition de la transaction, puis génère une série d'états de transaction.

Le contrôle des transactions dans Spring est principalement implémenté via ces trois API
PlatformTransactionManager est responsable de la gestion des transactions. un travail spécifique
TransactionDefinition définit certains paramètres pertinents de la transaction
TransactionStatus représente un statut en temps réel de la transaction running# 🎜🎜#

Comprendre la relation entre les trois :

Transaction manager

effectue la gestion des transactions en lisant

paramètres de définition de transaction

, puis une série de #🎜 sera généré 🎜#事STATUS

.
3. Contrôle déclaratif des transactions basé sur XML [Points clés]
Traitement déclaratif des transactions dans le fichier de configuration Spring au lieu du traitement du code. La couche inférieure est implémentée à l'aide des idées AOP.

Le contrôle déclaratif des transactions est clair :

Code métier principal (objet cible) (Qui est le point d'entrée ?)

# 🎜🎜#Code d'amélioration des transactions (Spring a fourni un gestionnaire de transactions)) (Qui est notifié ?) #🎜🎜##🎜🎜#Configuration des aspects (Comment configurer les aspects ?) (Aspect = pointcut + notification)#🎜🎜## 🎜🎜#3.1 Démarrage rapide#🎜🎜##🎜🎜# Utilisez les transactions déclaratives du printemps pour contrôler l'activité de transfert. #🎜🎜##🎜🎜##🎜🎜#Étapes : #🎜🎜##🎜🎜##🎜🎜#1.Présentation de l'espace de noms tx#🎜🎜##🎜🎜#2.Configuration des notifications du gestionnaire de transactions#🎜🎜 # #🎜🎜#3. Configuration AOP du gestionnaire de transactions #🎜🎜##🎜🎜#4. Testez le code commercial de transfert de contrôle des transactions #🎜🎜##🎜🎜#(1) Introduire l'espace de noms tx #🎜🎜#

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
       	http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd
       	http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/tx
		http://www.springframework.org/schema/tx/spring-tx.xsd
		http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop.xsd
">

#🎜 🎜#( 2)Configuration de notification du gestionnaire de transactions#🎜🎜#

  <!--事务管理器对象-->
    <!--<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>--> 
// 通知增强
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
       //定义事务的一些属性 * 表示当前任意名称的方法都走默认配置
     <!--
            name: 切点方法名称
            isolation：事务的隔离级别
            propagation：事务的传播行为
            read-only：是否只读
            timeout：超时时间
        -->
        <tx:attributes>
            <tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" timeout="-1"/>
            //CRUD常用配置
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

#🎜🎜#(3)Configuration AOP du gestionnaire de transactions #🎜🎜##🎜🎜#Lorsque vous utilisez Spring pour gérer les transactions de manière déclarative, utilisez la configuration aop:advisor aop ! #🎜🎜#

//aop配置：配置切面   
<aop:config>  
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.lagou.servlet.impl.AccountServiceImpl.*(..))"/>
    </aop:config>-->

#🎜🎜##🎜🎜# Configuration détaillée des paramètres de transaction : #🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#

• name：切点方法名称

• isolation:事务的隔离级别

• propogation：事务的传播行为

• timeout：超时时间

• read-only：是否只读

4.基于注解的声明式事务控制（重点）

步骤：

• 修改service层，增加事务注解

• 修改spring核心配置文件，开启事务注解支持

4.1 修改service层，增加事务注解

@Service
public class AccountServiceImpl implements AccountService {
  @Autowired
  private AccountDao accountDao;
    @Transactional(propagation = Propagation.REQUIRED, isolation =
Isolation.REPEATABLE_READ, timeout = -1, readOnly = false)
  @Override
  public void transfer(String outUser, String inUser, Double money) {
    accountDao.out(outUser, money);
    int i = 1 / 0;
    accountDao.in(inUser, money);
 }
}

4.2修改spring核心配置文件，开启事务注解支持

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w2.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xmlns:tx="http://www.springframework.org/schema/tx"
   xsi:schemaLocation="
   http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
   http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
   http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
   http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
  <!--省略之前datsSource、jdbcTemplate、组件扫描配置-->
  <!--事务管理器-->
  <bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
  </bean>
  <!--事务的注解支持-->
  <tx:annotation-driven/>
</beans

4.3纯注解方式

核心配置类：

@Configuration  // 声明该类为核心配置类
@ComponentScan("com.lagou")  // 包扫描
@Import(DataSourceConfig.class) //导入其他配置类
@EnableTransactionManagement //事务的注解驱动
public class SpringConfig {
    @Bean
    public JdbcTemplate getJdbcTemplate(@Autowired DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        return jdbcTemplate;
    }
    @Bean
    public PlatformTransactionManager getPlatformTransactionManager(@Autowired DataSource dataSource){
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager(dataSource);
        return dataSourceTransactionManager;
    }
}

数据源配置类：

@PropertySource("classpath:jdbc.properties") //引入properties文件
public class DataSourceConfig {
    @Value("${jdbc.driverClassName}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    @Bean //会把当前方法的返回值对象放进IOC容器中
    public DataSource getDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driver);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!