为什么要先查学员数#

student 表里有 clazz_id 一列（“班级ID, 关联班级表ID”），每个学员都挂在一个班级下。如果直接把班级删了，这些学员的 clazz_id 就会指向一个不存在的班级——学员列表里”班级”那一列会空掉、按班级筛选会查出”幽灵班级”、班级人数统计也会对不上。

这和 74 篇”删员工要连着他的工作经历一起删”是同一类问题（都是关联数据不能悬空），但处理方式不同：

学员是独立招进来的业务主体，不能因为班主任想删班级就把人一起删了——所以这里的选择是”先问一句，有人就不让删”。

异常怎么变成 {"code":0,"msg":"班级下有学员, 不能直接删除~"}#

Service 里抛的 BusinessException 不是 JDK 自带的异常，是项目里自定义的一个类（放在 com.itheima.exception 包下）：

1
public class BusinessException extends RuntimeException{
2
    public BusinessException(String message) {
3
        super(message);
4
    }
5
}

它继承 RuntimeException（运行时异常，方法签名上不用声明 throws），构造时把消息存起来。真正的关键在于全局异常处理器里专门给它加了一条处理：

1
/**
2
 * 声明异常处理的方法 - BusinessException
3
 */
4
@ExceptionHandler
5
public Result handleBuinessException(BusinessException businessException) {
6
    log.error("服务器异常", businessException);
7
    return Result.error(businessException.getMessage());
8
}

（这段和 76 篇的 GlobalExceptionHandler 是同一个类，handleBuinessException 是本章新加的方法。方法名里的 Buiness 是课程代码的拼写，照着写就行。）

串起来看整条链路：Service 抛出 BusinessException("班级下有学员, 不能直接删除~") → SpringMVC 把异常交给 GlobalExceptionHandler → 匹配到 handleBuinessException → 返回 Result.error(消息)。所以前端收到的是统一响应格式 {"code":0,"msg":"班级下有学员, 不能直接删除~","data":null}，而不是 500 错误页或者一堆堆栈。

这条链路解决了实战里一个很实际的问题：“不能删”是一个正常业务结果，不是程序出错。用 Exception 抛出去的好处是——Service 里不用逐层往 Controller 返回”成功没成功的标记”（那样每个中间层都得跟着改签名），业务要中断就抛，翻译成响应格式的活交给全局那一处。前端只要看 code 是 0 就把 msg 弹出来给用户看，那句话就是写给用户看的。

本机实测——删一个有学员的班级和删一个没学员的班级，结果完全不同：

1
# ① 删「有学员的班级」id=1（它下面挂着 6 名学员）
2
$ DELETE http://localhost:8080/clazzs/1
3
{"code":0,"msg":"班级下有学员, 不能直接删除~","data":null}     ← 业务校验拦下（BusinessException）
4

5
# ② 删「没有学员的班级」——刚新增的测试班级 id=9
6
$ DELETE http://localhost:8080/clazzs/9
7
{"code":1,"msg":"success","data":null}

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

1. 第 11 章的性质：实战章——PPT 只有 7 页（封面、需求两页、最终效果、暂停实战、实战说明、空白页），没有技术讲解；三块需求是班级管理 / 学员管理 / 数据统计，本篇做班级管理（另外两块在 79、80 篇）
2. 本章唯一的规矩（PPT 第 3 页原话）：“所有的功能全部严格，根据接口文档进行开发，并进行前后端联调”——路径、请求方式、参数名、响应字段都以接口文档为准，不能自己改
3. 班级管理的六个接口：GET /clazzs（条件分页）、DELETE /clazzs/{id}（删除）、POST /clazzs（新增）、GET /clazzs/{id}（详情回显）、PUT /clazzs（修改）、GET /clazzs/list（全部班级）；全部挂 /clazzs，靠请求方式区分同路径的三个
4. clazz 表的关键约束：name 非空且唯一、subject 非空（1 java / 2 前端 / 3 大数据 / 4 Python / 5 Go / 6 嵌入式）、master_id 可为 null（关联 emp.id）、begin_date / end_date 非空
5. 实体类里多出来的两个字段：masterName（班主任姓名）和 status（班级状态）——表里没有这两列，是列表查询时 left join emp 取别名、case when 比 now() 与开课/结课时间算出来的
6. 条件分页的参数与响应：传 name（模糊）、begin / end（结课时间范围）、page（默认 1）、pageSize（默认 10）；回 data: {total, rows}
7. 日期参数的写法：@DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin——不加这个注解，SpringMVC 没法把 2023-01-01 这样的请求参数转成 LocalDate
8. 两处动态 SQL：查询用 <where>（自动去掉多余的 and）+ <if>，模糊匹配写 like concat('%',#{name},'%')（不能写成 '%#{name}%'），时间条件用 c.end_date between #{begin} and #{end}；更新用 <set>（自动去掉最后一个逗号）+ <if>，逐字段动态更新
9. 分页怎么写：Service 里 PageHelper.startPage(page, pageSize); 紧跟着 clazzMapper.list(...)，把返回的 List 强转成 Page，用 getTotal() / getResult() 组装 new PageResult(total, rows)
10. 删除班级的业务校验：Service 里先 studentMapper.countByClazzId(id)，count > 0 就 throw new BusinessException("班级下有学员, 不能直接删除~")；BusinessException extends RuntimeException，由 GlobalExceptionHandler 的 handleBuinessException 用 Result.error(消息) 转成统一响应——本机实测删 id=1（6 名学员）返回 {"code":0,"msg":"班级下有学员, 不能直接删除~","data":null}，删没有学员的班级返回 {"code":1,"msg":"success","data":null}

二、裸写题#

• 2-1 新增班级（三层都要写） 需求：班级管理页面上点「+ 新增班级」，弹窗里填班级名称、班级教室、开课时间、结课时间、班主任、学科，点确定后把这些数据以 JSON 请求体发到 /clazzs，用 POST 方式提交。要求三层都实现：控制层接住这个班级对象、调用业务层；业务层把创建时间和修改时间补成当前时间，再交给数据访问层；数据访问层往 clazz 表插一条记录（主键自增，两个时间列由业务层给）。 （练习文件 test_78_班级管理.java 的题目2-1 里给了写作区。）

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

  一级 · 思路：请求体里是一个完整的班级对象（含提交上来的字段）——控制层用一个能装下它的形参接住，并声明数据来自请求体；业务层补两个时间戳（用”当前时间”）；数据访问层按 clazz 表的列顺序把九个值写进去，主键位置给空 二级 · 方法：@PostMapping（类上已有 /clazzs）；形参 @RequestBody Clazz clazz；LocalDateTime.now() 赋给 createTime / updateTime；SQL 用 @Insert，写法是 insert into clazz VALUES (null,#{...},...) 三级 · 骨架：

  1
  @PostMapping
  2
  public Result save(@____ Clazz clazz){
  3
      clazzService.____(clazz);
  4
      return Result.____();
  5
  }
  6
  
  7
  @Override
  8
  public void save(Clazz clazz) {
  9
      clazz.setCreateTime(LocalDateTime.____());
  10
      clazz.setUpdateTime(____.now());
  11
      clazzMapper.____(clazz);
  12
  }
  13
  
  14
  @Insert("insert into clazz VALUES (____,#{name},#{room},#{beginDate},#{endDate},#{masterId}, #{subject},#{createTime},#{updateTime})")
  15
  void ____(Clazz clazz);

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

  1
  // ===== Controller（com.itheima.controller.ClazzController）=====
  2
  @PostMapping
  3
  public Result save(@RequestBody Clazz clazz){
  4
      clazzService.save(clazz);
  5
      return Result.success();
  6
  }
  7
  
  8
  // ===== Service 接口 + 实现（注意方法名 save，实现里只多补两个时间）=====
  9
  void save(Clazz clazz);
  10
  
  11
  @Override
  12
  public void save(Clazz clazz) {
  13
      clazz.setCreateTime(LocalDateTime.now());
  14
      clazz.setUpdateTime(LocalDateTime.now());
  15
      clazzMapper.insert(clazz);
  16
  }
  17
  
  18
  // ===== Mapper（com.itheima.mapper.ClazzMapper）=====
  19
  @Insert("insert into clazz VALUES (null,#{name},#{room},#{beginDate},#{endDate},#{masterId}, #{subject},#{createTime},#{updateTime})")
  20
  void insert(Clazz clazz);

  显示更多显示更少

  说明：

  • @RequestBody 让 SpringMVC 把 JSON 请求体反序列化成 Clazz 对象，字段名（beginDate、masterId……）和实体属性同名就自动对应；
  • 第一个 null 是自增主键 id 的占位，数据库会自动分配；后面八个值的顺序必须和 clazz 建表顺序一致（name、room、begin_date、end_date、master_id、subject、create_time、update_time）；
  • create_time / update_time 不由前端传，业务层填 LocalDateTime.now()（前端传了也没用，插进去的是这两个值）；
  • 新增接口不返回数据，Result.success() 就行。本机实测这次调用的响应是 {"code":1,"msg":"success","data":null}。

• 2-2 班级列表的条件分页查询（三层的重头戏） 需求：班级管理页面顶部的查询区有”班级名称”和”结课时间（开始 至 结束）“两个条件，底部有页码和每页条数。要求实现 GET /clazzs 这条接口：按班级名称做模糊匹配、按结课时间做范围过滤，两个条件都可以不传；分页返回总记录数和当前页数据。另外，表格里还要显示”班主任姓名”和”班级状态”（未开班 / 在读中 / 已结课）两列，clazz 表里都没有，需要查询时算出来（班主任姓名要联员工表，状态拿开课、结课时间和当前时间比）。 （练习文件 test_78_班级管理.java 的题目2-2 里给了写作区；对应的 XML 写在 test_78_班级条件查询与更新.xml 的题目2-2 里。）

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

  一级 · 思路：控制层接收五个参数（两个条件 + 页码 + 每页条数），日期字符串要告诉框架按什么格式解析；业务层先用分页插件开启分页、再查询、最后组装分页结果；数据访问层是一条带条件的多表查询——条件是”可选”的，所以要用动态 SQL 标签把没传的条件整段去掉 二级 · 方法：@GetMapping；@DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin；@RequestParam(defaultValue = "1") Integer page；PageHelper.startPage(page, pageSize) + (Page<Clazz>) dataList + new PageResult(total, rows)；XML 里 select c.*, e.name masterName, (case when ... end) status from clazz c left join emp e on c.master_id = e.id 外面套 <where>，里面两个 <if>，模糊匹配用 like concat('%',#{name},'%')，时间条件用 c.end_date between #{begin} and #{end} 三级 · 骨架：

  1
  @GetMapping
  2
  public Result page(String name,
  3
                     @____________(pattern = "yyyy-MM-dd") LocalDate begin,
  4
                     @DateTimeFormat(pattern = "____") LocalDate end,
  5
                     @RequestParam(__________ = "1") Integer page,
  6
                     @RequestParam(defaultValue = "10") Integer pageSize){
  7
      PageResult pageResult = clazzService.____(name, begin, end, page, pageSize);
  8
      return Result.success(__________);
  9
  }
  10
  
  11
  @Override
  12
  public PageResult page(String name, LocalDate begin, LocalDate end, Integer page, Integer pageSize) {
  13
      PageHelper.________(page, pageSize);
  14
      List<Clazz> dataList = clazzMapper.____(name, begin, end);
  15
      Page<Clazz> p = (____<Clazz>) dataList;
  16
      return new PageResult(p.________(), p.________());
  17
  }

  显示更多显示更少

  1
  <select id="____" resultType="com.itheima.pojo.Clazz">
  2
      select c.*, e.name ____,
  3
          (case when begin_date &gt; now() then '未开班' when now() &gt; end_date then '已结课' else '在读中' end ) ____
  4
      from clazz c ____ join emp e on c.master_id = e.id
  5
      <____>
  6
          <if test="name != null and name != ''">
  7
              c.name like ____('%',#{name},'%')
  8
          </if>
  9
          <if test="begin != null and end != null">
  10
              and c.____ between #{begin} and #{end}
  11
          </if>
  12
      </____>
  13
      order by c.update_time desc
  14
  </select>

  参考答案（做完再点开）

  1
  // ===== Controller =====
  2
  @GetMapping
  3
  public Result page(String name ,
  4
                     @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin ,
  5
                     @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate end,
  6
                     @RequestParam(defaultValue = "1") Integer page ,
  7
                     @RequestParam(defaultValue = "10")Integer pageSize){
  8
      PageResult pageResult = clazzService.page(name , begin , end , page , pageSize);
  9
      return Result.success(pageResult);
  10
  }
  11
  
  12
  // ===== Service 实现 =====
  13
  @Override
  14
  public PageResult page(String name, LocalDate begin, LocalDate end, Integer page, Integer pageSize) {
  15
      PageHelper.startPage(page, pageSize);
  16
  
  17
      List<Clazz> dataList = clazzMapper.list(name,begin,end);
  18
      Page<Clazz> p = (Page<Clazz>) dataList;
  19
  
  20
      return new PageResult(p.getTotal(), p.getResult());
  21
  }
  22
  
  23
  // ===== Mapper 接口 =====
  24
  List<Clazz> list(String name, LocalDate begin, LocalDate end);

  显示更多显示更少

  1
  <select id="list" resultType="com.itheima.pojo.Clazz">
  2
      select
  3
          c.*,
  4
          e.name masterName,
  5
          (case when begin_date &gt; now() then '未开班' when now() &gt; end_date then '已结课' else  '在读中' end ) status
  6
      from clazz c left join emp e on c.master_id = e.id
  7
      <where>
  8
          <if test="name != null and name != ''">
  9
              c.name like concat('%',#{name},'%')
  10
          </if>
  11
          <if test="begin != null and end != null">
  12
              and c.end_date between #{begin} and #{end}
  13
          </if>
  14
      </where>
  15
      order by c.update_time desc
  16
  </select>

  显示更多显示更少

  说明：

  • <where> 会去掉条件开头多余的 and：只传 name 时不会拼出 where and ...；两个条件都没传时连 where 关键字都不出现（68 篇）；
  • 模糊匹配必须用 concat：写成 '%#{name}%' 是不生效的，因为 #{} 落在引号里就不会被当成参数解析了；
  • 过滤的是 end_date（结课时间），别看页面上两个输入框挨着”班级名称”就顺手写成 begin_date——接口文档的参数备注写的是”范围匹配的开始/结束时间（结课时间）”；
  • masterName / status 靠别名对上实体类的属性：resultType 仍是 Clazz，SQL 里 e.name masterName 和 case when ... end status 的别名正好给了那两个”表里没有的字段”；left join 保证班主任为 null 的班级也查得出来；
  • status 用的是 case when 比较大小（now() 与日期比），不是等值匹配——begin_date 还没到就是”未开班”，end_date 已经过了就是”已结课”，中间是”在读中”（接口文档的响应示例里写的是”已开班”，课程实现返回的是”在读中”，以课程为准）；
  • PageHelper 只对紧跟的那次查询生效，startPage 和 clazzMapper.list(...) 中间不要插别的查询；(Page<Clazz>) dataList 强转后才有 getTotal()（总记录数），getResult() 才是当前页数据；
  • 本机实测：GET /clazzs?page=1&pageSize=3 → {"code":1,"msg":"success","data":{"total":6,"rows":[3 条]}}。

• 2-3 点「编辑」先回显，改完提交只改传了值的字段 需求：表格每一行最右侧有「编辑」「删除」两个按钮。点「编辑」时，前端要把这个班级当前完整的字段填进弹窗表单（含学科、班主任这些不在表格里显示的内容），用户改完（可能只改班级教室，也可能全都改）提交保存。要求：给出回显用的那条查询接口（三层），以及修改接口的三层实现；修改时只更新用户确实传了值的字段，不想让”没传的字段被清空”。 （练习文件 test_78_班级管理.java 的题目2-3 里给了写作区；对应的 XML 写在 test_78_班级条件查询与更新.xml 的题目2-3 里。）

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

  一级 · 思路：回显是”按 id 查一条”，路径里带 id、方法上用能接收路径变量的注解把 id 取出来；修改是一个整体对象提交回来，靠对象里的 id 定位；要让更新”传什么改什么”，SQL 不能把所有列写死，得用一个能逐字段判断、并自动处理标点的小标签 二级 · 方法：@GetMapping("/{id}") + @PathVariable Integer id + @Select("select * from clazz where id = #{id}")；@PutMapping + @RequestBody Clazz；业务层 clazz.setUpdateTime(LocalDateTime.now())；XML 里 update clazz 后面跟 <set>，里面每个字段一个 <if test="xxx != null">列名 = #{xxx},</if>（字符串字段再判空串），最后的 where id = #{id} 写在 <set> 外面 三级 · 骨架：

  1
  @GetMapping("/____")
  2
  public Result getInfo(@________ Integer id){
  3
      Clazz clazz = clazzService.____(id);
  4
      return Result.success(____);
  5
  }
  6
  
  7
  @PutMapping
  8
  public Result update(@________ Clazz clazz){
  9
      clazzService.____(clazz);
  10
      return Result.success();
  11
  }
  12
  
  13
  @Override
  14
  public void update(Clazz clazz) {
  15
      clazz.setUpdateTime(LocalDateTime.____());
  16
      clazzMapper.____(clazz);
  17
  }

  显示更多显示更少

  1
  <update id="____">
  2
      update clazz
  3
      <____>
  4
          <if test="name != null and name != ''">
  5
              name = #{name}____
  6
          </if>
  7
          <if test="room != null and room != ''">
  8
              room = #{room},
  9
          </if>
  10
          <if test="updateTime != null">
  11
              update_time = #{updateTime}
  12
          </if>
  13
      </____>
  14
      where id = #{id}
  15
  </update>

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

  1
  // ===== Controller：详情回显 + 修改 =====
  2
  @GetMapping("/{id}")
  3
  public Result getInfo(@PathVariable Integer id){
  4
      Clazz clazz = clazzService.getInfo(id);
  5
      return Result.success(clazz);
  6
  }
  7
  
  8
  @PutMapping
  9
  public Result update(@RequestBody Clazz clazz){
  10
      clazzService.update(clazz);
  11
      return Result.success();
  12
  }
  13
  
  14
  // ===== Service 实现 =====
  15
  @Override
  16
  public Clazz getInfo(Integer id) {
  17
      return clazzMapper.getInfo(id);
  18
  }
  19
  
  20
  @Override
  21
  public void update(Clazz clazz) {
  22
      clazz.setUpdateTime(LocalDateTime.now());
  23
      clazzMapper.update(clazz);
  24
  }
  25
  
  26
  // ===== Mapper 接口 =====
  27
  @Select("select * from clazz where  id = #{id}")
  28
  Clazz getInfo(Integer id);
  29
  
  30
  void update(Clazz clazz);   // 动态 SQL 写在 XML 里

  显示更多显示更少

  1
  <update id="update">
  2
      update clazz
  3
      <set>
  4
          <if test="name != null and name != ''">
  5
              name = #{name},
  6
          </if>
  7
          <if test="room != null and room != ''">
  8
              room = #{room},
  9
          </if>
  10
          <if test="beginDate != null">
  11
              begin_date = #{beginDate},
  12
          </if>
  13
          <if test="endDate != null">
  14
              end_date = #{endDate},
  15
          </if>
  16
          <if test="masterId != null">
  17
              master_id = #{masterId},
  18
          </if>
  19
          <if test="subject != null">
  20
              subject = #{subject},
  21
          </if>
  22
          <if test="updateTime != null">
  23
              update_time = #{updateTime}
  24
          </if>
  25
      </set>
  26
      where id = #{id}
  27
  </update>

  显示更多显示更少

  说明：

  • 回显和修改是两个接口：回显是 GET /clazzs/{id}（路径参数，一个 id 换一个完整对象），修改是 PUT /clazzs（整个对象放请求体）。前端”先查后改”的流程和 75 篇员工修改一样；
  • 两个接口共用同一个 Clazz 实体：详情返回的对象直接填进表单，用户改完原样提交回来——连 id、createTime 都带着，所以修改接口拿到的是”完整对象”，能用 where id = #{id} 定位；
  • <set> 的作用是去掉最后一个多余的逗号：每个 #{} 后面都放心写逗号，只有最后一行 update_time = #{updateTime} 没写——它是唯一永远不会被跳过的字段（业务层一定会填），放最后最稳妥；
  • <if> 的判空要分开写：字符串字段用 != null and != ''（传空串视为没填），日期、数字字段只用 != null（masterId = 0 也算传了值）；
  • 系统自己维护的 createTime 不在更新列表里——创建时间一经写入就不再改（只有 update_time 每次更新都刷新）。

• 2-4 删除班级：有学员就不让删（业务校验 + 统一响应） 需求：表格每行有「删除」按钮，点它调删除接口。但业务上有个规则——班级下面还有学员时不允许删除，要给用户一句看得懂的话；班级下面是空的则正常删除。要求写出删除接口的三层实现（注意班级 id 是拼在路径里的），并说明那句提示是怎么变成前端收到的 JSON 的（前端最终收到的是 {"code":0,"msg":"班级下有学员, 不能直接删除~","data":null}）。 （练习文件 test_78_班级管理.java 的题目2-4 里给了写作区。）

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

  一级 · 思路：控制层从路径里取 id；业务层先”数一数这个班级有几个学员”（查学员表），有就中断并抛一个自定义异常、没有才执行删除；抛出去的异常要被全局异常处理器里一条形参是这个自定义异常类型的方法接住，转成统一响应 二级 · 方法：@DeleteMapping("/{id}") + @PathVariable Integer id；studentMapper.countByClazzId(id)（SQL 是 select count(*) from student where clazz_id = #{id}）；throw new BusinessException("班级下有学员, 不能直接删除~")；自定义异常类 extends RuntimeException；处理器里 @ExceptionHandler + Result.error(businessException.getMessage()) 三级 · 骨架：

  1
  @DeleteMapping("/____")
  2
  public Result delete(@________ Integer id){
  3
      clazzService.____(id);
  4
      return Result.success();
  5
  }
  6
  
  7
  @Override
  8
  public void deleteById(Integer id) {
  9
      //1. 查询班级下是否有学员
  10
      Integer count = studentMapper.________(id);
  11
      if(count > 0){
  12
          throw new __________("班级下有学员, 不能直接删除~");
  13
      }
  14
      //2. 如果没有, 再删除班级信息
  15
      clazzMapper.________(id);
  16
  }
  17
  
  18
  public class BusinessException extends ________ {
  19
      public BusinessException(String message) { super(message); }
  20
  }
  21
  
  22
  @ExceptionHandler
  23
  public Result handleBuinessException(__________ e) {
  24
      log.error("服务器异常", e);
  25
      return Result.____(e.getMessage());
  26
  }

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

  1
  // ===== Controller =====
  2
  @DeleteMapping("/{id}")
  3
  public Result delete(@PathVariable Integer id){
  4
      clazzService.deleteById(id);
  5
      return Result.success();
  6
  }
  7
  
  8
  // ===== Service 实现（业务校验就在这两步里）=====
  9
  @Override
  10
  public void deleteById(Integer id) {
  11
      //1. 查询班级下是否有学员
  12
      Integer count = studentMapper.countByClazzId(id);
  13
      if(count > 0){
  14
          throw new BusinessException("班级下有学员, 不能直接删除~");
  15
      }
  16
      //2. 如果没有, 再删除班级信息
  17
      clazzMapper.deleteById(id);
  18
  }
  19
  
  20
  // ===== Mapper 接口 =====
  21
  // StudentMapper
  22
  @Select("select count(*) from student where clazz_id = #{id}")
  23
  Integer countByClazzId(Integer id);
  24
  
  25
  // ClazzMapper
  26
  @Delete("delete from clazz where id = #{id}")
  27
  void deleteById(Integer id);
  28
  
  29
  // ===== 自定义异常 =====
  30
  public class BusinessException extends RuntimeException{
  31
      public BusinessException(String message) {
  32
          super(message);
  33
      }
  34
  }
  35
  
  36
  // ===== 全局异常处理器里新增的一条 =====
  37
  @ExceptionHandler
  38
  public Result handleBuinessException(BusinessException businessException) {
  39
      log.error("服务器异常", businessException);
  40
      return Result.error(businessException.getMessage());
  41
  }

  显示更多显示更少

  说明：

  • id 走的是路径参数：@DeleteMapping("/{id}") 里的 {id} 是占位符，@PathVariable 把它取出来赋给形参——和员工批量删除的 ?ids=1,2,3（查询参数）不是一回事（74 篇）；
  • “先查后删”的顺序不能颠倒：countByClazzId 查出 6 就 throw，删除语句压根不会发出去，班级还在库里——所以这个校验是”拦住”，不是”删了再恢复”；
  • 为什么不做级联删除：学员是独立的业务主体（74 篇里工作经历是员工的附属物，所以能一起删）；删班级只能删 clazz 一张表，学员要删去学员管理；
  • 异常变成 JSON 的链路：throw new BusinessException("班级下有学员, 不能直接删除~") → SpringMVC 找 @RestControllerAdvice 里的 @ExceptionHandler → 形参是 BusinessException 的 handleBuinessException 比兜底的 handleException(Exception e) 更具体、优先匹配 → Result.error(消息) 变成 {"code":0,"msg":"班级下有学员, 不能直接删除~","data":null}（76 篇）；
  • 自定义异常继承 RuntimeException 才能在 Service 里随便抛（不用在方法签名上声明 throws）；如果忘了给处理器加 handleBuinessException，它就落到兜底那条上，前端只会看到”出错啦, 请联系管理员~”；
  • 本机实测：删 id=1（下面 6 名学员）→ {"code":0,"msg":"班级下有学员, 不能直接删除~","data":null}；删一个没有学员的班级 → {"code":1,"msg":"success","data":null}。

三、综合题#

• 3-1 照着接口文档把班级管理六个接口全做出来并自测 这一题把本篇从头到尾走一遍，每一步都用响应 JSON 和数据库查询留下证据。

  1. 确认库表：clazz 表 6 条数据、student 表 18 条（建表脚本在课程 资料\03. 表结构\表结构.sql）；先把”哪个班级下面有几个学员”查出来记在纸上（select clazz_id, count(*) from student group by clazz_id;）；
  2. 照着接口文档”3. 班级管理”把六个接口的三层补齐：实体 Clazz、ClazzMapper（XML 里写条件分页查询和动态更新）、ClazzService / ClazzServiceImpl（分页、补时间、删除前查学员数）、ClazzController（六个方法）；
  3. 启动工程，先测条件分页查询：GET /clazzs?page=1&pageSize=3，把响应的 total 和 rows 的条数抄下来；再单独传 name（用班级名里的一两个关键字试模糊匹配）、单独传 begin / end（结课时间范围），各抄一次 total；
  4. 测全部班级：GET /clazzs/list，抄下 data 数组的条数——和上一步的 total 是同一个数吗？两条接口响应的结构一样吗？
  5. 测新增：POST /clazzs 新增一个班级（名称里带”测试”好认），响应是什么？再用全部班级接口确认它在清单里、用数据库查出它分到的 id；
  6. 测详情 + 修改：GET /clazzs/{刚才的id} 抄下响应里的字段（有没有 masterName / status？）；再 PUT /clazzs 把它改掉（比如只改 room），重新查详情确认改成功、update_time 变没变；
  7. 测删除：先删一个有学员的班级（比如 id=1），把响应整个抄下来；再删第 5 步新增的那个测试班级，抄下响应；最后查一次库：select count(*) from clazz;——班级数变了吗？
  8. 对照服务端日志，回答下面两个问题。 （练习文件 test_78_班级管理.java 的”综合题”一段里按这 8 步给了写作区。）

  回答：① 第 7 步里删”有学员的班级”时前端拿到的是 {"code":0,...} 而不是 500 报错页，这是谁的功劳？中间经过了哪几个环节？② 第 3 步里的 begin / end 过滤的是哪个日期字段？为什么不能想当然地换成开课时间？

  涉及知识点

  知识点	在这里的应用
  实战章的要求（PPT 3）	第 2 步——六个接口的路径、请求方式、参数名全部照接口文档写
  clazz 表与实体	第 1、5、6 步——name 唯一、subject 非空、master_id 关联 emp.id；实体多出 masterName / status
  条件分页 + 动态 SQL（<where>/<if>）	第 3 步——模糊匹配 concat、结课时间范围、<where> 去掉多余的 and
  PageHelper 分页	第 3 步——startPage 紧跟查询，Page 强转拿 total
  详情回显 + 动态更新（<set>）	第 6 步——@PathVariable 取 id，<set> 自动去逗号、传什么改什么
  删除的业务校验 + 统一响应	第 7、8 步——先查学员数，throw new BusinessException(...)，全局异常处理器转成 {"code":0,"msg":...}
  全局异常处理器	第 8 步①——@RestControllerAdvice + @ExceptionHandler 比兜底方法更具体

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

  一级 · 思路：先把”能查”跑通（分页、条件、全部列表都比对条数），再做增改删；删除那一步必须试两个班级——一个有人、一个没人，才能看出校验到底有没有生效 二级 · 方法：GET /clazzs?page=1&pageSize=3；GET /clazzs/list；POST /clazzs（JSON 请求体）；GET /clazzs/{id} / PUT /clazzs；DELETE /clazzs/{id}；查库用 select count(*) from clazz; 和 select clazz_id, count(*) from student group by clazz_id;；校验代码是 studentMapper.countByClazzId(id) + throw new BusinessException(...) + @ExceptionHandler 里的 Result.error(...) 三级 · 骨架：① 分页响应里 total = 、rows 有 ____ 条；② GET /clazzs/list 的 data 是（数组还是分页对象）、共 ____ 项；③ 新增返回 ____，它分到的 id 是 ____；④ 详情响应里 masterName / status ____（有/没有）；⑤ 删 id=1 返回 {"code":____,"msg":"____"}，再 select count(*) from clazz; 仍然是 ____；⑥ 删测试班级返回 {"code":____,"msg":"____"}

  参考答案（做完再点开）

  1. 库里的数据（本机实测）：clazz 6 条、student 18 条；按班级分布是 1 → 6 人、4 → 3 人、8 → 2 人，另有 clazz_id = 2 的 7 人（这个班级在 clazz 表里并不存在，课程原始数据如此），所以后面删 id=1 会被拦下、删 id=5/6/7 能删掉。 2. 六个接口的三层（与 2-1 ~ 2-4 的答案合起来就是课程工程）：

  1
  // Controller 六件套（路径 + 请求方式照接口文档）
  2
  @PostMapping                     Result save(@RequestBody Clazz clazz)
  3
  @GetMapping                      Result page(String name, ...LocalDate begin, ...LocalDate end,
  4
                                               @RequestParam(defaultValue="1") Integer page,
  5
                                               @RequestParam(defaultValue="10") Integer pageSize)
  6
  @GetMapping("/{id}")             Result getInfo(@PathVariable Integer id)
  7
  @PutMapping                      Result update(@RequestBody Clazz clazz)
  8
  @DeleteMapping("/{id}")          Result delete(@PathVariable Integer id)
  9
  @GetMapping("/list")             Result findAll()
  10
  
  11
  // Service 里三处"额外的活"
  12
  save   → clazz.setCreateTime(LocalDateTime.now()); clazz.setUpdateTime(LocalDateTime.now());
  13
  page   → PageHelper.startPage(page, pageSize); (Page<Clazz>) dataList → new PageResult(total, rows)
  14
  update → clazz.setUpdateTime(LocalDateTime.now());
  15
  deleteById → 先 studentMapper.countByClazzId(id)，>0 就 throw new BusinessException("班级下有学员, 不能直接删除~")

  显示更多显示更少

  3. 分页与条件（本机实测）：

  1
  GET /clazzs?page=1&pageSize=3
  2
  {"code":1,"msg":"success","data":{"total":6,"rows":[
  3
    {"id":8,"name":"JavaEE就业167期","room":"325","beginDate":"2023-11-20","endDate":"2024-05-10","masterId":36,"subject":1,...},
  4
    {"id":7,"name":"大数据就业58期",...},{"id":6,"name":"JavaEE就业166期",...}]}}

  total = 6、rows = 3 条（pageSize=3），按 update_time 倒序（id=8 最后被改过，排第一）。条件参数就两个：name 走 like concat('%',#{name},'%') 模糊匹配、begin / end 是结课时间的范围。 4. 全部班级（本机实测）：

  1
  GET /clazzs/list
  2
  {"code":1,"msg":"success","data":[{"id":1,"name":"JavaEE就业163期",...}, ...]}

  data 是数组（不是 {total, rows}），一共 6 项——和不带条件的 total: 6 是同一个数，但结构完全不同，前端取数据的方式也不一样。 5. 新增（本机实测）：POST /clazzs，body 是 {"name":"测试班级A","room":"999","beginDate":"2024-01-01","endDate":"2024-06-30","masterId":1,"subject":1}，响应 {"code":1,"msg":"success","data":null}；它由数据库自增分到了 id=9，在全部班级列表里能查到。 6. 详情与修改（本机实测）：GET /clazzs/1 返回该班级的完整字段（id、name、room、beginDate、endDate、masterId、subject、createTime、updateTime）——没有 masterName / status，那两个只在列表查询里算；PUT /clazzs 提交修改后返回 {"code":1,"msg":"success","data":null}，两个接口用的是同一个 Clazz 实体（详情回显的对象改完再整个提交回来）。动态更新只改了传值的列，业务层顺手把 update_time 刷成当前时间。 7. 删除的两种结果（本机实测）：

  1
  $ DELETE http://localhost:8080/clazzs/1        # 下面挂着 6 名学员
  2
  {"code":0,"msg":"班级下有学员, 不能直接删除~","data":null}
  3
  
  4
  $ DELETE http://localhost:8080/clazzs/9        # 刚新增的测试班级，没学员
  5
  {"code":1,"msg":"success","data":null}

  删 id=1 时删除语句根本没发出去，clazz 表里的班级一个没少；删掉刚新增的测试班级 id=9 之后，班级数从 7 回到 6（实验做完全部清理，库里仍是 6 个班级、18 名学员）。 8. 两个回答： ① 是 BusinessException + 全局异常处理器的功劳。链路是：Service 里 count > 0 → throw new BusinessException("班级下有学员, 不能直接删除~") → SpringMVC 捕获异常，交给 @RestControllerAdvice（GlobalExceptionHandler）→ 因为 handleBuinessException(BusinessException) 的形参比兜底的 handleException(Exception) 更具体，优先匹配到它 → Result.error(businessException.getMessage()) → 前端收到统一格式的 {"code":0,"msg":"班级下有学员, 不能直接删除~","data":null}。“不能删”是正常业务结果，不是程序崩了，所以不该返回 500；把它做成”异常 + 统一响应”的好处是 Service 不用逐层返回成功标记，前端只认 code、直接把 msg 弹给用户看。 ② 过滤的是 end_date（结课时间）。接口文档 3.1 的参数表写明”范围匹配的开始/结束时间（结课时间）“，页面上那两个输入框的标签也是”结课时间”，SQL 里对应 c.end_date between #{begin} and #{end}。不能换成开课时间的原因有两层：一是接口文档就是约定（前端按这个语义传参、页面标签也这么写，后端换了字段，前端拿到过滤结果会莫名其妙）；二是语义不同——“结课时间在前端选的区间内”和”开课时间在这个区间内”筛出来的是两批不同的班级（跨学期的班级差别很大）。