① 建表、实体类、Mapper#

日志表的建表脚本（课程资料 03. 事务进阶素材/emp_log.sql）：

1
-- 创建员工日志表
2
create table emp_log(
3
    id int unsigned primary key auto_increment comment 'ID, 主键',
4
    operate_time datetime comment '操作时间',
5
    info varchar(2000) comment '日志信息'
6
) comment '员工日志表';

实体类（三个字段 + Lombok 的全参/无参构造——下面 new EmpLog(null, LocalDateTime.now(), ...) 用的就是全参构造）：

1
@Data
2
@NoArgsConstructor
3
@AllArgsConstructor
4
public class EmpLog {
5
    private Integer id; //ID
6
    private LocalDateTime operateTime; //操作时间
7
    private String info; //详细信息
8
}

Mapper 就一句 insert：

1
@Mapper
2
public interface EmpLogMapper {
3

4
    @Insert("insert into emp_log (operate_time, info) values (#{operateTime}, #{info})")
5
    public void insert(EmpLog empLog);
6

7
}

日志的业务层单独一个 Service，关键在那一行传播行为：

1
public interface EmpLogService {
2
    public void insertLog(EmpLog empLog);
3
}
4

5
@Service
6
public class EmpLogServiceImpl implements EmpLogService {
7

8
    @Autowired
9
    private EmpLogMapper empLogMapper;
10

11
    @Transactional(propagation = Propagation.REQUIRES_NEW) //需要在一个新的事务中运行
12
    @Override
13
    public void insertLog(EmpLog empLog) {
14
        empLogMapper.insert(empLog);
15
    }
16
}

② 在新增员工时记录日志#

回到 EmpServiceImpl.save，把整段业务用 try 包起来，日志写在 finally 里：

1
@Transactional(rollbackFor = {Exception.class}) //事务管理 - 默认出现运行时异常RuntimeException才会回滚
2
@Override
3
public void save(Emp emp) throws Exception {
4
    try {
5
        //1. 保存员工基本信息
6
        emp.setCreateTime(LocalDateTime.now());
7
        emp.setUpdateTime(LocalDateTime.now());
8
        empMapper.insert(emp);
9

10
        //2. 保存员工工作经历信息
11
        List<EmpExpr> exprList = emp.getExprList();
12
        if(!CollectionUtils.isEmpty(exprList)){
13
            //遍历集合, 为empId赋值
14
            exprList.forEach(empExpr -> {
15
                empExpr.setEmpId(emp.getId());
16
            });
17
            empExprMapper.insertBatch(exprList);
18
        }
19
    } finally {
20
        //记录操作日志
21
        EmpLog empLog = new EmpLog(null, LocalDateTime.now(), "新增员工:" + emp);
22
        empLogService.insertLog(empLog);
23
    }
24
}

三个要点：

• 为什么用 finally：try 里的代码不管正常跑完还是中途抛异常，finally 块一定会执行——日志正好要”无论成功失败都记录”；id 传 null 是因为主键自增（69 篇的主键返回管的是 emp，日志这条记录自己不需要 id）；
• 这里不能 catch 异常：try 只配 finally、不配 catch，异常会照原样往外抛——外面（事务管理器）才能看到”出异常了”并回滚。如果顺手 catch 掉，异常被吞了，事务反而不会回滚；
• 日志方法必须独立事务：insertLog 上的 REQUIRES_NEW 会让 Spring 在调用它时挂起外层事务、另开一个连接干这件事（下面实测的日志里能直接看到”挂起/恢复”）。

一、知识回顾（读完直接做下面的实践题）#

1. rollbackFor 的作用：控制出现何种异常类型时回滚事务
2. 默认行为（重点）：@Transactional 默认只有出现 RuntimeException（运行时异常）才回滚；编译期异常（受检异常，如 IOException、SQLException）不会触发回滚
3. 推荐写法：@Transactional(rollbackFor = {Exception.class})——Exception 是所有异常的父类，运行时/编译期异常都能回滚
4. 课程代码里的 throws Exception：EmpService.save、EmpServiceImpl.save、EmpController.save 一路声明 throws Exception，就是为了能演示”编译期异常也回滚”
5. 日志里怎么认它：事务定义字符串末尾的 -java.lang.Exception（例如 PROPAGATION_REQUIRED,ISOLATION_DEFAULT,-java.lang.Exception）
6. 事务传播行为的定义：一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行事务控制
7. 六个属性值：REQUIRED（默认，有则加入、无则新建）、REQUIRES_NEW（无论有无总是新建）、SUPPORTS（有则加入、无则无事务运行）、NOT_SUPPORTED（无事务运行，有则挂起当前事务）、MANDATORY（必须有事务否则抛异常）、NEVER（必须没事务否则抛异常）
8. 场景选择：REQUIRED 用于大部分场景；REQUIRES_NEW 用于”希望两个方法在独立事务中运行、互不影响”
9. 日志案例的准备工作：创建 emp_log 表（id 主键自增、operate_time、info）+ EmpLog 实体类 + EmpLogMapper（一句 @Insert）+ 带 REQUIRES_NEW 的 EmpLogService.insertLog
10. “无论成败都要记录”怎么实现：save 用 try { 两次插入 } finally { insertLog }，日志方法用 REQUIRES_NEW 开独立事务；不能 catch 异常（吞掉异常主事务就不回滚了）
11. 本机实测（有事务）：1/0 → HTTP 500，emp/emp_expr 0 条，但 emp_log 有 1 条；日志里能看到 Suspending current transaction, creating new transaction … [insertLog] 与 Resuming suspended transaction
12. 本机实测（去掉事务）：emp 有 testuser03（id=40）、emp_expr 0 条——就是 PPT 第 11 页说的数据不完整、不一致

二、裸写题#

• 2-1 让业务方法里”任何异常”都能触发回滚 需求：现在的保存方法上贴了一个事务注解，但只有一类异常会回滚——文件读写、数据库驱动抛出的那类异常（编译器会强制要求处理的）如果发生，前面的插入不会被撤销。请把注解改成”只要这个方法里有异常就回滚”，并说明为什么这么改。 （练习文件 test_71_事务进阶与操作日志.java 的题目2-1 里给了写作区。）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：默认的回滚判断只看”运行时异常”；要让”编译期异常”也算数，得在注解上显式声明”哪种异常要回滚”，而且范围要覆盖所有异常 二级 · 方法：@Transactional(rollbackFor = {Exception.class})——rollbackFor 属性就是”出现何种异常类型回滚事务”；Exception 是所有异常的父类 三级 · 骨架：@Transactional(____ = {Exception.class})；说明写清楚：默认只回滚 ____，编译期异常不回滚，所以要用父类 Exception 把范围放大

  参考答案（做完再点开）

  1
  @Transactional(rollbackFor = {Exception.class}) //默认出现运行时异常RuntimeException才会回滚
  2
  @Override
  3
  public void save(Emp emp) throws Exception {
  4
      //1. 保存员工基本信息
  5
      emp.setCreateTime(LocalDateTime.now());
  6
      emp.setUpdateTime(LocalDateTime.now());
  7
      empMapper.insert(emp);
  8
  
  9
      //2. 保存员工的工作经历信息
  10
      List<EmpExpr> exprList = emp.getExprList();
  11
      if(!CollectionUtils.isEmpty(exprList)){
  12
          exprList.forEach(empExpr -> empExpr.setEmpId(emp.getId()));
  13
          empExprMapper.insertBatch(exprList);
  14
      }
  15
  }

  显示更多显示更少

  说明：@Transactional 默认只对 RuntimeException 回滚（PPT 第 23 页），而 save 里可能出现的 IOException、SQLException 都是编译期异常，默认不回滚——那样 emp 插进去了、后续失败也不会撤销，又回到”数据不一致”。加上 rollbackFor = {Exception.class} 后，任何 Exception 都会回滚（Exception 是 RuntimeException 的父类，两者都覆盖）。本机实测的事务日志里能看到这条规则：PROPAGATION_REQUIRED,ISOLATION_DEFAULT,-java.lang.Exception。

• 2-2 新增员工时记录一条操作日志（无论成功失败） 需求：新增员工这件事要在数据库里留下痕迹——无论这次新增是成功还是失败，都要记一条日志（记录操作时间和详细信息）。请把该准备的东西准备齐：一张日志表（主键自增、操作时间、日志信息三个字段）、对应的实体类、写一条插入语句的数据访问接口，以及一个专门负责写日志的业务方法；最后修改”新增员工”的业务方法，让它在成功和失败两种情况下都会去写这条日志。 （练习文件 test_71_事务进阶与操作日志.java 的题目2-2 里给了写作区。）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：表（emp_log）→ 实体类（EmpLog）→ Mapper（EmpLogMapper.insert）→ 日志 Service（EmpLogService.insertLog）→ 在 save 里调它；“无论成败”意味着要放在 try 的 finally 里 二级 · 方法：建表 SQL 用 create table emp_log(...)；实体类用 @Data + @NoArgsConstructor + @AllArgsConstructor（new EmpLog(null, LocalDateTime.now(), info) 需要全参构造）；Mapper 用 @Insert("insert into emp_log (operate_time, info) values (#{operateTime}, #{info})")；save 里 try { … } finally { empLogService.insertLog(...) } 三级 · 骨架：

  • 建表：create table emp_log( id int unsigned primary key auto_increment, operate_time datetime, info varchar(2000) );
  • 实体类：private Integer id; private LocalDateTime ____; private String ____;
  • Mapper：@Insert("insert into emp_log (operate_time, info) values (#{____}, #{____})") void insert(EmpLog empLog);
  • save：try { 两次插入 } finally { empLogService.____(new EmpLog(null, LocalDateTime.now(), "新增员工:" + emp)); }
  参考答案（做完再点开）

  1
  -- 创建员工日志表
  2
  create table emp_log(
  3
      id int unsigned primary key auto_increment comment 'ID, 主键',
  4
      operate_time datetime comment '操作时间',
  5
      info varchar(2000) comment '日志信息'
  6
  ) comment '员工日志表';

  1
  @Data
  2
  @NoArgsConstructor
  3
  @AllArgsConstructor
  4
  public class EmpLog {
  5
      private Integer id;            //ID
  6
      private LocalDateTime operateTime; //操作时间
  7
      private String info;           //详细信息
  8
  }
  9
  
  10
  @Mapper
  11
  public interface EmpLogMapper {
  12
      @Insert("insert into emp_log (operate_time, info) values (#{operateTime}, #{info})")
  13
      public void insert(EmpLog empLog);
  14
  }
  15
  
  16
  public interface EmpLogService {
  17
      public void insertLog(EmpLog empLog);
  18
  }
  19
  
  20
  @Service
  21
  public class EmpLogServiceImpl implements EmpLogService {
  22
      @Autowired
  23
      private EmpLogMapper empLogMapper;
  24
  
  25
      @Override
  26
      public void insertLog(EmpLog empLog) {
  27
          empLogMapper.insert(empLog);
  28
      }
  29
  }
  30
  
  31
  // EmpServiceImpl.save：业务用 try 包住，日志写在 finally（无论成败都会执行）
  32
  @Override
  33
  public void save(Emp emp) throws Exception {
  34
      try {
  35
          //1. 保存员工基本信息
  36
          emp.setCreateTime(LocalDateTime.now());
  37
          emp.setUpdateTime(LocalDateTime.now());
  38
          empMapper.insert(emp);
  39
  
  40
          //2. 保存员工工作经历信息
  41
          List<EmpExpr> exprList = emp.getExprList();
  42
          if(!CollectionUtils.isEmpty(exprList)){
  43
              exprList.forEach(empExpr -> empExpr.setEmpId(emp.getId()));
  44
              empExprMapper.insertBatch(exprList);
  45
          }
  46
      } finally {
  47
          //记录操作日志
  48
          EmpLog empLog = new EmpLog(null, LocalDateTime.now(), "新增员工:" + emp);
  49
          empLogService.insertLog(empLog);
  50
      }
  51
  }

  显示更多显示更少

  自查：① id 传 null——它是自增主键，不由这里给；② try 里不要写 catch：异常被吞掉的话外面就不知道出过错，主事务不会回滚（这一题只解决”日志要留下”，回滚交给 2-1 的注解）；③ EmpLog 需要全参构造，别忘了 Lombok 的 @AllArgsConstructor。

• 2-3 让日志在主事务回滚时仍然留下来 需求：现在日志能写了，但是有个致命问题——把 2-2 的代码和事务管理一起用的时候，一旦”新增员工”失败回滚，那条日志也跟着消失了，“无论成功失败都要记录”根本没做到。请让写日志的那一步不受主事务进退的影响，并说明现象：改造后，失败一次之后数据库里应该能查到什么。 （练习文件 test_71_事务进阶与操作日志.java 的题目2-3 里给了写作区。）

  提示（先自己想，实在想不出再点开）

  一级 · 思路：日志方法默认会”加入”外层事务，所以外层一回滚它也回滚；要让它自己开一个事务，就得改它的传播行为 二级 · 方法：在 EmpLogServiceImpl.insertLog 上加 @Transactional(propagation = Propagation.REQUIRES_NEW)；日志里会出现 Suspending current transaction, creating new transaction with name [...insertLog] 和 Resuming suspended transaction 三级 · 骨架：@Transactional(____ = Propagation.____) (+ @Override) public void insertLog(EmpLog empLog) { empLogMapper.insert(empLog); }；现象：主事务回滚后 emp/emp_expr ____ 条、emp_log ____ 条

  参考答案（做完再点开）

  1
  @Service
  2
  public class EmpLogServiceImpl implements EmpLogService {
  3
  
  4
      @Autowired
  5
      private EmpLogMapper empLogMapper;
  6
  
  7
      @Transactional(propagation = Propagation.REQUIRES_NEW) //需要在一个新的事务中运行
  8
      @Override
  9
      public void insertLog(EmpLog empLog) {
  10
          empLogMapper.insert(empLog);
  11
      }
  12
  }

  说明：默认传播行为是 REQUIRED（有事务就加入），所以 insertLog 会跟着 save 的事务一起回滚。改成 REQUIRES_NEW 之后，Spring 在调用它时挂起外层事务、新建一个事务去写日志并提交，主事务后面无论提交还是回滚都不影响它。 本机实测（1/0 场景）：HTTP 500；emp 里 0 条、emp_expr 里 0 条，但 emp_log 里有 1 条 新增员工:Emp(id=39, username=testuser02, ...)。日志里那两行 Suspending current transaction, creating new transaction with name [com.itheima.service.impl.EmpLogServiceImpl.insertLog] 和 Resuming suspended transaction after completion of inner transaction 就是证据。

三、综合题#

• 3-1 把”新增员工”做成事务 + 日志的完整版本，并用两个对照实验回答三个问题 这一题把第 70、71 篇合起来跑一遍，重点是用日志 + 数据库把结论钉死。

  1. 准备：建 emp_log 表，写 EmpLog、EmpLogMapper、EmpLogService/EmpLogServiceImpl（日志方法用独立事务）；
  2. 业务层：save 加”任何异常都回滚”的注解，业务代码用 try 包住、日志写在 finally，配置文件打开事务管理的 debug 日志；
  3. 启动工程，先发一次正常请求，确认响应成功、emp 与 emp_expr 都有数据、emp_log 也多了一条；
  4. 对照实验一：在保存基本信息之后插入 int i = 1 / 0;，重新构建启动，换个用户名再发一次——记录状态码、查库三个表各有多少条，并把日志里”挂起”/“恢复”/“回滚”那几行抄下来；
  5. 对照实验二：把 save 上的事务注解注释掉（1/0 保留），再发一次——记录 emp、emp_expr 各有多少条，和你预想的对不对得上；
  6. 收尾回答三个问题。

  （练习文件 test_71_事务进阶与操作日志.java 的”综合题”一段里按这 6 步给了写作区。）

  回答：① 实验一里为什么”员工没了、日志却还在”？（分别说明是哪两个设置起的作用）② 实验二的结果说明了什么？③ 如果想要”实验一那种失败也回滚、日志也保留”的效果，三个注解（rollbackFor、传播行为、以及第 70 篇的 @Transactional）分别负责哪一件事？

  涉及知识点

  知识点	在这里的应用
  @Transactional（70 篇 / PPT 21）	第 2 步——把两次插入包成一个事务
  rollbackFor（PPT 23）	第 2、4 步——让任何异常都回滚（日志里的 -java.lang.Exception）
  传播行为表（PPT 24）	第 1、4 步——REQUIRED 与 REQUIRES_NEW 的差别
  日志案例（PPT 25）	第 1、2 步——emp_log 表 + EmpLog + EmpLogMapper + try/finally
  必答问答（PPT 26）	第 6 步——传播行为控制什么、两个常用值的场景
  数据不一致（PPT 11 / 70 篇实测）	第 5 步——去掉事务后的 emp 有、emp_expr 没有

  提示（先自己想，实在想不出再点开）

  一级 · 思路：先做”成功路径”，再用 1/0 做”失败路径”，最后把事务注解去掉做”裸奔路径”——三条路径的查库结果放在一起看，注解各自的作用就一目了然 二级 · 方法：@Transactional(rollbackFor = {Exception.class}) 管主事务；@Transactional(propagation = Propagation.REQUIRES_NEW) 管日志；查库用 select * from emp where username = '...'、select * from emp_expr where emp_id = ...、select * from emp_log; 三级 · 骨架：① 日志 Service：@Transactional(propagation = ____.____)；② save：@Transactional(____ = {Exception.class}) + try { … } ____ { empLogService.insertLog(…); }；③ 查库三句：select count(*) from emp where username = '____';、select count(*) from emp_expr where emp_id = ____;、select count(*) from emp_log;

  参考答案（做完再点开）

  1~2. 代码见 2-1、2-2、2-3 的参考答案；日志配置见70 篇（org.springframework.jdbc.support.JdbcTransactionManager: debug）。 3. 本机实测：响应 {"code":1,"msg":"success","data":null}；emp 生成 id=38、emp_expr 2 条（emp_id=38）、emp_log 1 条。 4. 本机实测（实验一）：HTTP 500；emp 0 条、emp_expr 0 条、emp_log 1 条（新增员工:Emp(id=39, username=testuser02, ...)）。日志关键行：

  1
  Suspending current transaction, creating new transaction with name [com.itheima.service.impl.EmpLogServiceImpl.insertLog]
  2
  Initiating transaction commit
  3
  Committing JDBC transaction on Connection [HikariProxyConnection@…]      ← 日志事务提交
  4
  Resuming suspended transaction after completion of inner transaction
  5
  Initiating transaction rollback
  6
  Rolling back JDBC transaction on Connection [HikariProxyConnection@…]    ← 主事务回滚

  5. 本机实测（实验二）：HTTP 500；emp 里有 testuser03（id=40）、emp_expr 0 条——两次插入里第一次生效、第二次失败，数据不完整、不一致（和预想的一致：没有事务，就没有”同生共死”）。
  6. 三个回答： ① “员工没了”是 @Transactional + rollbackFor = {Exception.class} 的效果——主事务在异常后整体回滚；“日志还在”是 propagation = Propagation.REQUIRES_NEW 的效果——日志在自己的事务里提前提交了，主事务回滚波及不到它（日志里 Suspending … → Committing JDBC transaction → Initiating transaction rollback 的顺序就是全过程）。 ② 说明没有事务管理时两次插入是各自独立的：第一条 insert into emp 自动提交后就已经永久生效，后面的异常只能让它后面的操作不执行，管不了已经提交的数据——这正是”必须加事务”的理由。 ③ 分工：@Transactional 决定”这个方法要由 Spring 管事务”（进入方法前开启、结束提交/回滚）；rollbackFor 决定”哪些异常算失败、要触发回滚”（默认只认 RuntimeException，所以要放宽到 Exception）；传播行为（REQUIRES_NEW） 决定”这个方法被别的事务方法调用时，是加入对方的事务还是自己新开一个”——日志必须自己新开，才能做到”无论成功失败都记录”。