【Spring Boot 快速入门】九、事务管理

目录

• 事务管理
• • 事务回顾
  • Spring 事务管理基础
  • Spring 事务管理进阶
  • • rollbackFor
    • propagation

事务管理

事务回顾

概念：事物是一组操作的集合，它是一个不可分割的工作单位，这些操作要么同时成功，要么同时失败

操作：

• 开启事务（一组操作开始前，开启事务）：start transaction / begin ;
• 提交事务（这组操作全部成功后，提交事务）：commit ;
• 回滚事务（中间任何一个操作出现异常，回滚事务）：rollback ;

事务的必要性：当一组操作（如 “删除部门 + 删除该部门下的员工”）需要保证数据一致性时，必须通过事务控制。若没有事务，某一步操作异常可能导致部分操作生效、部分失效，造成数据不一致（例如：删除部门后出现异常，员工数据未被删除，导致数据关联错误）。

Spring 事务管理基础

在员工部门中，关于部门的代码为：

• controller：import com.example.demo.pojo.Dept;
  import com.example.demo.responed.Result;
  import com.example.demo.service.DeptService;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.web.bind.annotation.*;

  import java.util.List;

  @Slf4j
  @RequestMapping("/depts")
  @RestController
  public class DeptController {

  @Autowired
  private DeptService deptService;

  // 查询部门数据
  @GetMapping
  public Result list(){
  log.info("查询全部部门数据");
  //调用service查询部门数据
  List<Dept> deptList = deptService.list();
  return Result.success(deptList);
  }

  // 删除部门
  @DeleteMapping("/{id}")
  public Result delete(@PathVariable Integer id){
  log.info("根据id删除部门:{}",id);
  //调用service删除部门
  deptService.deleteById(id);
  return Result.success();
  }

  //新增部门
  @PostMapping
  public Result add(@RequestBody Dept dept){
  log.info("新增部门: {}" , dept);
  //调用service新增部门
  deptService.add(dept);
  return Result.success();
  }
  }

• service 接口：import com.example.demo.pojo.Dept;

  import java.util.List;

  public interface DeptService {
  void deleteById(Integer id);

  // 查询全部部门数据
  List<Dept> list();

  // 删除部门
  void delete(Integer id);

  // 新增部门
  void add(Dept dept);
  }

• service 实现类import com.example.demo.mapper.DeptMapper;
  import com.example.demo.mapper.EmpMapper;
  import com.example.demo.pojo.Dept;
  import com.example.demo.service.DeptService;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Service;
  import org.springframework.transaction.annotation.Transactional;

  import java.time.LocalDateTime;
  import java.util.List;

  @Service
  public class DeptServiceImpl implements DeptService {

  @Autowired
  private DeptMapper deptMapper;

  @Override
  public void deleteById(Integer id) {
  deptMapper.deleteById(id);
  }

  @Override
  public List<Dept> list() {
  return deptMapper.list();
  }

  @Override
  public void delete(Integer id) {
  deptMapper.deleteById(id);
  }

  @Override
  public void add(Dept dept) {
  dept.setCreateTime(LocalDateTime.now());
  dept.setUpdateTime(LocalDateTime.now());

  deptMapper.insert(dept);
  }
  }

• mapper 接口：import com.example.demo.pojo.Dept;
  import org.apache.ibatis.annotations.Delete;
  import org.apache.ibatis.annotations.Insert;
  import org.apache.ibatis.annotations.Mapper;
  import org.apache.ibatis.annotations.Select;

  import java.util.List;

  @Mapper
  public interface DeptMapper {
  // 查询全部部门
  @Select("select * from dept")
  List<Dept> list();

  // 根据ID删除部门
  @Delete("delete from dept where id = #{id}")
  void deleteById(Integer id);

  // 新增部门
  @Insert("insert into dept(name, create_time, update_time) values(#{name},#{createTime},#{updateTime})")
  void insert(Dept dept);
  }

目前，部门的删除操作只是删除了部门，然而在实际操作中，部门解散后相应的部门员工的部门编号也应该进行更改，为了方便，后面演示为部门删除后对应的部门员工也删除。

所以需要将部门的 service 实现类改为以下：

import com.example.demo.mapper.DeptMapper;
import com.example.demo.mapper.EmpMapper;
import com.example.demo.pojo.Dept;
import com.example.demo.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

@Service
public class DeptServiceImpl implements DeptService {

@Autowired
private DeptMapper deptMapper;
@Autowired
private EmpMapper empMapper;

@Override
public void deleteById(Integer id) {
// 1. 删除部门
deptMapper.deleteById(id);

// 2. 删除部门下的员工
empMapper.deleteByDeptId(id);
}

// …
}

在 EmpMapper 中添加接口方法：

// 根据部门id删除员工
@Delete("delete from emp where dept_id=#{deptId}")
void deleteByDeptId(Integer deptId);

目前代码存在一个问题，如果说在实现类调用的两个方法之间添加一个异常：

@Override
public void deleteById(Integer id) {
// 1. 删除部门
deptMapper.deleteById(id);

int i = 1 / 0;// 添加异常

// 2. 删除部门下的员工
empMapper.deleteByDeptId(id);
}

即是程序抛出异常，部门依然删除了，部门被删除但相应的部门员工未被删除，导致数据不一致，这是因为异常导致后续删除员工的代码未执行，需将两步操作置于同一事务中才能保证事务的一致性。

Spring 中提供了 @Transactional 注解来解决这个问题：

• 注解：@Transactional
• 位置：service 层的方法上、类上、接口上
• 作用：将当前方法交给 Spring 进行事务管理，方法执行前，开启事务；成功执行完毕，提交事务；出现异常回滚事务
• 通常加在业务层执行多次数据访问操作的增删改方法上

import com.example.demo.mapper.DeptMapper;
import com.example.demo.mapper.EmpMapper;
import com.example.demo.pojo.Dept;
import com.example.demo.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

@Service
public class DeptServiceImpl implements DeptService {

@Autowired
private DeptMapper deptMapper;
@Autowired
private EmpMapper empMapper;

@Transactional
@Override
public void deleteById(Integer id) {
// 1. 删除部门
deptMapper.deleteById(id);

int i = 1/0;

// 2. 删除部门下的员工
empMapper.deleteByDeptId(id);
}

// …
}

这样就能保证事务的一致性，一起提交或者一起回滚。

可以配置 Spring 事务管理的日志开关，方便在控制台中查看日志：

application.properties：

logging.level.org.springframework.jdbc.support.JdbcTransactionManager=DEBUG

application.yml：

logging:
level:
org.springframework.jdbc.support.JdbcTransactionManager: DEBUG

Spring 事务管理进阶

@Transactional 注解的两个常见属性：

• rollbackFor（异常回滚属性）
• propagation（事务传播行为）

rollbackFor

将实现类的方法改为：

@Transactional
@Override
public void deleteById(Integer id) throw Exception{
// 1. 删除部门
deptMapper.deleteById(id);

// 添加异常
if(true) {
throw new Exception("程序出错了！！！");
}

// 2. 删除部门下的员工
empMapper.deleteByDeptId(id);
}

如果代码中添加的是这种异常，即使添加了 @Transactional，也还是会出现程序抛出异常，部门依然删除了，部门被删除但相应的部门员工未被删除，导致数据不一致的情况。

这是因为 @Transactional 默认情况下，只有出现 RuntimeException（运行时异常）才会回滚，之前模拟的 1÷0 产生的算术运算异常属于运行时异常，所以能正常回滚，而直接抛出的 Exception 异常不是运行时异常，不会回滚。

rollbackFor 属性用于控制出现何种异常类型时回滚事务，配置为 rollbackFor = Exception.class 时，代表出现所有异常都会进行事务回滚。

@Transactional(rollbackFor = Exception.class)
@Override
public void deleteById(Integer id) throw Exception{
// 1. 删除部门
deptMapper.deleteById(id);

// 添加异常
if(true) {
throw new Exception("程序出错了！！！");
}

// 2. 删除部门下的员工
empMapper.deleteByDeptId(id);
}

如此一来，不论是何种异常，都会进行事务回滚，保证了事务的一致性

propagation

事务传播行为指当一个事务方法被另一个事务方法调用时，该事务方法如何进行事务控制。例如 a 方法（带事务）调用 b 方法（带事务）时，b 是加入 a 的事务还是新建事务，由传播行为决定。

事务传播行为：

往数据库中新增一个部门操作日志表：

create table dept_log(
id int unsigned primary key auto_increment comment '主键ID',
create_time datetime not null comment '创建时间',
description varchar(300) not null comment '操作描述'
)'部门操作日志表';

实体类为：

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDateTime;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class DeptLog {
private Integer id;
private LocalDateTime createTime;
private String description;
}

mapper 接口：

import org.apache.ibatis.annotations.Insert;

public interface DeptLogMapper {

@Insert("insert into dept_log(description, create_time) values(#{description}, #{createTime})")
void insert(DeptLog deptLog);
}

service 接口以及实现类：

// service接口
import com.example.demo.pojo.DeptLog;
public interface DeptLogService {
void insert(DeptLog deptLog);
}

// service实现类
import com.example.demo.mapper.DeptLogMapper;
import com.example.demo.pojo.DeptLog;
import com.example.demo.service.DeptLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class DeptLogServiceImpl implements DeptLogService {
@Autowired
private DeptLogMapper deptLogMapper;
@Transactional
@Override
public void insert(DeptLog deptLog) {
deptLogMapper.insert(deptLog);
}
}

现在要求，不论删除操作是否成功，都要记录操作日志，将 DeptServiceImpl 改为：

import com.example.demo.mapper.DeptMapper;
import com.example.demo.mapper.EmpMapper;
import com.example.demo.pojo.Dept;
import com.example.demo.pojo.DeptLog;
import com.example.demo.service.DeptLogService;
import com.example.demo.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

@Service
public class DeptServiceImpl implements DeptService {

@Autowired
private DeptMapper deptMapper;
@Autowired
private EmpMapper empMapper;
@Autowired
private DeptLogService deptLogService;

@Transactional
@Override
public void deleteById(Integer id) {
try {
// 1. 删除部门
deptMapper.deleteById(id);

int i = 1/0;

// 2. 删除部门下的员工
empMapper.deleteByDeptId(id);
} finally {
// 3. 删除部门日志
DeptLog deptLog = new DeptLog();
deptLog.setCreateTime(LocalDateTime.now());
deptLog.setDescription("删除了部门id为" + id + "的部门");
deptLogService.insert(deptLog);
}
}
// …
}

deleteById 方法（带事务）调用 insert 方法（带事务）时，insert 会加入 delete 的事务。若 delete 执行中出现异常，整个事务回滚，导致日志记录也回滚，无法满足需求。

import com.example.demo.mapper.DeptLogMapper;
import com.example.demo.pojo.DeptLog;
import com.example.demo.service.DeptLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class DeptLogServiceImpl implements DeptLogService {
@Autowired
private DeptLogMapper deptLogMapper;

@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public void insert(DeptLog deptLog) {
deptLogMapper.insert(deptLog);
}
}

将 insert 方法的传播行为设为 REQUIRES_NEW 后，调用 insert 时会挂起当前事务并新建事务。insert 执行完毕后提交，不受 delete 事务回滚影响，即使 delete 异常，日志也能成功记录。