spring事务的面试题 —— 事务的特性、传播机制、隔离机制、注解

白日依山尽yy2025-06-01 14:43

目录

1、事务的四个特性

2、如何使用事务@Transactional

3、事务的传播机制

[3.1 事务传播机制的概念](#3.1 事务传播机制的概念)

[3.2 事务传播机制的分类](#3.2 事务传播机制的分类)

[1、PROPAGATION_REQUIRED （默认）](#1、PROPAGATION_REQUIRED （默认）)

2、PROPAGATION_SUPPORTS

3、PROPAGATION_MANDATORY

4、PROPAGATION_REQUIRES_NEW

5、PROPAGATION_NOT_SUPPORTED

6、PROPAGATION_NEVER

7、PROPAGATION_NESTED

4、事务的隔离机制

[4.1 事物隔离机制的概念](#4.1 事物隔离机制的概念)

[4.2 幻读、不可重复读取、脏读的概念](#4.2 幻读、不可重复读取、脏读的概念)

[4.3 事务隔离级别](#4.3 事务隔离级别)

[4.4 Spring隔离级别可选值](#4.4 Spring隔离级别可选值)

[4.5 spring如何设置隔离级别（代码）](#4.5 spring如何设置隔离级别（代码）)

5、事务注解

[1. @Transactional (最核心注解)](#1. @Transactional (最核心注解))

2.使用范围：

1、事务的四个特性

特性 含义 作用 关键点/并发问题 实现机制
原子性 事务被视为一个不可分割的最小工作单元。事务中的所有操作要么全部成功执行，要么全部不执行。不存在部分执行的情况。 确保操作完整性。例如银行转账的两个操作要么都成功，要么都不生效。 强调"不可分割"，没有中间状态。 主要通过回滚日志实现，记录事务前状态，失败时恢复到之前的状态。
一致性 事务执行的结果必须使数据库从一个一致性状态转换到另一个一致性状态。一致性是指数据满足业务规则和约束。 保证数据逻辑正确性和有效性。例如转账前后总金额不变（业务规则）。 数据库在事务执行前后都必须处于一致状态；依赖应用层逻辑和数据库约束（主键、外键等）。 应用层逻辑 + 数据库约束 + 其他ACID特性（原子性、隔离性、持久性）共同保障。
隔离性 多个事务并发执行时，彼此互不影响。每个事务如同独占整个数据库一样执行。 防止并发执行导致的数据不一致问题。 常见并发问题包括：脏读、不可重复读、幻读。 主要通过锁机制和多版本并发控制（MVCC）实现，并提供不同隔离级别供选择（如读未提交、串行化等）。
持久性 一旦事务成功提交，它对数据库的修改就是永久性的，即使系统发生故障也不会丢失。 确保已提交的事务不会因系统崩溃而丢失，可以恢复到最后一致状态。 强调"永久性"。 主要通过重做日志（Redo Log）实现，事务提交前先写入日志文件，重启后可依据日志恢复数据。

2、如何使用事务@Transactional

使用事务的注解@Transactional

@EnableTransactionManagement 在启动类上开启全局事务支持

@Transactional注解加在类上，表示这个类中的所有方法都需要事务管理

事务属性的介绍：

1. readOnly = true

  • 含义： 声明事务为只读。

  • 默认值： false (读写事务)。

2. rollbackFor = Exception.class

  • 含义： 指定哪些异常类型 会触发事务回滚。

  • 示例：

    java 复制代码 
    @Transactional(rollbackFor = {SQLException.class, IOException.class})

3. noRollbackFor = {SomeException.class}

  • 含义： 指定哪些异常类型 发生时不回滚事务。

  • 示例：

    java 复制代码 
    @Transactional(noRollbackFor = {BusinessValidationException.class})

4. timeout = 10

  • 含义： 设置事务的超时时间（秒）。

  • 默认值： 使用底层数据库系统的默认超时（通常无限制）。

5. propagation = Propagation.REQUIRED

  • 含义： 定义事务的传播行为（即当多个事务方法相互调用时，事务如何传递）。

  • a---调用--->b b是否能够使用事务的问题

6. isolation = Isolation.DEFAULT

  • 含义： 设置事务的隔离级别（控制并发事务之间的可见性）。

  • 权衡： 隔离级别越高，数据一致性越强，但并发性能越低。

3、事务的传播机制

3.1 事务传播机制的概念

事务传播描述的事务与事务之间的传播关系， 常见的场景是在一个嵌套调用的方法中，外部方法和内部每个方法都添加了事务管理， 不同的传播行为配置，决定了最终是这些方法是使用同一个事务，还是在不同的事务中运行。

3.2 事务传播机制的分类

传播行为 (Propagation) 中文名称 核心特性
REQUIRED (默认) 必需事务 存在事务则加入，不存在则新建事务（最常用）
REQUIRES_NEW 新建事务 无论是否存在事务，都创建独立新事务（新旧事务完全隔离）
SUPPORTS 支持事务 存在事务则加入，不存在则以非事务方式运行
MANDATORY 强制事务 必须存在事务才能执行，否则抛出异常
NOT_SUPPORTED 非事务支持 强制以非事务方式运行，若存在事务则挂起
NEVER 强制非事务 必须无事务才能执行，否则抛出异常
NESTED 嵌套事务 在当前事务内创建嵌套子事务（可独立回滚，依赖数据库 Savepoint 机制）

1、PROPAGATION_REQUIRED （默认）

支持当前事务，如果当前已经存在事务，就加入到事务中执行，如果当前没有事务，就新建一个事务。这是最常见的选择。

java 复制代码 
public class Demo{
	void a(){
		b();//新建事务
	}
	@Transactional
	void a(){
		b(); //使用a的事务
	}
	@Transactional
	void b();

}

2、PROPAGATION_SUPPORTS

支持当前事务，如果当前没有事务，就以非事务方式执行。

java 复制代码 
public class Demo{
	void a(){
		b();//不要事务
	
	}
	@Transactional
	void a(){
		b(); //使用a的事务
	}
	@Transactional
	void b();

}

3、PROPAGATION_MANDATORY

支持当前事务，如果当前没有事务，就抛出异常。

java 复制代码 
public class Demo{
	void a(){
		b();//报错
	}
	@Transactional
	void a(){
		b(); //使用a的事务
	}
	@Transactional
	void b();

}

4、PROPAGATION_REQUIRES_NEW

新建事务，如果当前存在事务，把当前事务挂起。

java 复制代码 
public class Demo{
	void a(){
		b();//新建
	}
	@Transactional
	void a(){
		b(); //挂起a事务 新建事务
	}
	@Transactional
	void b();

}

5、PROPAGATION_NOT_SUPPORTED

以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

java 复制代码 
public class Demo{
	void a(){
		b(); 
	}
	@Transactional
	void a(){
		b(); //挂起a事务
	}
	@Transactional
	void b();

}

6、PROPAGATION_NEVER

以非事务方式执行，如果当前存在事务，则抛出异常。

java 复制代码 
public class Demo{
	void a(){
		b(); 
	}
	@Transactional
	void a(){
		b(); //报错
	}
	@Transactional(传播级别)
	void b();

}

7、PROPAGATION_NESTED

如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

嵌套事务： 与REQUIRED不同， NESTED支持真正意义上的子事务， 父事务回滚会将所有子事务都回滚，子事务回滚不会引起父事务的回滚。而REQUIRED其实只有一个物理事务。

java 复制代码 
public class Demo{
	void a(){
		b(); //新建
	}
	@Transactional  父事务
	void a(){
		b(); // 新建事务  子事务
	}
	@Transactional(传播级别)
	void b();

}

4、事务的隔离机制

4.1 事物隔离机制的概念

事务的隔离级别描述的是多个事务之间的可见性问题。比如一个事务还未提交时，其他事务是否能看到被未提交事务修改的数据。

4.2 幻读、不可重复读取、脏读的概念

问题类型 脏读 不可重复读 幻读（虚读）
现象描述 事务读取了其他未提交事务修改的数据。 同一事务中多次读取同一记录，结果不同（因为其他事务已提交更新）。 同一事务中多次查询返回的记录数量不同（插入或删除导致）。
示例说明 T1 更新记录但未提交，T2 读取该记录，之后 T1 回滚，T2 读取到无效数据。 T1 读取某记录，T2 更新并提交该记录，T1 再次读取发现数据变化。 T1 查询是否存在某记录，结果为无；准备插入时，T2 插入该记录并提交，T1 插入失败或删除成功却找不到记录。
允许的并发操作 一个事务在另一个事务未提交时可以读取其修改的数据 一个事务在另一个事务提交后可以读取其更新的数据 一个事务在另一个事务提交后可以插入/删除记录影响查询结果集
数据状态 未提交数据 已提交的修改数据 已提交的新增/删除数据
操作类型 读未提交UPDATE 读已提交UPDATE 读已提交INSERT/DELETE
影响范围 单行数据 单行数据 多行结果集
根本原因 事务隔离失效 数据版本变更 数据集范围变化
导致结果 读到了"脏"数据（无效、可能被回滚的数据） 同一条记录在同一个事务中读取不一致 同一范围查询返回不同的行数（像是"幻觉"出现或消失）

4.3 事务隔离级别

隔离级别 别名 描述 可能出现的并发问题 是否加锁 应用场景说明
读未提交 Read Uncommitted 事务可以读取其他事务未提交的数据。 脏读、不可重复读、幻读 否 最低隔离级别，性能最好但数据一致性最差，实际很少使用。
读已提交 Read Committed 事务只能读取已经提交的数据，避免脏读。 不可重复读、幻读 否 多数数据库默认级别（除MySQL外），适用于对一致性要求不高的场景。
可重复读 Repeatable Read 在同一个事务中多次读取的结果一致，InnoDB引擎的默认隔离级别。会出现"幻读"现象。 幻读 是（范围锁） MySQL默认级别，保证同一查询结果不变，但可能插入新记录导致幻读。
串行化 Serializable 所有事务串行执行，通过锁表来强制事务串行化，避免所有并发问题。 无 是（表锁） 最高隔离级别，安全性最高，但性能差，容易产生锁竞争和超时，实际应用较少使用。
  • Mysql默认隔离级别：REPEATABLE-READ 可重复读
  • Oracle默认隔离级别：Read committed 读已提交

4.4 Spring隔离级别可选值

隔离级别 说明
ISOLATION_DEFAULT（默认级别） 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.
ISOLATION_READ_UNCOMMITTED（读未提交） 这是事务最低的隔离级别，它允许另外一个事务可以看到这个事务未提交的数据。 这种隔离级别会产生脏读，不可重复读和幻像读。
ISOLATION_READ_COMMITTED（读已提交） 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。 这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读（因为在事务提交前允许别的事务更新和插入操作）。
ISOLATION_REPEATABLE_READ（可重复读） 它保证了一个事务不能修改已经由另一个事务读取但还未提交的数据，也就是说同一个事务内读取的数据都是一致的。这种事务隔离级别可以防止脏读、不可重复读。但是可能出现幻像读（一个事务在提交前不允许别的事务更新，但是允许插入）。
ISOLATION_SERIALIZABLE（串行化） **这是花费最高代价但是最可靠的事务隔离级别。**事务被处理为顺序执行。 除了防止脏读，不可重复读外，还避免了幻像读（一个事务在提交前不允许别的事务读取、更新、插入）。

4.5 spring如何设置隔离级别（代码）

注解

java 复制代码 
@Transactional(
        isolation = Isolation.REPEATABLE_READ,
        propagation = Propagation.REQUIRED,
        timeout = 5000,
        readOnly = true,
        rollbackFor = Exception.class,
        noRollbackFor = NullPointerException.class)

示例代码：

java 复制代码 
@RequestMapping("/transfer")
public Object transfer(Integer fromId, Integer toId, Double money){
    //接收数据，传递数据到业务层
    boolean flag = accountService.transfer(fromId, toId, money);
    //返回结果给客户端
    return flag;
}
@RequestMapping("/findById")
public void findAccountById(Integer id){
    accountService.query(id);
}
java 复制代码 
public interface AccountService {
    public boolean transfer(Integer fromId, Integer toId, double money);
​
    public void query(Integer id);
​
}
java 复制代码 
package com.hl.springboot4.service;
​
import com.hl.springboot4.dao.AccountDao;
import com.hl.springboot4.pojo.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
/*
@EnableTransactionManagement 开启全局事务支持
@Transactional 使用事务
    readOnly = true, 只读事务  当前事务中查询出的数据，不能用户更新操作
    rollbackFor = Exception.class  当遇到特定异常，执行rollback回滚
    noRollbackFor = {} 当发生某种异常，不回滚
    timeout=数值   超时时间
    propagation =  事务的传播机制  a--调用-->b b是否能够使用事务的问题
            Propagation.REQUIRED
    isolation =  事务的隔离行为  两个方法在使用事务时，对方操作的数据是否可见
 */
@Service
@Transactional(isolation = Isolation.SERIALIZABLE)
public class AccountServiceImpl implements AccountService{
    @Autowired
    private AccountDao accountDao;
    @Override
//    @Transactional//事务注解
    public boolean transfer(Integer fromId, Integer toId, double money) {
        //转出方法
        int num1 = accountDao.transferOut(fromId,money);
//        System.out.println(1/0);
        //转入方法
        int num2 = accountDao.transferIn(toId,money);
        return num1==num2&&num1>0 ? true : false;
    }
/*
    事务隔离机制：
        isolation = Isolation.READ_UNCOMMITTED
        READ_UNCOMMITTED 读未提交  读取到其他事务修改但是尚未提交的数据  可能出现脏数据
        READ_COMMITTED 读已提交 读取其他事务已经提交的数据
        REPEATABLE_READ 可重复读  一个事务在执行期间，不受其他会话影响，多次读取结果保持一致
        SERIALIZABLE 可串行化  锁表  第一个事务commit提交后，第二个事务才能执行
 */
    @Override
    public void query(Integer id) {
        Account account = accountDao.getAccountById(id);
        System.out.println(account);
​
        Account account2 = accountDao.getAccountById(id);
        System.out.println(account);
        System.out.println(account2);
    }
}
java 复制代码 
package com.hl.springboot4.dao;
​
import com.hl.springboot4.pojo.Account;
​
public interface AccountDao {
    //转出
    public int transferOut(Integer fromId,Double money);
    //转入
    public int transferIn(Integer toId,Double money);
    //查询
    public Account getAccountById(Integer id);
}
java 复制代码 
package com.hl.springboot4.dao;
​
import com.hl.springboot4.pojo.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import org.springframework.web.bind.annotation.RequestMapping;
​
import java.util.List;
​
@Repository
public class AccountDaoImpl implements AccountDao{
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public int transferOut(Integer fromId, Double money) {
        String sql = "update account set money = money - ? where id = ?";
        return jdbcTemplate.update(sql, money, fromId);
    }
​
    @Override
    public int transferIn(Integer toId, Double money) {
        String sql = "update account set money = money + ? where id = ?";
        return jdbcTemplate.update(sql, money, toId);
    }
​
    @Override
    public Account getAccountById(Integer id) {
        String sql = "select * from account where id = ?";
        List<Account> list = jdbcTemplate.query(sql,new BeanPropertyRowMapper<Account>(Account.class),id);
        return list!=null ? list.get(0) : null;
    }
}
java 复制代码 
@SpringBootTest
class Springboot4ApplicationTests {
    @Autowired
    private AccountController accountController;
    @Test
    void tes1() {
        accountController.findAccountById(1);
    }
    @Test
    void tes2() {
        accountController.transfer(1,2,300.0);
    }
​
}

5、事务注解

1. @Transactional (最核心注解)

属性 说明 示例
value/transactionManager 指定事务管理器 Bean 名称（多数据源时必填） @Transactional("orderTxManager")
propagation 事务传播行为（默认 Propagation.REQUIRED） propagation = Propagation.REQUIRES_NEW
isolation 事务隔离级别（默认 Isolation.DEFAULT） isolation = Isolation.READ_COMMITTED
timeout 事务超时时间（秒），-1 表示永不超时 timeout = 30
readOnly 是否只读事务（默认 false） readOnly = true
rollbackFor 触发回滚的异常类型（数组） rollbackFor = {SQLException.class}
noRollbackFor 不触发回滚的异常类型（数组） noRollbackFor = NullPointerException.class
label 事务标签（Spring 5.3+ 用于添加描述性标签） label = "order-service"

2.使用范围：

java 复制代码 
@Transactional // 类级：所有public方法生效
@Service
public class OrderService {
    
    @Transactional(propagation = Propagation.REQUIRES_NEW) // 方法级：覆盖类配置
    public void createOrder() { ... }
}
相关推荐
小师兄吃牛肉3 小时前
Java语法 | 多重循环
java·开发语言·python
Han.miracle3 小时前
MySQL InnoDB：MVCC、记录锁、间隙锁、二级索引MVCC底层原理
java·开发语言
不停喝水4 小时前
【前端转全栈java速通课】 项目实战④7-11节 操作数据库-登录-注册-修改密码-注销-mubatis-plus简化crud-
java·前端·数据库
y1su4 小时前
Leetcode 二分模板
java·数据结构·算法·leetcode·排序算法
~光~~4 小时前
【嵌入式linux学习】Cache 策略：Write-Through / Write-Back + Allocation
linux·学习·spring
leisoo80974 小时前
融资融券数据怎么查两融指标含义与杠杆观察方法 IG50免费开源股票数据API接口
开发语言·jvm·数据库·python·json
霸道流氓气质4 小时前
多Agent通信机制与协议设计完全指南：从FIPA-ACL到A2A/MCP的Java生产级实战
java·开发语言
Aric_Jones4 小时前
pgsql内置publication/subscription功能，实现数据同步
数据库
热门推荐
01如何新建文件夹？ 电脑新建文件夹的4种方法02国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）03历年考研数学一、数学二、数学三真题试卷及答案PDF04GitHub 镜像站点05「全语录+省流版」邵艾伦 × 孙宇晨：聊风口、聊个人IP、聊年轻人如何抓住 AI 时代的机会06蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接07Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）08轻量化AI渗透武器库｜ARTEX自主攻防系统、资产梳理、漏洞挖掘、链路分析全流程智能化落地09Telegram APK 下载安装完整指南 — 2026年最新10微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新