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

1. 本章是实战章：PPT 只有 7 页（封面、需求、最终效果、暂停视频完成实战、实战说明），没有技术讲解；要求是严格按接口文档开发 + 前后端联调，路径、请求方式、参数格式三样都要和 资料\02. 接口文档 对上。
2. 学员管理要做的五件事：学员列表查询、删除学员、添加学员、修改学员、违纪处理；接口文档第 4 节把它们拆成六个接口（查询分成”列表”和”详情”）。
3. 学员表的三个唯一约束字段：no（学号）、phone（手机号）、id_card（身份证号）——新增/修改时重复会撞数据库，再由全局异常处理器转成 {"code":0,"msg":"'xxx' 已存在"}。
4. 列表查询接口：GET /students?name=&degree=&clazzId=&page=&pageSize=；name 模糊（like concat('%',#{name},'%')）、degree 与 clazzId 精确；三个条件都可选；排序按 update_time desc。
5. 列表为什么要关联班级表：student 里只有 clazz_id，页面要显示班级名称，所以 select s.*, c.name clazzName from student s left join clazz c on s.clazz_id = c.id，别名 clazzName 正好落到 Student 那个非表字段的属性上。
6. <where> 的作用：有条件时自动补 where，并去掉紧跟其后多余的 and——三个条件任意组合都不会拼错 SQL。
7. 详情与修改：详情 GET /students/{id}（@PathVariable，单表查，响应里没有 clazzName）；修改 PUT /students（JSON 里带 id）用 <set> + <if> 做到”传了才更新”，<set> 还会自动去掉最后一个多余的逗号。
8. 删除学员的参数格式是路径参数：DELETE /students/1,2,3，控制层 @DeleteMapping("/{ids}") + @PathVariable List<Integer> ids；它和员工删除的 DELETE /emps?ids=1,2,3（查询参数）不一样。
9. 违纪处理接口：PUT /students/violation/{id}/{score}，两个路径参数（id 学员 ID、score 扣除分数）；SQL 里 violation_count = violation_count + 1、violation_score = violation_score + #{score}、update_time = now()。
10. 本机实测：列表 total=18（按 update_time 倒序，崔百泉、郑成功排在前面）；clazzId=1 筛出 6 人；PUT /students/violation/1/5 之后段誉的 violation_count 0→1、violation_score 0→5。

二、裸写题#

• 2-1 新增学员：把请求体里的 JSON 落成一条记录 需求：页面上点「+ 新增学员」弹窗，填完提交；前端把学员信息（姓名、学号、性别、手机号、身份证号、是否来自院校、联系地址、学历、毕业时间、班级 ID）以 JSON 放进请求体，POST 到 /students。要求三层都写出来：控制层把请求体接成学员对象、业务层补上创建时间与修改时间、数据访问层把记录写进 student 表。写完回答：① 这条 insert 语句为什么不写 violation_count、violation_score 两列？② 如果学号和库里已有学员重复，接口会返回什么？ （练习文件 test_79_学员管理.java 的题目2-1 里给了写作区。）

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

  一级 · 思路：请求体是一整段 JSON → 要有一个能把它整体转成对象的形参；两个时间字段前端不传 → 由业务层用当前时间补上；SQL 只需要写”要落库的那些列” 二级 · 方法：控制层 @PostMapping + @RequestBody Student student；业务层 student.setCreateTime(LocalDateTime.now())、student.setUpdateTime(...)；数据访问层注解 @Insert("insert into student(...) values (...)")（69 篇） 三级 · 骨架：

  1
  // Controller
  2
  @____
  3
  public Result save(@____ Student student){
  4
      studentService.____(student);
  5
      return Result.success();
  6
  }
  7
  
  8
  // ServiceImpl
  9
  public void save(Student student) {
  10
      student.setCreateTime(____);
  11
      student.setUpdateTime(____);
  12
      studentMapper.____(student);
  13
  }

  参考答案（做完再点开）

  1
  // Controller
  2
  @PostMapping
  3
  public Result save(@RequestBody Student student){
  4
      studentService.save(student);
  5
      return Result.success();
  6
  }

  1
  // ServiceImpl
  2
  @Override
  3
  public void save(Student student) {
  4
      student.setCreateTime(LocalDateTime.now());
  5
      student.setUpdateTime(LocalDateTime.now());
  6
      studentMapper.insert(student);
  7
  }

  1
  // StudentMapper（课程写法：注解）
  2
  @Insert("insert into student(name, no, gender, phone,id_card, is_college, address, degree, graduation_date,clazz_id, create_time, update_time) VALUES " +
  3
          "(#{name},#{no},#{gender},#{phone},#{idCard},#{isCollege},#{address},#{degree},#{graduationDate},#{clazzId},#{createTime},#{updateTime})")
  4
  void insert(Student student);

  回答： ① 这两列在表定义里有默认值 0（violation_count tinyint unsigned default 0 not null），新学员没违过纪，插进去就是 0；而且前端表单里也没有”违纪次数/扣分”可填。违纪次数与扣分只由违纪处理接口去改，不经过新增与编辑。 ② 学号/手机号/身份证号都带唯一约束，重复时数据库抛 Duplicate entry ... for key 'student.no'，Spring 把它翻译成 DuplicateKeyException，被 76 篇的 handleDuplicateKeyException 接住，接口返回 {"code":0,"msg":"'<重复的值>' 已存在","data":null}——不会 500，也不会真的插进去。调试时换个学号/手机号/身份证号即可。

• 2-2 学员列表的条件分页查询：三个可选条件 + 班级名称 需求：页面顶部三个条件——姓名（模糊）、最高学历（精确下拉）、所属班级（精确下拉），三个都可以留空；列表里”班级”那一列要显示班级名称（不是 ID）；结果按最后操作时间倒序、分页显示。要求写全三层，并说明列表 SQL 里为什么要关联班级表。 （练习文件 test_79_学员管理.java 的题目2-2 里给了写作区。）

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

  一级 · 思路：条件可有可无 → 动态 SQL；要显示班级名字 → 关联 clazz 表并起个别名装进实体；分页 → PageHelper 拦下紧跟着的那条查询 二级 · 方法：控制层 @GetMapping 接 name/degree/clazzId + @RequestParam(defaultValue = "1") Integer page/pageSize（68 篇）；业务层 PageHelper.startPage(page, pageSize) 后紧跟 studentMapper.list(...)，把结果强转 Page<Student> 取 getTotal()（67 篇）；数据访问层 XML 里 select s.*, c.name clazzName from student s left join clazz c on s.clazz_id = c.id + <where><if> + order by s.update_time desc 三级 · 骨架：

  1
  <select id="list" resultType="com.itheima.pojo.Student">
  2
      select s.*, ____ clazzName from student s ____ clazz c on s.clazz_id = c.id
  3
      <____>
  4
          <if test="name != null and name != ''">
  5
              s.name like ____('%',#{name},'%')
  6
          </if>
  7
          <if test="degree != null">
  8
              ____ s.degree = #{degree}
  9
          </if>
  10
          <if test="clazzId != null">
  11
              and s.____ = #{clazzId}
  12
          </if>
  13
      </where>
  14
      order by s.update_time ____
  15
  </select>

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

  1
  // Controller
  2
  @GetMapping
  3
  public Result page(String name,
  4
                     Integer degree,
  5
                     Integer clazzId,
  6
                     @RequestParam(defaultValue = "1") Integer page,
  7
                     @RequestParam(defaultValue = "10") Integer pageSize){
  8
      PageResult pageResult = studentService.page(name, degree, clazzId, page, pageSize);
  9
      return Result.success(pageResult);
  10
  }

  1
  // ServiceImpl
  2
  @Override
  3
  public PageResult page(String name, Integer degree, Integer clazzId, Integer page, Integer pageSize) {
  4
      PageHelper.startPage(page, pageSize);
  5
      List<Student> studentList = studentMapper.list(name, degree, clazzId);
  6
      Page<Student> p = (Page<Student>) studentList;
  7
      return new PageResult(p.getTotal(), p.getResult());
  8
  }

  1
  <select id="list" resultType="com.itheima.pojo.Student">
  2
      select s.*, c.name clazzName from student s left join clazz c on s.clazz_id = c.id
  3
      <where>
  4
          <if test="name != null and name != ''">
  5
              s.name like concat('%',#{name},'%')
  6
          </if>
  7
          <if test="degree != null">
  8
              and s.degree = #{degree}
  9
          </if>
  10
          <if test="clazzId != null">
  11
              and s.clazz_id = #{clazzId}
  12
          </if>
  13
      </where>
  14
      order by s.update_time desc
  15
  </select>

  显示更多显示更少

  为什么要关联班级表：student 表里只有 clazz_id，页面要显示的是班级名称，所以把 clazz 连进来取 c.name，并起别名 clazzName——它正好对应 Student 实体里那个不属于表字段的 clazzName 属性，resultType 一自动映射就装上了。本机实测：不加条件 total=18；加 clazzId=1 后 total=6（钟万仇、天山童姥、萧峰、虚竹、萧远山、阿朱）。

• 2-3 学员的「编辑」流程：详情回显 + 按需修改 需求：点行尾的「编辑」，弹窗要先把这名学员的信息查出来回显（按 ID 查详情）；改完点保存，前端把学员 JSON（带 id）以 PUT 发到 /students，只有提交上来的字段才更新，最后修改时间由后端补。要求写出这两个接口的三层实现，并说明 <set> 这个标签帮了什么忙。 （练习文件 test_79_学员管理.java 的题目2-3 里给了写作区。）

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

  一级 · 思路：详情是”按 id 查一个”→ 路径参数 + 单表查询；修改是”按 id 改若干列”→ 请求体 + <set> 动态更新；updateTime 由 Service 补，这样 <set> 里必定有一项 二级 · 方法：@GetMapping("/{id}") + @PathVariable / @PutMapping + @RequestBody；Mapper 的查询 @Select("select * from student where id = #{id}")；XML 里 <update id="update"> 的 <set><if test="列 != null and 列 != ''">列 = #{列},</if></set>，最后 where id = #{id} 三级 · 骨架：

  1
  // Controller
  2
  @GetMapping("/{id}")
  3
  public Result getInfo(@____ Integer id){
  4
      return Result.success(studentService.____(id));
  5
  }
  6
  
  7
  @PutMapping
  8
  public Result update(@____ Student student){
  9
      studentService.update(student);
  10
      return Result.success();
  11
  }
  12
  
  13
  // ServiceImpl.update：补 updateTime
  14
  student.setUpdateTime(____);

  参考答案（做完再点开）

  1
  // Controller
  2
  @GetMapping("/{id}")
  3
  public Result getInfo(@PathVariable Integer id){
  4
      Student student = studentService.getInfo(id);
  5
      return Result.success(student);
  6
  }
  7
  
  8
  @PutMapping
  9
  public Result update(@RequestBody Student student){
  10
      studentService.update(student);
  11
      return Result.success();
  12
  }

  1
  // ServiceImpl
  2
  @Override
  3
  public Student getInfo(Integer id) {
  4
      return studentMapper.getById(id);
  5
  }
  6
  
  7
  @Override
  8
  public void update(Student student) {
  9
      student.setUpdateTime(LocalDateTime.now());
  10
      studentMapper.update(student);
  11
  }

  1
  // StudentMapper：详情条件简单，用注解
  2
  @Select("select * from student where id = #{id}")
  3
  Student getById(Integer id);

  1
  <!-- StudentMapper.xml：按需更新（只列前面几列，其余同理） -->
  2
  <update id="update">
  3
      update student
  4
      <set>
  5
          <if test="name != null and name != ''">
  6
              name = #{name},
  7
          </if>
  8
          <if test="gender != null">
  9
              gender = #{gender},
  10
          </if>
  11
          <if test="clazzId != null">
  12
              clazz_id = #{clazzId},
  13
          </if>
  14
          <if test="updateTime != null">
  15
              update_time = #{updateTime}
  16
          </if>
  17
      </set>
  18
      where id = #{id}
  19
  </update>

  显示更多显示更少

  <set> 帮了两件事：有字段时自动补 set 关键字、自动去掉最后一个多余的逗号（所以每个 <if> 里的 xxx = #{xxx}, 都能放心带逗号）。另外：字符串字段判 != null and != ''（防止把库里的值覆盖成空串），数字/日期字段只判 != null；Service 每次都补 updateTime，所以 <set> 里至少有一项，不会拼出 update student where id = ? 这种语法错误的 SQL。详情响应里没有 clazzName，因为编辑弹窗用 clazzId 选班级，单表 select * 就够。

• 2-4 批量删除学员（注意路径参数） 需求：表格勾选若干行点「批量删除」，前端把选中的学员 id 拼成 1,2,3 放进路径里发到 /students/1,2,3；单行的「删除」只传一个 id，走同一个接口。要求写全三层，并回答：它和 74 篇的员工删除接口在”参数格式”上差在哪？控制层注解因此有什么不同？ （练习文件 test_79_学员管理.java 的题目2-4 里给了写作区。）

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

  一级 · 思路：参数在 URL 路径里而不是问号后面 → 接参用另一种注解；SQL 是”按一批 id 删除” → in + <foreach>（和员工删除那段完全一样） 二级 · 方法：@DeleteMapping("/{ids}") + @PathVariable List<Integer> ids（对比员工的 @RequestParam List<Integer> ids）；XML 里 <delete id="delete">delete from student where id in <foreach collection="ids" item="id" separator="," open="(" close=")">#{id}</foreach></delete>（74 篇） 三级 · 骨架：

  1
  @____("/{ids}")
  2
  public Result delete(@____ List<Integer> ids){
  3
      studentService.delete(ids);
  4
      return Result.success();
  5
  }

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

  参考答案（做完再点开）

  1
  // Controller
  2
  @DeleteMapping("/{ids}")
  3
  public Result delete(@PathVariable List<Integer> ids){
  4
      studentService.delete(ids);
  5
      return Result.success();
  6
  }
  7
  
  8
  // ServiceImpl：学员只有一张表要删，不需要事务
  9
  @Override
  10
  public void delete(List<Integer> ids) {
  11
      studentMapper.delete(ids);
  12
  }

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

  回答：员工删除是 DELETE /emps?ids=1,2,3——参数是查询参数（问号后面），控制层用 @RequestParam List<Integer> ids（甚至不写注解的 Integer[] ids 也行）；学员删除是 DELETE /students/1,2,3——参数是路径参数（路径里的一段），必须用 @PathVariable List<Integer> ids。Spring 会把路径里逗号分隔的 1,2,3 自动切成三个元素绑进 List。XML 里 <foreach> 的写法两边完全一样。照接口文档写，别把员工那套地址抄过来（会 404）。

三、综合题#

• 3-1 照着课程把”违纪处理”从接口做到数据库，并验证数据是”累加”的 这一题只做一个功能，但要走完”看接口文档 → 写三层 → 发请求 → 查库 → 回头看 SQL → 解释设计”的整条路，每步都留证据。

  1. 按接口文档 4.6 写出违纪处理的三层实现（控制层接两个路径参数、业务层透传、数据访问层写那条 update），写在 test_79_违纪处理.java 里；
  2. 找一个没被处理过的学员，记下他的 id 和当前的 violation_count / violation_score（比如 select id, name, violation_count, violation_score from student where violation_count = 0;）；
  3. 启动工程，发一次请求：PUT http://localhost:8080/students/violation/<id>/5，把响应的 JSON 抄下来；
  4. 再查一次库，把 violation_count 与 violation_score 的新值抄下来——数一数次数涨了几、分数涨了几；
  5. 用同一个 id 再发一次 PUT /students/violation/<id>/3（这次扣 3 分），再查库，把两个字段的新值抄下来；
  6. 从 StudentMapper 里把这条 SQL 原文抄出来，圈出”哪一部分是次数 +1""哪一部分是分数累加""哪一部分保证只改这一个学员”；
  7. 回答下面的问题。

  （练习文件 test_79_违纪处理.java 的题目3-1 里按这 7 步给了写作区。）

  回答：① 如果把违纪处理改成”先 getById 查出来、在 Java 里把次数 +1、分数加上去，再调 update 写回”，会有什么风险？② 这个接口为什么把”扣多少分”设计成一个路径参数、让前端传，而”违纪次数”却要后端自己加？

  涉及知识点

  知识点	在这里的应用
  接口文档 4.6 违纪处理	第 1、3 步——PUT /students/violation/{id}/{score}，两个路径参数
  @PathVariable	第 1、3 步——两个同名形参自动接住路径里的 id 与 score
  一条 SQL 完成累加	第 4、5、6 步——violation_count = violation_count + 1、violation_score = violation_score + #{score}
  where id = #{id}	第 6、7 步——算错条件就会改到所有人
  读-改-写的并发问题	第 7 步——先查后改会丢更新
  本机实测	第 3～5 步——段誉 0/0 → 1/5

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

  一级 · 思路：路径里两段 {id}、{score} 各需要一个 @PathVariable 形参；业务规则写在 SQL 里——“次数在原值上加 1""分数在原值上加这次扣的分” 二级 · 方法：@PutMapping("/violation/{id}/{score}") + @PathVariable Integer id, @PathVariable Integer score；Mapper 用 @Update，SQL 是 update student set violation_count = violation_count + 1, violation_score = violation_score + #{score}, update_time = now() where id = #{id} 三级 · 骨架：

  1
  @PutMapping("/violation/{____}/{____}")
  2
  public Result violationHandle(@PathVariable Integer id , @PathVariable Integer score){
  3
      studentService.____(id, score);
  4
      return Result.success();
  5
  }

  1
  @Update("update student set violation_count = violation_count + ____ , violation_score = violation_score + ____ , update_time = now() where id = ____")
  2
  void updateViolation(Integer id, Integer score);

  参考答案（做完再点开）

  1. 三层代码（课程 StudentController.violationHandle / StudentServiceImpl.violationHandle / StudentMapper.updateViolation）：

  1
  @PutMapping("/violation/{id}/{score}")
  2
  public Result violationHandle(@PathVariable Integer id , @PathVariable Integer score){
  3
      studentService.violationHandle(id, score);
  4
      return Result.success();
  5
  }

  1
  @Override
  2
  public void violationHandle(Integer id, Integer score) {
  3
      studentMapper.updateViolation(id, score);
  4
  }

  1
  @Update("update student set violation_count = violation_count + 1 , violation_score = violation_score + #{score} , update_time = now() where id = #{id}")
  2
  void updateViolation(Integer id, Integer score);

  2. 找一个没被处理过的学员：本机实测挑的是 id=1 段誉（violation_count=0、violation_score=0）。 3. 请求与响应（本机实测）：

  1
  $ PUT http://localhost:8080/students/violation/1/5
  2
  {"code":1,"msg":"success","data":null}

  4. 第一次查库：violation_count 0 → 1（涨了 1），violation_score 0 → 5（涨了这次扣的 5 分）。 5. 再扣 3 分：本机实测只跑了第 3 步那一发（跑完已把数据还原成 0/0）；你自己按第 5 步再发一次 PUT /students/violation/1/3 之后查库，violation_count 会是 2、violation_score 会是 8——次数再 +1、分数再 +3，是在上一次的结果上继续加，不是重置。 6. SQL 三个部位：

  • 次数 +1 → violation_count = violation_count + 1；
  • 分数累加 → violation_score = violation_score + #{score}（#{score} 就是路径里传进来的那个分数）；
  • 只改一个人 → where id = #{id}（少了它会把全表所有人都记一次违纪）。 另外 update_time = now() 顺手刷新最后操作时间，列表按 update_time desc 排序，刚被处理过的学员会冒到最前面。 7. 两个回答： ① 会丢更新。“查 → 在 Java 里算 → 写回”是三步，中间有时间间隙：两个老师同时给同一个学员记违纪，可能都先读到 violation_count=3，各自在内存里算成 4，再分别写回 4——数据库里最终只涨了 1 次，另一次被覆盖了（典型的读-改-写并发问题）。写成 violation_count = violation_count + 1 是把”读当前值、加 1、写回”合成一条 SQL 原子执行，两个请求先后到达都会正确累加，而且少了一次查询。 ② “扣多少分”是这次操作的输入，只有前端（老师点的那个弹窗）知道，所以做成参数传进来；“已经违纪几次”是库里的状态，前端手里的值可能已经过期，让它传反而有覆盖成旧值的风险，所以由后端在 SQL 里”在现有值上加 1”。一句话：输入参数传进来，状态字段库内自增。