接口方法#

EmpMapper.java：

1
/**
2
 * 根据ID批量删除员工的基本信息
3
 */
4
void deleteByIds(List<Integer> ids);

EmpExprMapper.java：

1
/**
2
 * 根据员工ID批量删除员工工作经历
3
 */
4
void deleteByEmpIds(List<Integer> empIds);

两个方法都是”一批 id 进去、没有返回值”（SQL 复杂，注解写不下，所以实现都写在 XML 里——55 篇的三条规则：同包同名、namespace 是接口全限定名、语句 id 是方法名）。

EmpMapper.xml#

1
<!--批量删除员工基本信息 (1,2,3)-->
2
<delete id="deleteByIds">
3
    delete from emp where id in
4
    <foreach collection="ids" item="id" separator="," open="(" close=")">
5
        #{id}
6
    </foreach>
7
</delete>

EmpExprMapper.xml#

1
<!--根据员工ID批量删除员工工作经历-->
2
<delete id="deleteByEmpIds">
3
    delete from emp_expr where emp_id in
4
    <foreach collection="empIds" item="empId" separator="," open="(" close=")">
5
        #{empId}
6
    </foreach>
7
</delete>

<foreach> 的三个属性，这次真的都用上了#

69 篇插入时括号写在循环体里面，open/close 用不上；这次的 in (...) 不一样——括号属于整段 SQL，只出现一次，正好交给 open 和 close：

拼出来的效果：

1
ids = [1, 2, 3]   →   delete from emp where id in ( ? , ? , ? )
2
ids = [41]        →   delete from emp where id in ( ? )

#{id} 里的名字要跟 item 对上（不是跟方法形参名对上）——这是初学最容易写错的一处。另外 in 后面只留一个空格、括号交给 open，别自己再手写一对括号，否则会拼成 in ((?, ?, ?))。

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

1. 需求（PPT 第 5 页）：要”根据 ID 删除单个员工”和”根据 ID 批量删除员工”，但只开发一个接口——删除单条数据也是一种特殊的批量删除（ids=1 而已）
2. 接口：请求路径 /emps、请求方式 DELETE、参数格式查询参数；ids 是数组（示例 1,2,3）、必须；请求样例 /emps?ids=1,2,3
3. Controller 接收一批 id 的两种方式：Integer[] ids（数组，不用加注解）与 @RequestParam List<Integer> ids（集合，必须加 @RequestParam）；课程代码采用集合那种
4. 为什么要 @RequestParam：SpringMVC 默认能把逗号分隔的请求参数绑到数组上；要绑成 List 就得用 @RequestParam 声明”这是一个请求参数”
5. 为什么两次删除：emp_expr.emp_id 关联 emp.id，只删 emp 会在 emp_expr 里留下一批指向不存在员工的孤儿经历（数据不完整、不一致）
6. Service 的代码骨架：empMapper.deleteByIds(ids); 然后 empExprMapper.deleteByEmpIds(ids);，方法上加 @Transactional(rollbackFor = {Exception.class})
7. 事务的作用：把两次删除圈进同一个事务，任一步出错整体回滚，避免”员工删了、经历还在”的半拉子结果（70 篇的内容）
8. Mapper 接口方法：void deleteByIds(List<Integer> ids);（删 emp）和 void deleteByEmpIds(List<Integer> empIds);（删 emp_expr）——名字很像，别写串
9. <foreach> 的属性（删除场景）：collection 写 Mapper 方法的形参名（ids / empIds）、item 是循环变量（id / empId，循环体里写 #{id} / #{empId}）、separator=","、open="("、close=")"
10. 本机实测：DELETE /emps?ids=41 → {"code":1,"msg":"success","data":null}，日志两条 SQL 都是 in ( ? )（emp 与 emp_expr 各一条），删后两张表里这个员工的数据都是 0 条；ids=999,998,997 → delete from emp where id in ( ? , ? , ? )

二、裸写题#

• 2-1 写一个”删一个 / 删一批”共用的删除接口（控制层） 需求：前端顶部「批量删除」会把勾选中的若干个员工 id 拼成 1,2,3 这样的串，以查询参数 ids 发过来；表格里每行的「删除」只传一个 id，走的是同一个地址。控制层要做四件事：接住这串 id、打一行日志、调用业务层的删除方法、返回统一响应结果。请给出这段代码，并说明接参为什么可以不写注解、也可以写成另一种形式。 （练习文件 test_74_批量删除.java 的题目2-1 里给了写作区。）

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

  一级 · 思路：请求是 DELETE /emps?ids=1,2,3——一个能接一批整数的形参 + 一个对应 DELETE 方式的注解；接一批 id 有两种写法（数组或集合），集合那种要额外声明参数来自请求 二级 · 方法：@DeleteMapping（类上已有 /emps，方法上不写路径）；形参用 @RequestParam List<Integer> ids（或 Integer[] ids）；日志用 log.info(...)，数组要 Arrays.toString(ids)；结尾 return Result.success(); 三级 · 骨架：

  1
  @DeleteMapping
  2
  public Result delete(@____ List<Integer> ids){
  3
      log.info("根据id批量删除员工: {}", ____);
  4
      empService.____(ids);
  5
      return Result.____();
  6
  }

  参考答案（做完再点开）

  1
  // ===== 方式二：集合接收（课程代码采用） =====
  2
  @DeleteMapping
  3
  public Result delete(@RequestParam List<Integer> ids){
  4
      log.info("删除员工: {}", ids);
  5
      empService.delete(ids);
  6
      return Result.success();
  7
  }
  8
  
  9
  // ===== 方式一：数组接收（PPT 第 7 页，课程里注释保留作对照） =====
  10
  @DeleteMapping
  11
  public Result delete(Integer[] ids){
  12
      log.info("删除员工: {}", Arrays.toString(ids));
  13
      return Result.success();
  14
  }

  说明：

  • @DeleteMapping 对应 DELETE 请求；类上 @RequestMapping("/emps") 已经把路径写好了，方法上不写；
  • 数组那种之所以不用注解，是因为 SpringMVC 默认就能把 ids=1,2,3 绑成数组；换成 List 就必须用 @RequestParam 声明它来自请求参数（否则会被当成对象参数去解析，收不到值）；
  • 数组直接 {} 打日志会打成对象地址，所以课程代码里用了 Arrays.toString(ids)；集合可以直接打印出 [1, 2, 3]。

• 2-2 一个员工被删掉时，他的工作经历也要一起删（业务层） 需求：删除接口只收到一批员工 id，但数据库里这些人的信息分散在两张表中（员工基本信息表 + 工作经历表，工作经历用”员工 id”关联到员工）。要求一次请求把两张表里这些人的数据都删掉，并保证两处删除要么都成功、要么都不做。写出业务层的方法，并说明为什么不能只删基本信息表。 （练习文件 test_74_批量删除.java 的题目2-2 里给了写作区。）

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

  一级 · 思路：业务层按顺序调两个数据访问方法——先删员工、再按同样那批 id 删他的工作经历；“要么都成功要么都不做”靠自己写代码做不到，要一个事务注解把整个方法圈起来 二级 · 方法：方法上 @Transactional(rollbackFor = {Exception.class})；两句 empMapper.deleteByIds(ids); 和 empExprMapper.deleteByEmpIds(ids);（70 篇） 三级 · 骨架：

  1
  @____(rollbackFor = {Exception.class})
  2
  @Override
  3
  public void delete(List<Integer> ids) {
  4
      //1. 批量删除员工基本信息
  5
      empMapper.____(ids);
  6
      //2. 批量删除员工的工作经历信息
  7
      empExprMapper.____(ids);
  8
  }

  参考答案（做完再点开）

  1
  // ===== Service 接口：void delete(List<Integer> ids); =====
  2
  
  3
  // ===== Service 实现 =====
  4
  @Transactional(rollbackFor = {Exception.class})
  5
  @Override
  6
  public void delete(List<Integer> ids) {
  7
      //1. 批量删除员工基本信息
  8
      empMapper.deleteByIds(ids);
  9
      //2. 批量删除员工的工作经历信息
  10
      empExprMapper.deleteByEmpIds(ids);
  11
  }

  说明：

  • 两次删除用的是同一批 id：删 emp 时条件是 where id in (...)，删 emp_expr 时条件是 where emp_id in (...)；
  • 不能只删基本信息表：emp_expr 里的每一行都靠 emp_id 指向某个员工，员工没了这些经历就成了孤儿数据——查不到主人、还占着表，后续统计与关联查询都会算错；
  • 加 @Transactional(rollbackFor = {Exception.class}) 之后，“员工没了、经历还在”这种半拉子结果不会出现（第二次删除失败，第一次的删除也会回滚）。

• 2-3 讲清楚：为什么只要一个接口、为什么必须删两张表 需求：有同学说”删一个和删一批是两回事，后端应该写两个接口”，也有同学说”先删员工就行，工作经历表反正没人看”。请回答：① 为什么只开发一个接口就够了？② 只删 emp 会留下什么后果？③ 这两次删除之间应该加什么机制，为什么？ （练习文件 test_74_批量删除.java 的题目2-3 里给了写作区。）

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

  一级 · 思路：从”删一个”和”删一批”的参数形状去看（都是”一批 id”，只是个数不同）；从两张表的关系去看（工作经历靠 emp_id 指向员工） 二级 · 方法：接口是 DELETE /emps?ids=1,2,3；两张表的关系是 64 篇的一对多；两次数据库操作要用事务（@Transactional） 三级 · 骨架：① 接口参数是 ____（一批 id），单个删除只是这批里只有 ____ 个元素；② 只删 emp 会在 emp_expr 里留下 ____ 数据（emp_id 指向一个已经不存在的员工）；③ 加 ____ 保证两次删除同生共死

  参考答案（做完再点开）

  ① 接口收的参数本来就是”一批 id”（ids=1,2,3）。删一个无非是这批里只有 1 个元素——ids=41。写两个接口会出现两条一模一样的链路（同样的接收、同样的两次删除、同样的响应），属于重复代码，而且前端两处按钮还得记两个地址。PPT 第 5 页的原话就是”删除单条数据也是一种特殊的批量删除，所以只需要开发一个接口”。 ② 会在 emp_expr 表里留下一批 emp_id 指向已删除员工的孤儿经历：这些经历再也关联不到任何人，占着磁盘、混在查询结果里，如果按部门/职位做统计还可能算重。数据的完整性（该一起走的数据没走）和一致性（两张表对不上）都被破坏。 ③ 要加事务：@Transactional(rollbackFor = {Exception.class})。因为”删除一个员工”在业务上是一件事，两次删除必须整体成功或整体回滚——否则可能出现删了员工、删经历时抛异常（比如数据库连接断了），结果只删了一半（70 篇）。

• 2-4 数据访问层：按一批 id 删除两条语句（写进 XML） 需求：删除接口要发两条 SQL，分别按”一批员工 id”删员工基本信息表、按”同一批 id”删工作经历表的 emp_id 列。id 的个数不固定，可能是 1 个也可能是 5 个，要求每条只用一条 SQL 完成，写进 XML 映射文件；写完后回答：这段 SQL 里固定不动的是哪些部分、随 id 个数变化的是哪部分、括号和逗号是谁拼出来的。 （练习文件 test_74_批量删除XML.xml 的题目2-4 里给了写作区。）

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

  一级 · 思路：不定长的部分只能靠动态 SQL 标签”遍历 + 拼串”；in (...) 的括号属于整段 SQL、只出现一次，所以要用到 open/close 二级 · 方法：<delete id="方法名"> 里写 delete from 表 where 列 in，后面跟 <foreach collection="形参名" item="元素名" separator="," open="(" close=")">#{元素名}</foreach> 三级 · 骨架：

  1
  <!-- 删 emp -->
  2
  <delete id="____">
  3
      delete from emp where id in
  4
      <foreach collection="____" item="____" separator="____" open="____" close="____">
  5
          #{____}
  6
      </foreach>
  7
  </delete>
  8
  
  9
  <!-- 删 emp_expr：条件是 emp_id -->
  10
  <delete id="deleteByEmpIds">
  11
      delete from emp_expr where ____ in
  12
      <foreach collection="empIds" item="____" separator="," open="(" close=")">
  13
          #{____}
  14
      </foreach>
  15
  </delete>

  显示更多显示更少
  参考答案（做完再点开）

  EmpMapper.java / EmpExprMapper.java：

  1
  void deleteByIds(List<Integer> ids);      // 根据ID批量删除员工的基本信息
  2
  void deleteByEmpIds(List<Integer> empIds); // 根据员工ID批量删除员工工作经历

  EmpMapper.xml：

  1
  <delete id="deleteByIds">
  2
      delete from emp where id in
  3
      <foreach collection="ids" item="id" separator="," open="(" close=")">
  4
          #{id}
  5
      </foreach>
  6
  </delete>

  EmpExprMapper.xml：

  1
  <delete id="deleteByEmpIds">
  2
      delete from emp_expr where emp_id in
  3
      <foreach collection="empIds" item="empId" separator="," open="(" close=")">
  4
          #{empId}
  5
      </foreach>
  6
  </delete>

  回答：

  • 固定不动：delete from emp where id in（以及 delete from emp_expr where emp_id in）这一整段前缀，和末尾的 )；
  • 随 id 个数变化：? 的个数，以及它们之间的逗号；
  • 括号和逗号都是 <foreach> 拼的：open="(" / close=")" 负责括号，separator="," 负责逗号；
  • 本机实测拼出来的样子：ids=41 → delete from emp where id in ( ? )；ids=999,998,997 → delete from emp where id in ( ? , ? , ? )。collection 写的是方法形参名，item 是循环变量名，循环体里 #{} 要写 item 的名字。

三、综合题#

• 3-1 照着课程把”批量删除”从接口做到数据库 这一题把本节从头到尾走一遍，每一步都用日志和数据库查询留证据。

  1. 三层补齐”删除员工”：控制层接住一批 id、业务层按同一批 id 删两张表（两次删除要同生共死）、数据访问层写两条按 in 批量删除的语句（写在 test_74_批量删除XML.xml 里）；
  2. 先造一个”值得删”的员工：用上一篇的新增接口新增一名员工，并带上 2 段工作经历，记下它的 id；
  3. 启动工程，发一次只删这一个 id 的请求（DELETE /emps?ids=<刚才那个 id>），把响应 JSON 和你手头两条查询的结果抄下来：select count(*) from emp where id = <id>;、select count(*) from emp_expr where emp_id = <id>;；
  4. 观察服务端日志：这次请求发出去了几条 SQL？in 后面的括号里各有几组占位符？
  5. 再发一次多个 id 的请求（可以故意混入几个不存在的 id，比如 ids=999,998,997 加上一个真 id），把日志里那条 SQL 抄下来，数一数 ? 的个数和逗号的个数；
  6. 做对照实验：把业务层里”删除工作经历”那一步注释掉，再用一个新员工走一次删除，然后查两张表——emp 里还有这个人吗？emp_expr 里他的经历还在吗？
  7. 回答下面两个问题。

  （练习文件 test_74_批量删除.java 的”综合题”一段里按这 7 步给了写作区。）

  回答：① 第 5 步里混入不存在的 id，接口会报错吗？这说明什么？② 第 6 步的对照实验留下了什么数据？为什么这种数据不能忍受？

  涉及知识点

  知识点	在这里的应用
  需求与接口文档（PPT 5）	第 2、3 步——DELETE /emps?ids=1,2,3，单个与批量共用同一个接口
  三层分工（PPT 6）	第 1 步——Controller 接参、Service 两次删除、Mapper 两条 SQL
  Controller 两种接收方式（PPT 7）	第 1、3 步——@RequestParam List<Integer> ids（或 Integer[] ids）
  Service 的两张表 + 事务（PPT 8）	第 1、6 步——@Transactional 保证两次删除一起成功/一起回滚
  <foreach> 拼 in 子句（PPT 8）	第 1、4、5 步——open/close 拼括号、separator 拼逗号
  数据一致性	第 6、7 步——孤儿经历就是”只删一半”的后果

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

  一级 · 思路：先把”删一个”跑通（两张表条数都变 0），再看日志确认 SQL 的形状；最后用”少删一张表”的对照实验暴露数据不一致 二级 · 方法：@DeleteMapping + @RequestParam List<Integer> ids；@Transactional(rollbackFor = {Exception.class}) + 两次 Mapper 调用；XML 里 <delete> + <foreach ... open="(" close=")" separator=",">；查库用 select count(*) from emp_expr where emp_id = ? 三级 · 骨架：① 业务层 empMapper.____(ids); empExprMapper.____(ids);；② 请求 DELETE http://localhost:8080/____?ids=____；③ 查库 select count(*) from emp_expr where emp_id = ____;；④ 对照实验后：emp 里该员工 ____ 条、emp_expr 里 ____ 条

  参考答案（做完再点开）

  1. 三层代码（与 2-1、2-2、2-4 的答案一致，合起来就是课程 EmpController.delete / EmpServiceImpl.delete / EmpMapper.deleteByIds / EmpExprMapper.deleteByEmpIds）：

  1
  @DeleteMapping
  2
  public Result delete(@RequestParam List<Integer> ids){
  3
      log.info("删除员工: {}", ids);
  4
      empService.delete(ids);
  5
      return Result.success();
  6
  }
  7
  
  8
  @Transactional(rollbackFor = {Exception.class})
  9
  @Override
  10
  public void delete(List<Integer> ids) {
  11
      empMapper.deleteByIds(ids);       //1. 批量删除员工基本信息
  12
      empExprMapper.deleteByEmpIds(ids); //2. 批量删除员工的工作经历信息
  13
  }

  2～3. 响应与查库（本机实测）：DELETE /emps?ids=41 返回 {"code":1,"msg":"success","data":null}；删的是刚才造出来、挂着 3 条经历的员工，删完 emp 里 0 条、emp_expr 里 emp_id=41 也是 0 条——一次请求两张表一起清。 4. 日志里的 SQL（本机实测）：

  1
  ==>  Preparing: delete from emp where id in ( ? )
  2
  ==> Parameters: 41(Integer)
  3
  ==>  Preparing: delete from emp_expr where emp_id in ( ? )
  4
  ==> Parameters: 41(Integer)

  两次 SQL、各一组占位符——和 Service 里两步一一对应。 5. 多个 id 的 SQL（本机实测）：

  1
  ==>  Preparing: delete from emp where id in ( ? , ? , ? )
  2
  ==> Parameters: 999(Integer), 998(Integer), 997(Integer)

  三个 ?、两个逗号，括号是 open/close、逗号是 separator。 6. 对照实验：注释掉删经历那一步之后，emp 里这个员工没了，emp_expr 里他的工作经历还在——留下一堆”指不到人”的孤儿数据。 7. 两个回答： ① 不报错。删除不存在的 id 只是影响行数为 0，SQL 照样按你传的这批 id 发出去、Result.success() 照样返回。这说明 <foreach> 只是照着参数拼 SQL，不替你校验数据是否存在——真正要不要删、能删什么，得在业务层和接口层把关； ② 留下的是 emp_expr 里的孤儿经历（emp_id 指向一个已经不存在的员工）。它破坏数据的完整性与一致性：这些经历谁也查不到主人，还占着表；将来做统计、按部门/职位聚合时会被算进去，结果就不对了。所以”删员工”必须是一个事务里的两件事。