Welche zwei Arten von Transaktionen gibt es in Java Spring?

1. Die Transaktionssteuerungsmethode von Spring

Die Transaktionssteuerung von Spring kann in Programmatische Transaktionen #🎜 unterteilt werden 🎜#Kontrolle und Deklarative Transaktionen Kontrolle.

Programmatic

Entwickler koppeln Transaktionscode und Geschäftscode direkt miteinander, was in der tatsächlichen Entwicklung nicht verwendet wird.

Deklarativ

Entwickler verwenden Konfiguration, um Transaktionskontrolle zu erreichen, Geschäftscode und Transaktionscode zu entkoppeln und AOP Thought zu verwenden.

2. Objekte im Zusammenhang mit der programmgesteuerten Transaktionssteuerung

2.1PlatformTransactionManager

PlatformTransactionManager-Schnittstelle ist die Transaktionsmanagerschnittstelle von Spring, die unsere häufig verwendete Methode zum Betreiben von Transaktionen bereitstellt .

2.2TransactionDefinition

Die TransactionDefinition-Schnittstelle stellt Transaktionsdefinitionsinformationen bereit ( (Transaktionsisolationsstufe, Transaktionsausbreitungsverhalten usw.) 🎜#Legen Sie die Isolationsstufe fest, um Probleme zu lösen, die durch die Parallelität von Transaktionen verursacht werden, wie z. B. Dirty Reads, nicht wiederholbare Lesevorgänge und virtuelle Lesevorgänge (Phantom Reads).

Hinweis: Verwenden Sie die Datenbank-Standardebene. Wenn es sich bei der Datenbank um MySQL handelt, ist die Standardeinstellung wiederholbares Lesen, Oracle ist lesefestgeschrieben.

ISOLATION_DEFAULT Datenbank-Standardebene verwenden ISOLATION_READ_UNCOMMITTED Nicht festgeschrieben lesen

ISOLATION_READ_COMMITTED Festgeschriebener Lesevorgang (kann Dirty-Read-Probleme lösen)

ISOLATION_REPEATABLE_READ Wiederholbarer Lesevorgang (kann Dirty-Read- und nicht wiederholbare Lesevorgänge lösen)#🎜 🎜# ISOLATION_SERIALIZABLE Serialisierung

kann gelöst werden: 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) Verhalten bei der Transaktionsausbreitung Das Verhalten bei der Transaktionsweitergabe bezieht sich darauf, wie die Transaktionssteuerung durchgeführt werden soll, wenn eine Geschäftsmethode von einer anderen Geschäftsmethode aufgerufen wird.

Wichtiger Punkt:

• schreibgeschützt (schreibgeschützt oder nicht): Es wird empfohlen, es bei der Abfrage von

• timeout (Timeout-Zeit) auf schreibgeschützt zu setzen ): Der Standardwert ist -1. Es gibt kein Timeout-Limit. Wenn ja, stellen Sie ihn in Sekunden ein.

2.3 TransactionStatus
Die TransactionStatus-Schnittstelle stellt den spezifischen Ausführungsstatus der Transaktion bereit.


Sie können die Beziehung zwischen den dreien einfach verstehen: Der Transaktionsmanager führt die Transaktionsverwaltung durch, indem er die Transaktionsdefinitionsparameter liest und dann eine Reihe von Transaktionsstatus generiert.

Die Transaktionssteuerung in Spring wird hauptsächlich über diese drei APIs implementiert.
PlatformTransactionManager ist für die Verwaltung von Transaktionen verantwortlich Verantwortlich für bestimmte Arbeiten
TransactionDefinition definiert einige relevante Parameter der Transaktion
TransactionStatus stellt einen Echtzeitstatus dar die laufende Transaktion# 🎜🎜#

Verstehen Sie die Beziehung zwischen den drei:

Transaktionsmanager

führt die Transaktionsverwaltung durch, indem er

Transaktionsdefinitionsparameter

liest und dann eine Reihe von #🎜 wird generiert 🎜#事STATUS

.
3. XML-basierte deklarative Transaktionssteuerung [Wichtige Punkte]
Deklarative Verarbeitung von Transaktionen in der Spring-Konfigurationsdatei anstelle der Codeverarbeitung. Die unterste Ebene wird mithilfe von AOP-Ideen implementiert.

Deklarative Transaktionskontrolle klärt Angelegenheiten:

Kerngeschäftscode (Zielobjekt) (Wer ist der Einstiegspunkt?)

# 🎜🎜#Transaktionserweiterungscode (Spring hat einen Transaktionsmanager bereitgestellt)) (Wer wird benachrichtigt?) #🎜🎜##🎜🎜#Aspektkonfiguration (Wie konfiguriere ich Aspekte?) (Aspekt = Pointcut + Benachrichtigung)#🎜🎜## 🎜🎜#3.1 Schnellstart#🎜🎜##🎜🎜# Verwenden Sie deklarative Frühlingstransaktionen, um das Transfergeschäft zu steuern. #🎜🎜##🎜🎜##🎜🎜#Schritte: #🎜🎜##🎜🎜##🎜🎜#1.Einführung des tx-Namespace#🎜🎜##🎜🎜#2.Transaction Manager-Benachrichtigungskonfiguration#🎜🎜 # #🎜🎜#3. Transaktionsmanager-AOP-Konfiguration #🎜🎜##🎜🎜#4. Testen Sie den Transaktionskontrollübertragungs-Geschäftscode #🎜🎜##🎜🎜#(1) Einführung des TX-Namespace #🎜🎜#

<?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
">

Nach dem Login kopieren

#🎜 🎜#( 2)Transaktionsmanager-Benachrichtigungskonfiguration#🎜🎜#

  <!--事务管理器对象-->
    <!--<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>

Nach dem Login kopieren

#🎜🎜#(3)Transaktionsmanager-AOP-Konfiguration #🎜🎜##🎜🎜#Wenn Sie Spring zum deklarativen Verwalten von Transaktionen verwenden, verwenden Sie die aop:advisor aop-Konfiguration! #🎜🎜#

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

Nach dem Login kopieren

#🎜🎜##🎜🎜# Detaillierte Konfiguration der Transaktionsparameter: #🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#

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

Nach dem Login kopieren

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

Nach dem Login kopieren

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

Nach dem Login kopieren

数据源配置类：

@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;
    }
}

Nach dem Login kopieren

Das obige ist der detaillierte Inhalt vonWelche zwei Arten von Transaktionen gibt es in Java Spring?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!