Apakah dua jenis transaksi dalam Java Spring?

1. Kaedah kawalan transaksi dalam Spring

Kawalan transaksi Spring boleh dibahagikan kepada transaksi terprogram kawalan dan Transaksi pengisytiharan kawalan.

Programmatik

Pembangun secara langsung menggabungkan kod transaksi dan kod perniagaan, yang tidak digunakan dalam pembangunan sebenar.

Deklaratif

Pembangun menggunakan konfigurasi untuk mencapai kawalan transaksi, memisahkan kod perniagaan dan kod transaksi serta menggunakan idea AOP.

2. Objek berkaitan kawalan transaksi terprogram

2.1PlatformTransactionManager

Antara muka PlatformTransactionManager ialah antara muka pengurus transaksi spring, yang menyediakan kaedah yang biasa kami gunakan untuk mengendalikan transaksi.

2.2TransactionDefinition

Antara muka TransactionDefinition menyediakan maklumat definisi transaksi (tahap pengasingan transaksi, tingkah laku penyebaran transaksi, dsb. )

(1) Tahap pengasingan transaksi

Menetapkan tahap pengasingan boleh menyelesaikan masalah yang disebabkan oleh konkurensi transaksi, seperti bacaan kotor , tidak tersedia Bacaan berulang dan bacaan maya (bacaan hantu).

Nota: Gunakan tahap lalai pangkalan data Jika pangkalan data ialah mysql, lalai boleh dibaca berulang, oracle dibaca komited.

ISOLATION_DEFAULT Gunakan tahap lalai pangkalan data

ISOLATION_READ_UNCOMMITTED Read Uncommitted

ISOLATION_READ_COMMITTED Read Committed (boleh menyelesaikan masalah bacaan kotor)

ISOLATION_REPEATABLE_READ Bacaan berulang (boleh menyelesaikan bacaan kotor, bacaan tidak berulang)

ISOLATION_SERIALIZABLE Pensiri

Boleh selesaikan:

(2) Tingkah laku penyebaran transaksi

Tingkah laku penyebaran transaksi merujuk kepada cara transaksi harus dijalankan apabila kaedah perniagaan dipanggil oleh kawalan kaedah perniagaan lain.

Isi penting:

• read-only (sama ada Baca sahaja): Adalah disyorkan untuk menetapkannya kepada baca sahaja apabila membuat pertanyaan

• timeout (tamat masa): Nilai lalai ialah -1, tiada had tamat masa. Jika ya, tetapkan dalam beberapa saat

2.3 TransactionStatus

Antara muka TransactionStatus menyediakan status berjalan khusus transaksi.

Anda hanya boleh memahami perhubungan antara ketiga-tiga: pengurus urus niaga melaksanakan pengurusan transaksi dengan membaca parameter definisi transaksi, dan kemudian menjana satu siri keadaan transaksi.

Kawalan transaksi dalam Spring dilaksanakan terutamanya melalui ketiga-tiga API ini

PlatformTransactionManager bertanggungjawab untuk pengurusan transaksi, dan subkelasnya bertanggungjawab untuk kerja tertentu

TransactionDefinition Mentakrifkan beberapa parameter urus niaga yang berkaitan

TransactionStatus Mewakili status masa nyata transaksi yang berjalan

Fahami perhubungan antara ketiga-tiga: Pengurus urus niaga membaca Parameter definisi transaksi melaksanakan pengurusan transaksi, dan kemudian satu siri keadaan transaksi akan dijana.

3. Kawalan transaksi perisytiharan berasaskan XML [Isi penting]

Pemprosesan deklaratif transaksi dalam fail konfigurasi Spring dan bukannya pemprosesan kod. Lapisan bawah dilaksanakan menggunakan idea AOP.

Kawalan urus niaga deklaratif perkara yang jelas:

Kod perniagaan teras (objek sasaran) (Siapakah titik masuk?)

Kod peningkatan transaksi (Musim bunga Pengurus transaksi telah disediakan)) (Siapa yang dimaklumkan?)

Konfigurasi aspek (Bagaimana untuk mengkonfigurasi aspek?) (Aspek = titik potong + pemberitahuan)

3.1 Permulaan Pantas

Gunakan transaksi deklaratif musim bunga untuk mengawal perniagaan pemindahan.

Langkah:

1 Pengenalan ruang nama tx

2. Konfigurasi pemberitahuan pengurus transaksi

3

4. Uji kod perniagaan pemindahan kawalan transaksi

(1) Pengenalan ruang nama 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) Konfigurasi pemberitahuan pengurus transaksi

rreee

(3 ) Konfigurasi AOP pengurus transaksi

Apabila menggunakan musim bunga untuk mengurus urus niaga secara deklaratif, gunakan aop:advisor untuk mengkonfigurasi aop!

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

Konfigurasi terperinci parameter transaksi:

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

Atas ialah kandungan terperinci Apakah dua jenis transaksi dalam Java Spring?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!