当前位置： 首页 > article >正文

【Spring】4—声明式事务

article 2024/11/15 1:37:15

⭐⭐⭐⭐⭐⭐
Github主页👉https://github.com/A-BigTree
笔记链接👉https://github.com/A-BigTree/Code_Learning
⭐⭐⭐⭐⭐⭐

如果可以，麻烦各位看官顺手点个star~😊

如果文章对你有所帮助，可以点赞👍收藏⭐支持一下博主~😆

文章目录

  • 4 声明式事务
    • 4.1 `JDBCTemplate`
      • 4.1.1 简介
      • 4.1.2 加入依赖和资源文件
        • jdbc.properties
        • Spring配置文件
        • 测试
      • 4.1.3 基本用法
        • 增删改操作
        • 查询返回简单类型
        • 查询返回实体类型
    • 4.2 声明式事务概念
      • 4.2.1 声明式事务
      • 4.2.2 事务管理器
        • 技术体系
    • 4.3 基于注解的声明式事务
      • 4.3.1 准备工作
        • 加入依赖
        • 外部属性文件
        • Spring配置文件
        • 测试类
        • 创建组件
      • 4.3.2 应用最基本的事务控制
        • 加事务前状态
        • 添加事务功能
        • 开启基于注解的声明式事务功能
        • 在Service方法上添加注解
      • 4.3.3 只读
        • 介绍
        • 设置方式
        • `@Transactional`注解放在类中
      • 4.3.4 超时
        • 需求
        • 设置
      • 4.3.5 回滚和不回滚的异常
        • 默认情况
        • 设置回滚的异常
        • 设置不回滚的异常
        • 回滚和不回滚同时设置
      • 4.3.6 事务隔离级别
        • 问题
        • 测试读未提交
        • 测试读已提交
      • 4.3.7 事务传播行为
        • 问题
        • `propagation`属性
        • 测试
        • REQUIRED模式
        • REQUIRES_NEW模式
        • 实际开发场景
        • 总结
    • 4.4 基于XML的声明式事务
      • 4.4.1 加入依赖
      • 4.4.2 修改Spring配置文件

4 声明式事务

4.1 JDBCTemplate

4.1.1 简介

为了在特定领域帮助我们简化代码，Spring封装了很多『Template』形式的模板类。例如：RedisTemplate、RestTemplate 等等，包括我们今天要学习的JDBCTemplate。

4.1.2 加入依赖和资源文件

<dependencies>

    <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.1</version>
    </dependency>

    <!-- Spring 持久化层支持jar包 -->
    <!-- Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个jar包 -->
    <!-- 导入 orm 包就可以通过 Maven 的依赖传递性把其他两个也导入 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>5.3.1</version>
    </dependency>

    <!-- Spring 测试相关 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.3.1</version>
        <scope>test</scope>
    </dependency>

    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>

    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.3</version>
    </dependency>
    
    <!-- 数据源 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.0.31</version>
    </dependency>
    
    <!-- 日志 -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>

    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
        <scope>provided</scope>
    </dependency>

</dependencies>

jdbc.properties

atguigu.url=jdbc:mysql://localhost:3306/mybatis-example
atguigu.driver=com.mysql.jdbc.Driver
atguigu.username=root
atguigu.password=atguigu

Spring配置文件

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 导入外部属性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties" />

    <!-- 配置数据源 -->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${atguigu.url}"/>
        <property name="driverClassName" value="${atguigu.driver}"/>
        <property name="username" value="${atguigu.username}"/>
        <property name="password" value="${atguigu.password}"/>
    </bean>

    <!-- 配置 JdbcTemplate -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">      
        <!-- 装配数据源 -->
        <property name="dataSource" ref="druidDataSource"/>        
	</bean>
</beans>

测试

@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = {"classpath:spring-context.xml"})
public class JDBCTest {
    
    @Autowired
    private DataSource dataSource;
    
    @Autowired
    private JdbcTemplate jdbcTemplate;
        
    @Test
    public void testJdbcTemplateUpdate() {
        
    }
    
    @Test
    public void testConnection() throws SQLException {
        Connection connection = dataSource.getConnection();
    
        log.debug("connection = " + connection);
    }
    
}

4.1.3 基本用法

增删改操作

@Test
public void testJdbcTemplateUpdate() {
    
    // 1.编写 SQL 语句。需要传参的地方写问号占位符
    String sql = "update t_emp set emp_salary=? where emp_id=?";
    
    // 2.调用 jdbcTemplate 的 update() 方法执行 update 语句
    int count = jdbcTemplate.update(sql, 999.99, 3);
    
    log.debug("count = " + count);
    
}

查询返回简单类型

@Test
public void testJdbcTemplateQueryForSingleValue() {
    
    // 1.编写 SQL 语句
    String sql = "select emp_name from t_emp where emp_id=?";
    
    // 2.调用 jdbcTemplate 的方法执行查询
    String empName = jdbcTemplate.queryForObject(sql, String.class, 6);
    
    log.debug("empName = " + empName);
    
}

查询返回实体类型

@Test
public void testJdbcTemplateQueryForEntity() {
    
    // 1.编写 SQL 语句
    String sql = "select emp_id,emp_name,emp_salary from t_emp where emp_id=?";
    
    // 2.准备 RowMapper 对象
    RowMapper<Emp> rowMapper = new BeanPropertyRowMapper<>(Emp.class);
    
    // 3.调用 jdbcTemplate 的方法执行查询
    Emp emp = jdbcTemplate.queryForObject(sql, rowMapper, 7);
    
    log.debug("emp = " + emp);
    
}

4.2 声明式事务概念

4.2.1 声明式事务

既然事务控制的代码有规律可循，代码的结构基本是确定的，所以框架就可以将固定模式的代码抽取出来，进行相关的封装。封装起来后，我们只需要在配置文件中进行简单的配置即可完成操作。

  • 好处1：提高开发效率；
  • 好处2：消除了冗余的代码；
  • 好处3：框架会综合考虑相关领域中在实际开发环境下有可能遇到的各种问题，进行了健壮性、性能等各个方面的优化；

所以，我们可以总结下面两个概念：

  • 编程式：自己写代码实现功能；
  • 声明式：通过配置让框架实现功能；

4.2.2 事务管理器

public interface PlatformTransactionManager {

  TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;

  void commit(TransactionStatus status) throws TransactionException;

  void rollback(TransactionStatus status) throws TransactionException;

}

技术体系

在这里插入图片描述

我们现在要使用的事务管理器是org.springframework.jdbc.datasource.DataSourceTransactionManager，将来整合Mybatis用的也是这个类。

DataSourceTransactionManager类中的主要方法：

  • doBegin()：开启事务；
  • doSuspend()：挂起事务；
  • doResume()：恢复挂起的事务；
  • doCommit()：提交事务；
  • doRollback()：回滚事务；

4.3 基于注解的声明式事务

4.3.1 准备工作

加入依赖

    <dependencies>
    
        <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入IOC容器所需所有jar包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>
    
        <!-- Spring 持久化层支持jar包 -->
        <!-- Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个jar包 -->
        <!-- 导入 orm 包就可以通过 Maven 的依赖传递性把其他两个也导入 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.3.1</version>
        </dependency>
    
        <!-- Spring 测试相关 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.1</version>
        </dependency>
    
        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    
        <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.3</version>
        </dependency>
        <!-- 数据源 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.31</version>
        </dependency>
        
        <!-- 日志 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
    
    </dependencies>

外部属性文件

atguigu.url=jdbc:mysql://localhost:3306/mybatis-example
atguigu.driver=com.mysql.jdbc.Driver
atguigu.username=root
atguigu.password=atguigu

Spring配置文件

<!-- 配置自动扫描的包 -->
<context:component-scan base-package="com.atguigu.tx"/>

<!-- 导入外部属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties" />
    
<!-- 配置数据源 -->
<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="url" value="${atguigu.url}"/>
    <property name="driverClassName" value="${atguigu.driver}"/>
    <property name="username" value="${atguigu.username}"/>
    <property name="password" value="${atguigu.password}"/>
</bean>
    
<!-- 配置 JdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    
    <!-- 装配数据源 -->
    <property name="dataSource" ref="druidDataSource"/>
    
</bean>

测试类

@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = {"classpath:spring-context.xml"})
public class JDBCTest {
   
}

创建组件

@Repository
public class EmpDao {
    
    @Autowired
    private JdbcTemplate jdbcTemplate;
        
    public void updateEmpNameById(Integer empId, String empName) {
        String sql = "update t_emp set emp_name=? where emp_id=?";
        jdbcTemplate.update(sql, empName, empId);
    }
        
    public void updateEmpSalaryById(Integer empId, Double salary) {
        String sql = "update t_emp set emp_salary=? where emp_id=?";
        jdbcTemplate.update(sql, salary, empId);
    }
        
    public String selectEmpNameById(Integer empId) {
        String sql = "select emp_name from t_emp where emp_id=?";
    
        String empName = jdbcTemplate.queryForObject(sql, String.class, empId);
    
        return empName;
    }
    
}

EmpDao准备好之后最好测试一下，确认代码正确。养成随写随测的好习惯。

在三层结构中，事务通常都是加到业务逻辑层，针对Service类使用事务。

@Service
public class EmpService {
    
    @Autowired
    private EmpDao empDao;
    
    // 为了便于核对数据库操作结果，不要修改同一条记录
    public void updateTwice(
            // 修改员工姓名的一组参数
            Integer empId4EditName, String newName,

            // 修改员工工资的一组参数
            Integer empId4EditSalary, Double newSalary
            ) {
    
        // 为了测试事务是否生效，执行两个数据库操作，看它们是否会在某一个失败时一起回滚
        empDao.updateEmpNameById(empId4EditName, newName);
    
        empDao.updateEmpSalaryById(empId4EditSalary, newSalary);
    }    
}

4.3.2 应用最基本的事务控制

加事务前状态

修改EmpDao中的updateEmpSalaryById()方法：

public void updateEmpSalaryById(Integer empId, Double salary) {

    // 为了看到操作失败后的效果人为将 SQL 语句破坏
    String sql = "upd222ate t_emp set emp_salary=? where emp_id=?";
    jdbcTemplate.update(sql, salary, empId);
}

@Test
public void testBaseTransaction() {
    
    Integer empId4EditName = 2;
    String newName = "new-name";
    
    Integer empId4EditSalary = 3;
    Double newSalary = 444.44;
    
    empService.updateTwice(empId4EditName, newName, empId4EditSalary, newSalary);
    
}

效果：修改姓名的操作生效了，修改工资的操作没有生效。

添加事务功能

配置事务管理器：

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
   
    <!-- 事务管理器的bean只需要装配数据源，其他属性保持默认值即可 -->
    <property name="dataSource" ref="druidDataSource"/>
</bean>

开启基于注解的声明式事务功能

<!-- 开启基于注解的声明式事务功能 -->
<!-- 使用transaction-manager属性指定当前使用是事务管理器的bean -->
<!-- transaction-manager属性的默认值是transactionManager，如果事务管理器bean的id正好就是这个默认值，则可以省略这个属性 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

注意：导入名称空间时有好几个重复的，我们需要的是tx结尾的那个。

在Service方法上添加注解

@Transactional
public void updateTwice(
        // 修改员工姓名的一组参数
        Integer empId4EditName, String newName,
 
        // 修改员工工资的一组参数
        Integer empId4EditSalary, Double newSalary
        ) {
 
    // 为了测试事务是否生效，执行两个数据库操作，看它们是否会在某一个失败时一起回滚
    empDao.updateEmpNameById(empId4EditName, newName);
 
    empDao.updateEmpSalaryById(empId4EditSalary, newSalary); 
}

4.3.3 只读

介绍

对一个查询操作来说，如果我们把它设置成只读，就能够明确告诉数据库，这个操作不涉及写操作。这样数据库就能够针对查询操作来进行优化。

设置方式

// readOnly = true把当前事务设置为只读
@Transactional(readOnly = true)
public String getEmpName(Integer empId) {
      
    return empDao.selectEmpNameById(empId);
}

@Transactional注解放在类中

如果一个类中每一个方法上都使用了 @Transactional 注解，那么就可以将 @Transactional 注解提取到类上。反过来说：@Transactional 注解在类级别标记，会影响到类中的每一个方法。同时，类级别标记的 @Transactional 注解中设置的事务属性也会延续影响到方法执行时的事务属性。除非在方法上又设置了 @Transactional 注解。

对一个方法来说，离它最近的 @Transactional 注解中的事务属性设置生效。

4.3.4 超时

需求

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。而长时间占用资源，大概率是因为程序运行出现了问题（可能是Java程序或MySQL数据库或网络连接等等）。

此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来，让其他正常程序可以执行。

概括来说就是一句话：超时回滚，释放资源。

设置

@Transactional(readOnly = false, timeout = 3)
public void updateTwice(
        // 修改员工姓名的一组参数
        Integer empId4EditName, String newName,

        // 修改员工工资的一组参数
        Integer empId4EditSalary, Double newSalary
        ) {

    // 为了测试事务是否生效，执行两个数据库操作，看它们是否会在某一个失败时一起回滚
    empDao.updateEmpNameById(empId4EditName, newName);

    empDao.updateEmpSalaryById(empId4EditSalary, newSalary);

}

4.3.5 回滚和不回滚的异常

默认情况

默认只针对运行时异常回滚，编译时异常不回滚。情景模拟代码如下：

public void updateEmpSalaryById(Integer empId, Double salary) throws FileNotFoundException {
    
  // 为了看到操作失败后的效果人为将 SQL 语句破坏
  String sql = "update t_emp set emp_salary=? where emp_id=?";
  jdbcTemplate.update(sql, salary, empId);
    
//  抛出编译时异常测试是否回滚
  new FileInputStream("aaaa.aaa");
    
//  抛出运行时异常测试是否回滚
//  System.out.println(10 / 0);
}

设置回滚的异常

  • rollbackFor属性：需要设置一个Class类型的对象；
  • rollbackForClassName属性：需要设置一个字符串类型的全类名；
@Transactional(rollbackFor = Exception.class)

设置不回滚的异常

在默认设置和已有设置的基础上，再指定一个异常类型，碰到它不回滚。

    @Transactional(
            noRollbackFor = FileNotFoundException.class
    )

回滚和不回滚同时设置

不管是哪个设置范围大，都是在大范围内再排除小范围的设定。例如：

  • rollbackFor = Exception.class
  • noRollbackFor = FileNotFoundException.class

意思是除了FileNotFoundException之外，其他所有Exception范围的异常都回滚；但是碰到FileNotFoundException不回滚。

4.3.6 事务隔离级别

问题

在这里插入图片描述

测试读未提交

在@Transactional注解中使用isolation属性设置事务的隔离级别。 取值使用org.springframework.transaction.annotation.Isolation枚举类提供的数值。

@Transactional(isolation = Isolation.READ_UNCOMMITTED)
public String getEmpName(Integer empId) {
    
    return empDao.selectEmpNameById(empId);
}
    
@Transactional(isolation = Isolation.READ_UNCOMMITTED, readOnly = false)
public void updateEmpName(Integer empId, String empName) {
    
    empDao.updateEmpNameById(empId, empName);
}

测试结果：执行查询操作的事务读取了另一个尚未提交的修改。

测试读已提交

@Transactional(isolation = Isolation.READ_COMMITTED)
public String getEmpName(Integer empId) {
    
    return empDao.selectEmpNameById(empId);
}
    
@Transactional(isolation = Isolation.READ_COMMITTED, readOnly = false)
public void updateEmpName(Integer empId, String empName) {
    
    empDao.updateEmpNameById(empId, empName);
}

测试结果：执行查询操作的事务读取的是数据库中正确的数据。

4.3.7 事务传播行为

问题

在这里插入图片描述

propagation属性

@Transactional注解通过propagation属性设置事务的传播行为。它的默认值是：

Propagation propagation() default Propagation.REQUIRED;

propagation 属性的可选值由 org.springframework.transaction.annotation.Propagation 枚举类提供：

名称含义
REQUIRED
默认值		当前方法必须工作在事务中
如果当前线程上有已经开启的事务可用，那么就在这个事务中运行
如果当前线程上没有已经开启的事务，那么就自己开启新事务，在新事务中运行
所以当前方法有可能和其他方法共用事务
在共用事务的情况下：当前方法会因为其他方法回滚而受连累
REQUIRES_NEW
建议使用		当前方法必须工作在事务中
不管当前线程上是否有已经开启的事务，都要开启新事务
在新事务中运行
不会和其他方法共用事务，避免被其他方法连累

测试

在EmpService中声明两个内层方法：

@Transactional(readOnly = false, propagation = Propagation.REQUIRED)
public void updateEmpNameInner(Integer empId, String empName) {
    
    empDao.updateEmpNameById(empId, empName);
}

@Transactional(readOnly = false, propagation = Propagation.REQUIRED)
public void updateEmpSalaryInner(Integer empId, Double empSalary) {
    
    empDao.updateEmpSalaryById(empId, empSalary);
}

创建TopService：

@Service
public class TopService {
    
    // 这里我们只是为了测试事务传播行为，临时在Service中装配另一个Service
    // 实际开发时非常不建议这么做，因为这样会严重破坏项目的结构
    @Autowired
    private EmpService empService;
    
    @Transactional
    public void topTxMethod() {
    
        // 在外层方法中调用两个内层方法
        empService.updateEmpNameInner(2, "aaa");
        
        empService.updateEmpSalaryInner(3, 666.66);
    }
}

测试方法：

@Autowired
private TopService topService;
    
@Test
public void testPropagation() {
    
    // 调用外层方法
    topService.topTxMethod();
    
}

REQUIRED模式

在这里插入图片描述

REQUIRES_NEW模式

@Transactional(readOnly = false, propagation = Propagation.REQUIRES_NEW)
public void updateEmpNameInner(Integer empId, String empName) {
    
    empDao.updateEmpNameById(empId, empName);
}
    
@Transactional(readOnly = false, propagation = Propagation.REQUIRES_NEW)
public void updateEmpSalaryInner(Integer empId, Double empSalary) {
    
    empDao.updateEmpSalaryById(empId, empSalary);
}

在这里插入图片描述

实际开发场景

在这里插入图片描述

过滤器或拦截器组件：

在这里插入图片描述

总结

我们在事务传播行为这里，使用REQUIRES_NEW属性，也可以说是让不同事务方法从事务的使用上解耦合，不要互相影响。

4.4 基于XML的声明式事务

4.4.1 加入依赖

相比于基于注解的声明式事务，基于 XML 的声明式事务需要一个额外的依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.3.1</version>
</dependency>

4.4.2 修改Spring配置文件

去掉 tx:annotation-driven 标签，然后加入下面的配置：

<aop:config>
    <!-- 配置切入点表达式，将事务功能定位到具体方法上 -->
    <aop:pointcut id="txPoincut" expression="execution(* *..*Service.*(..))"/>
    
    <!-- 将事务通知和切入点表达式关联起来 -->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPoincut"/>
    
</aop:config>
    
<!-- tx:advice标签：配置事务通知 -->
<!-- id属性：给事务通知标签设置唯一标识，便于引用 -->
<!-- transaction-manager属性：关联事务管理器 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
    
        <!-- tx:method标签：配置具体的事务方法 -->
        <!-- name属性：指定方法名，可以使用星号代表多个字符 -->
        <tx:method name="get*" read-only="true"/>
        <tx:method name="query*" read-only="true"/>
        <tx:method name="find*" read-only="true"/>
    
        <!-- read-only属性：设置只读属性 -->
        <!-- rollback-for属性：设置回滚的异常 -->
        <!-- no-rollback-for属性：设置不回滚的异常 -->
        <!-- isolation属性：设置事务的隔离级别 -->
        <!-- timeout属性：设置事务的超时属性 -->
        <!-- propagation属性：设置事务的传播行为 -->
        <tx:method name="save*" read-only="false" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"/>
        <tx:method name="update*" read-only="false" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"/>
        <tx:method name="delete*" read-only="false" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"/>
    </tx:attributes>
</tx:advice>

即使需要事务功能的目标方法已经被切入点表达式涵盖到了，但是如果没有给它配置事务属性，那么这个方法就还是没有事务。所以事务属性必须配置。


http://www.kler.cn/a/8088.html

相关文章：

  • 深度学习——优化算法、激活函数、归一化、正则化
  • 前端框架大比拼：React.js, Vue.js 及 Angular 的优势与适用场景探讨
  • Android音频架构
  • Flink_DataStreamAPI_输出算子Sink
  • [CKS] 关闭API凭据自动挂载
  • 【STM32】基于SPI协议读写SD，详解！
  • 【Mysql系列】——详细剖析数据库中的存储引擎
  • Java面向对象三剑客之——继承
  • Burp Suite的使用（常用模块）
  • python基础-元组
  • 【gRPC】第1篇 全面讲解RPC原理（必收藏）
  • egg编写用户点赞的接口
  • 思维导图手撕MyBatis源码
  • Spring中的循环依赖是什么？如何解决它？
  • HTB-Passage
  • Kafka源码分析之Producer数据发送流程（四）
  • SpringBoot项目中web静态资源的一些问题
  • 【C#】NLS_Speed使用说明
  • ToBeWritten之杂项2
  • C-NCAP 2025主动安全ADAS测试研究
  • 面了 6 家大厂，并拿下 5 家 offer，进大厂好像也没有那么困难吧....
  • 【SQL 必知必会】- 第十一课 使用子查询
  • mocha如何实现异步测试
  • 【建站】手把手教你搭建惊艳的博客
  • 【OpenCV-Python】cvui 之 图像
  • 6.数组