Controller：一个 PUT 方法#

1
@PutMapping
2
public Result update(@RequestBody Emp emp){
3
    log.info("修改员工: {}", emp);
4
    empService.update(emp);
5
    return Result.success();
6
}

@PutMapping 对应 PUT（改数据用 PUT、新增用 POST，61 篇的约定）；请求体是整份表单的 JSON，所以要用 @RequestBody。改的是”哪一个员工”由 JSON 里的 id 决定（不是路径参数）——所以接口文档里 id 是必须的。

Service：三件事，一件都不能漏#

1
@Transactional(rollbackFor = Exception.class)
2
@Override
3
public void update(Emp emp) {
4
    //1. 根据ID修改员工的基本信息
5
    emp.setUpdateTime(LocalDateTime.now());
6
    empMapper.updateById(emp);
7

8
    //2. 根据ID修改员工的工作经历信息
9
    //2.1 先根据员工ID删除原有的工作经历
10
    empExprMapper.deleteByEmpIds(Arrays.asList(emp.getId()));
11

12
    //2.2 再添加这个员工新的工作经历
13
    List<EmpExpr> exprList = emp.getExprList();
14
    if(!CollectionUtils.isEmpty(exprList)){
15
        exprList.forEach(empExpr -> empExpr.setEmpId(emp.getId()));
16
        empExprMapper.insertBatch(exprList);
17
    }
18
}

逐条说：

1. 改基本信息：先 emp.setUpdateTime(LocalDateTime.now()) 补上”最后修改时间”（前端表单里没有这一项，69 篇补的是创建/修改时间，这里只需要改修改时间），然后 empMapper.updateById(emp)；
2. 删掉这个员工原有的全部工作经历：empExprMapper.deleteByEmpIds(...) 就是上一篇写的那个”按一批员工 id 删经历”的方法，这里复用它——只不过这次要删的只有当前这一个员工，所以用 Arrays.asList(emp.getId()) 把一个 id 包成 List（方法要的是 List<Integer>，可以理解为”只有一个人的批量删除”）；
3. 插入表单里新的工作经历：和新增员工时一样，先 forEach 给每条经历填上 empId，再 insertBatch 批量插入；CollectionUtils.isEmpty(exprList) 判空——用户可能把工作经历全部删光，这时 exprList 是 null 或空集合，跳过插入（但第 2.1 步的删除照样执行，效果就是”这个员工现在没有任何经历”）。

@Transactional(rollbackFor = Exception.class)：这三件事合起来才叫”修改一个员工”。如果”删了老经历”之后、“插入新经历”失败了，不加事务就会留下一个工作经历凭空消失的员工；加了事务，整个方法一起回滚，数据还是修改前的样子（70 篇）。

经历 id 从 3、4 变成 5、6、7，是 bug 吗#

不是。emp_expr.id 是自增主键，它只会往前发号，删掉的行号不会回收：

1
改之前：id = 3（腾讯）、id = 4（字节跳动）      ← 原来的两条
2
改的时候：delete 把它们删掉 → 自增计数器不会退回去
3
          insert 三条新经历 → 拿到 5、6、7
4
改之后：id = 5、6、7                          ← 三条全新记录，和 3、4 没有任何关系

这个细节正是”先删后插”的证据：库里那三条不是被”改”出来的，而是新插进来的记录（老的两条真的被删了）。所以：

• 前端回显时带下来的经历 id，后端保存时并不依赖它——反正要全删重插（那些 id 只用于前端列表渲染，[修改接口的文档]里 exprList[].id 也是非必须的）；
• “经历 id 变了”不是数据错乱，是这种实现方式的正常现象；反过来说，如果哪天需要跟踪某条经历的历史（比如按经历 id 记流水），就不能用”先删后插”了，要改成按 id 逐条 update——这属于超出课程范围的取舍。

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

1. 两件事：修改员工 = 查询回显（点「编辑」时前端拿 id 来要这个员工的完整信息）+ 修改数据（用户改完点「保存」整份提交），对应两次请求、两个接口
2. 两个接口：回显是 GET /emps/{id}（路径参数，id 必须，响应 data 是一个员工对象、里面有 exprList）；修改是 PUT /emps（application/json，id/username/name/gender 必须，改的是哪个员工由 JSON 里的 id 决定）
3. 回显的 SQL：select e.*, ee.id ee_id, ee.emp_id ee_empid, ee.begin ee_begin, ee.end ee_end, ee.company ee_company, ee.job ee_job from emp e left join emp_expr ee on e.id = ee.emp_id where e.id = #{id}；用 left join 是因为员工可能一条工作经历都没有，内连接会查不到这种员工
4. 为什么要起 ee_ 别名：两张表有重名列（都有 id），e.* 已经把 emp 的列名占了；起别名后六列名字唯一，才能一一映射到集合元素的属性上
5. <resultMap> + <collection> 怎么写：结果集用 <id column property> 标主键（MyBatis 靠它把多行合并成同一个对象）、用 <result column property> 映射普通列（column 是结果集列名、property 是实体属性名，entry_date → entryDate 这类要自己写清）；集合部分 <collection property="exprList" ofType="com.itheima.pojo.EmpExpr">——property 是 Emp 里的集合字段名，ofType 是集合元素的类型
6. resultType 还是 resultMap（PPT 第 15 页）：字段名与属性名能直接对上 → resultType；对不上、或实体属性比较复杂（要装集合）→ resultMap 手动封装
7. Service 的三件事：① 补 updateTime 后 updateById(emp)；② deleteByEmpIds(Arrays.asList(emp.getId())) 删掉老经历（复用批量删除方法，一个 id 包成 List）；③ exprList 非空时给每条填 empId 再 insertBatch；整个方法 @Transactional(rollbackFor = Exception.class)
8. 先删后插的理由：前端提交的是保存那一刻表单里的全部经历，后端分不清哪条改了/哪条新增/哪条被删；全删再全插的结果一定等于表单现状（只插不删会越改越多、只删不插会清空）
9. 本机实测：回显 GET /emps/41 返回 exprList 2 条；改成 3 条经历后日志三条 SQL 顺序是 UPDATE → delete → insert，新经历的 id 从 3、4 变成 5、6、7（自增主键不回收——老记录真的被删了，新记录是新插的）
10. <set> + <if>（PPT 第 19 页）：<set> 自动生成 set 关键字、自动删掉更新字段后多余的逗号；<if> 判断字段有值才拼进 SQL，实现动态更新——替代”写死所有字段”那种不灵活、扩展性差的写法（全写死会把没提交的字段改成 NULL）

二、裸写题#

• 2-1 点「编辑」时，把员工和他的工作经历一起带出来（三层） 需求：前端在列表里点了某一行「编辑」，只知道这个员工的 id（比如 41），要打开一张表单、把这位员工的基本信息和他手下的所有工作经历都填进去。后端要提供一个查询接口：接住这个 id、把它交给业务层和数据访问层，返回统一响应结果，data 里是这位员工（工作经历要能一起装进去）。三层都要写。 （练习文件 test_75_查询回显与修改.java 的题目2-1 里给了写作区。）

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

  一级 · 思路：这个 id 是嵌在 URL 路径里的（/emps/41），不是查询参数；数据是两张表的（基本信息 + 工作经历列表），要用多表查询把它们一起查出来，再折成”一个对象 + 一个集合” 二级 · 方法：Controller 用 @GetMapping("/{id}") + @PathVariable Integer id；Service 直接 return empMapper.getById(id);；Mapper 用 left join 查两张表，配合 <resultMap> + <collection> 封装（结果映射写在 test_75_结果映射与动态更新.xml 里） 三级 · 骨架：

  1
  // Controller
  2
  @GetMapping("____")
  3
  public Result getInfo(@____ Integer id){
  4
      log.info("根据id查询员工信息, id: {}", id);
  5
      Emp emp = empService.____(id);
  6
      return Result.____(emp);
  7
  }
  8
  // Service
  9
  public Emp getInfo(Integer id) { return empMapper.____(id); }
  10
  // Mapper 接口
  11
  Emp ____(Integer id);

  参考答案（做完再点开）

  1
  // ===== Controller =====
  2
  @GetMapping("/{id}")
  3
  public Result getInfo(@PathVariable Integer id){
  4
      log.info("根据ID查询员工信息: {}", id);
  5
      Emp emp = empService.getInfo(id);
  6
      return Result.success(emp);
  7
  }
  8
  
  9
  // ===== Service（只读查询，不用事务，直接转交给 Mapper） =====
  10
  @Override
  11
  public Emp getInfo(Integer id) {
  12
      return empMapper.getById(id);
  13
  }
  14
  
  15
  // ===== Mapper 接口 =====
  16
  /**
  17
   * 根据ID查询员工信息以及工作经历信息
  18
   */
  19
  Emp getById(Integer id);

  显示更多显示更少

  自查：① 路径变量要用 @PathVariable（/emps/41 里那个 41 是路径的一部分，不是 ?id=41）；② 返回值是一个 Emp，工作经历装在它的 exprList 里；③ 完整 SQL 与结果映射见 2-3（left join + 自定义结果集）——本机实测 GET /emps/41 返回的 data 里 exprList 有 2 条经历。

• 2-2 保存修改：一次提交要动两张表（三层 + 讲清工作经历那一步） 需求：用户在修改表单里改完基本信息、又增删了几行工作经历，点「保存」把整份数据（含工作经历列表）以 JSON 提交到 /emps（PUT）。后端要：改这个员工的基本信息（顺手记下最后修改时间）；把这个员工原有的工作经历换成表单里的那份。两步都必须实现，并且要么一起成功、要么一起不做。写出三层代码，并说明工作经历那一步要怎么操作才能做到”表单里剩几条，库里就有几条”——如果只新增不删除会怎样？如果只删除不新增会怎样？用户把经历全删光时又该怎么处理？ （练习文件 test_75_查询回显与修改.java 的题目2-2 里给了写作区。）

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

  一级 · 思路：基本信息是”一行对一行”，改它用更新语句；工作经历是”一组对一组”、条数还会变，安全做法是先把这个人的老经历全删掉，再把新列表整个插进去（复用 74 篇那两个”按一批 id 操作”的方法）；两次数据库操作要包在事务里 二级 · 方法：Controller 用 @PutMapping + @RequestBody Emp emp；Service 加 @Transactional(rollbackFor = Exception.class)，里面 emp.setUpdateTime(LocalDateTime.now()) → empMapper.updateById(emp) → empExprMapper.deleteByEmpIds(Arrays.asList(emp.getId())) → 判空后 forEach 填 empId → empExprMapper.insertBatch(exprList)；单条更新语句先写 void updateById(Emp emp); 声明（动态更新的 XML 见 2-4） 三级 · 骨架：

  1
  // Controller
  2
  @____
  3
  public Result update(@____ Emp emp){
  4
      log.info("修改员工: {}", emp);
  5
      empService.____(emp);
  6
      return Result.____();
  7
  }
  8
  // Service
  9
  @____(rollbackFor = Exception.class)
  10
  public void update(Emp emp) {
  11
      emp.setUpdateTime(LocalDateTime.____());
  12
      empMapper.____(emp);                                   //1. 改基本信息
  13
      empExprMapper.____(Arrays.asList(emp.getId()));          //2.1 删掉老经历
  14
      List<EmpExpr> exprList = emp.getExprList();             //2.2 插入新经历
  15
      if(!CollectionUtils.____(exprList)){
  16
          exprList.forEach(e -> e.setEmpId(emp.____()));
  17
          empExprMapper.____(exprList);
  18
      }
  19
  }

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

  1
  // ===== Controller =====
  2
  @PutMapping
  3
  public Result update(@RequestBody Emp emp){
  4
      log.info("修改员工: {}", emp);
  5
      empService.update(emp);
  6
      return Result.success();
  7
  }
  8
  
  9
  // ===== Service 实现 =====
  10
  @Transactional(rollbackFor = Exception.class)
  11
  @Override
  12
  public void update(Emp emp) {
  13
      //1. 根据ID修改员工的基本信息
  14
      emp.setUpdateTime(LocalDateTime.now());
  15
      empMapper.updateById(emp);
  16
  
  17
      //2. 根据ID修改员工的工作经历信息
  18
      //2.1 先根据员工ID删除原有的工作经历
  19
      empExprMapper.deleteByEmpIds(Arrays.asList(emp.getId()));
  20
  
  21
      //2.2 再添加这个员工新的工作经历
  22
      List<EmpExpr> exprList = emp.getExprList();
  23
      if(!CollectionUtils.isEmpty(exprList)){
  24
          exprList.forEach(empExpr -> empExpr.setEmpId(emp.getId()));
  25
          empExprMapper.insertBatch(exprList);
  26
      }
  27
  }
  28
  
  29
  // ===== Mapper 接口 =====
  30
  void updateById(Emp emp);   // XML 版 SQL 见 2-4

  显示更多显示更少

  为什么”先删后插”：

  • 前端提交的是保存那一刻表单里的全部经历，里面分不出”哪条改了、哪条是新的、哪条被删了”（用户新加的行没有 id，用户删掉的行根本不在列表里）；
  • 所以后端把这个人名下的老经历全删、再把列表里的全插，结果一定等于”表单现在长什么样，库里就长什么样”；
  • 只插不删 → 老经历还在，经历会越改越多（出现重复）；只删不插 → 用户改了个公司名，工作经历被清空；
  • 记得两个细节：Arrays.asList(emp.getId()) 是把一个 id 包成 List（复用批量删除的方法），CollectionUtils.isEmpty(...) 判空是因为用户可能把经历全部删光（那就只删不插）。
  • 本机实测：日志里的三条 SQL 顺序就是 UPDATE → delete → insert；新经历 id 从 3、4 变成 5、6、7。

• 2-3 回显的查询 + 结果映射（写进 XML） 需求：要按 id 查出一位员工的全部信息，同时把他的所有工作经历作为一个列表装进这个员工对象里（他可能一条经历都没有）。这句查询和这句查询的”结果怎么封装”都写在 XML 映射文件里，写完回答：为什么给工作经历那几列都起了 ee_ 前缀的别名？“装集合”那部分写的两个属性分别是什么意思（一个是装到哪个字段、一个是集合里装什么类型）？两张表连接时为什么用左外连接而不是内连接？ （练习文件 test_75_结果映射与动态更新.xml 的题目2-3 里给了写作区。）

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

  一级 · 思路：两张表要一起查——用左外连接（保证”没有经历”的员工也查得出来）；查出来是多行，要折成”一个对象 + 一个集合”，所以不能用那个”直接对上就用”的简单写法，要自定义结果集 二级 · 方法：<resultMap id="empResultMap" type="com.itheima.pojo.Emp"> 里先写员工自己的列（<id> 标主键）、再写 <collection property="exprList" ofType="com.itheima.pojo.EmpExpr">；查询用 <select id="getById" resultMap="empResultMap">，select e.*, ee.id ee_id, ee.emp_id ee_empid, ... 三级 · 骨架：

  1
  <resultMap id="empResultMap" type="com.itheima.pojo.Emp">
  2
      <id column="id" property="____"/>
  3
      <result column="username" property="____"/>
  4
      ... （其余基本列）
  5
      <collection property="____" ofType="com.itheima.pojo.EmpExpr">
  6
          <id column="____" property="id"/>
  7
          <result column="ee_company" property="____"/>
  8
          ...
  9
      </collection>
  10
  </resultMap>
  11
  
  12
  <select id="____" resultMap="____">
  13
      select e.*, ee.id ____, ... from emp e ____ emp_expr ee on e.id = ee.____
  14
      where e.id = #{id}
  15
  </select>

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

  1
  <!--自定义结果集ResultMap-->
  2
  <resultMap id="empResultMap" type="com.itheima.pojo.Emp">
  3
      <id column="id" property="id" />
  4
      <result column="username" property="username" />
  5
      <result column="password" property="password" />
  6
      <result column="name" property="name" />
  7
      <result column="gender" property="gender" />
  8
      <result column="phone" property="phone" />
  9
      <result column="job" property="job" />
  10
      <result column="salary" property="salary" />
  11
      <result column="image" property="image" />
  12
      <result column="entry_date" property="entryDate" />
  13
      <result column="dept_id" property="deptId" />
  14
      <result column="create_time" property="createTime" />
  15
      <result column="update_time" property="updateTime" />
  16
  
  17
      <!--封装工作经历信息-->
  18
      <collection property="exprList" ofType="com.itheima.pojo.EmpExpr">
  19
          <id column="ee_id" property="id"/>
  20
          <result column="ee_empid" property="empId"/>
  21
          <result column="ee_begin" property="begin"/>
  22
          <result column="ee_end" property="end"/>
  23
          <result column="ee_company" property="company"/>
  24
          <result column="ee_job" property="job"/>
  25
      </collection>
  26
  </resultMap>
  27
  
  28
  <!--根据ID查询员工基本信息及员工的工作经历信息-->
  29
  <select id="getById" resultMap="empResultMap">
  30
      select
  31
          e.* ,
  32
          ee.id ee_id,
  33
          ee.emp_id ee_empid,
  34
          ee.begin ee_begin,
  35
          ee.end ee_end,
  36
          ee.company ee_company,
  37
          ee.job ee_job
  38
      from emp e left join emp_expr ee on e.id = ee.emp_id
  39
      where e.id = #{id}
  40
  </select>

  显示更多显示更少

  回答：

  • 为什么起 ee_ 别名：emp 和 emp_expr 有重名列（都有 id），而 e.* 已经把 emp 的那些列名占了；如果 emp_expr 的列还叫 id、company 这些名字，结果集里出现同名同姓的列，映射时分不清谁是谁。ee_ 前缀让六列名字唯一，才能分别对到 EmpExpr 的属性上；
  • <collection> 的两个属性：property="exprList" 指 Emp 里那个集合字段的名字（装到哪儿去），ofType="com.itheima.pojo.EmpExpr" 指集合里元素的类型（里面装什么）；
  • 顺带两点：<id column="id" property="id"/> 里的 <id> 是”主键”的意思——MyBatis 靠它把多行结果里属于同一个员工的行合并成一个对象；用 left join 是为了让没有工作经历的员工也能被查出来。

• 2-4 让更新语句只更新真正传了值的字段（写进 XML） 需求：现在这句员工更新语句把十一个字段全写死了，一次”只改姓名”的请求会把密码、头像这些没提交的字段覆盖成 NULL，以后表里加字段还得回来改它。请把它改成”传了值的字段才更新”的写法，写完说明新标签帮我们做了哪两件事、字符串字段为什么要多判一个空串。 （练习文件 test_75_结果映射与动态更新.xml 的题目2-4 里给了写作区。）

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

  一级 · 思路：这就是动态 SQL 的套路——每个字段用条件判断”有值才拼进去”；麻烦的是字段之间的逗号（不知道哪个是最后一个），所以要用一个专门管 set 的标签替我们收拾格式 二级 · 方法：把 SET 换成一个特殊标签，里面每个字段一行 <if test="字段 != null">列名 = #{属性名},</if>；字符串字段的 test 再加 and 字段 != ''（68 篇的写法） 三级 · 骨架：

  1
  <update id="updateById">
  2
      UPDATE emp
  3
      <____>
  4
          <if test="username != null and username != ''">username = #{username},</if>
  5
          <if test="gender != null">gender = #{gender},</if>
  6
          ...（其余字段）
  7
          <if test="updateTime != null">update_time = #{updateTime},</if>
  8
      </____>
  9
      WHERE id = #{id}
  10
  </update>

  参考答案（做完再点开）

  1
  <!--set标签: 会自动生成set关键字; 会自动的删除掉更新字段后多余,-->
  2
  <update id="updateById">
  3
      UPDATE emp
  4
      <set>
  5
          <if test="username != null and username != ''">username = #{username},</if>
  6
          <if test="password != null and password != ''">password = #{password},</if>
  7
          <if test="name != null and name != ''">name = #{name},</if>
  8
          <if test="gender != null">gender = #{gender},</if>
  9
          <if test="phone != null and phone != ''">phone = #{phone},</if>
  10
          <if test="job != null">job = #{job},</if>
  11
          <if test="salary != null">salary = #{salary},</if>
  12
          <if test="image != null and image != ''">image = #{image},</if>
  13
          <if test="entryDate != null">entry_date = #{entryDate},</if>
  14
          <if test="deptId != null">dept_id = #{deptId},</if>
  15
          <if test="updateTime != null">update_time = #{updateTime},</if>
  16
      </set>
  17
      WHERE id = #{id}
  18
  </update>

  显示更多显示更少

  说明：

  • 那个标签（<set>）帮我们做两件事：自动生成 set 关键字、自动删掉更新字段后面多余的逗号——所以每个 <if> 里的字段都可以无脑带上逗号，不用记得”最后一个别写”；
  • 字符串字段要多判空串（and username != ''）：null 和空字符串都表示”这次没有值”，只判 null 的话，前端传了个空串也会把数据库里的值改成空；
  • 数字/日期/时间字段只判 != null 就够了（它们没有”空串”这种状态）；
  • 对比原来”写死所有字段”那版：那版不灵活、扩展性差——本次没提交的字段（比如表单里压根没有的 password）会被 #{password} 写成 NULL，表里加字段还得回来改语句；
  • WHERE id = #{id} 千万不能丢：丢了就变成不带条件的全表更新。

三、综合题#

• 3-1 照着课程把”编辑 → 回显 → 改 → 保存”整条链路走一遍 这一题把本节从头到尾走一遍，每一步都留证据（响应 JSON、数据库查询、服务端日志）。

  1. 三层补齐两个接口：查询回显（GET，带路径变量，多表查询 + 自定义结果集）和修改数据（PUT，接收 JSON，改基本信息 + 换工作经历），更新语句用”只更新传了值的字段”那版；
  2. 先造一条带 2 段工作经历的数据：用新增接口新增一名员工（例如 username 用 zhangwei），记下后端生成的 id；
  3. 发一次查询回显请求 GET /emps/<id>，把返回的 JSON 抄下来——确认 data 是一个对象、里面 exprList 是2 条，记下这两条经历的 id；
  4. 发一次修改请求 PUT /emps：把姓名改掉、职位/薪资/部门改掉，工作经历换成 3 条（注意 JSON 里必须带 id）；
  5. 把服务端日志里这次请求发出的 SQL 按顺序抄下来（应该有三条），并去库里查：select * from emp where id = <id>; 和 select * from emp_expr where emp_id = <id>;——基本信息改对了吗？经历有几条？
  6. 再发一次 GET /emps/<id>，把新经历的 id 和第 3 步记下的老 id 比一比，然后解释：为什么 id 会变？
  7. 回答下面两个问题。

  （练习文件 test_75_查询回显与修改.java 的”综合题”一段里按这 7 步给了写作区。）

  回答：① 第 5 步的三条 SQL 为什么是这个顺序？如果改成”先插新经历、再删老经历”会发生什么？② 用户在工作经历里点了几次「添加工作经历」、又删掉了一行，后端怎么知道该存哪几条？

  涉及知识点

  知识点	在这里的应用
  两件事：回显 + 修改（PPT 11、12、16）	第 3、4 步——两次请求，先查后改
  多表查询（PPT 13）	第 1、3 步——left join 把基本信息和经历一起查出来
  <resultMap> + <collection>（PPT 14）	第 1、3 步——exprList 能装进对象的唯一原因
  resultType / resultMap 的选择（PPT 15）	第 1、3 步——重名列 + 集合属性只能靠自定义结果集
  PUT + Service 三件事（PPT 17、18）	第 1、4、5 步——更新基本信息、删老经历、插新经历
  <set> + <if>（PPT 19）	第 1、4 步——只更新传了值的字段（第 4 步里没传的字段不会被清空）
  先删后插	第 5、6、7 步——SQL 顺序与经历 id 变化的解释

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

  一级 · 思路：先把”回显”链路走通（一次请求拿到对象 + 经历列表），再把”修改”链路走通（三条 SQL 落库），最后用新旧经历的 id 对比证明”先删后插” 二级 · 方法：@GetMapping("/{id}") + @PathVariable；@PutMapping + @RequestBody；@Transactional(rollbackFor = Exception.class)；resultMap + collection；<set> + <if>；查库用 select * from emp_expr where emp_id = ? 三级 · 骨架：① 回显 GET http://localhost:8080/emps/____；② 修改 PUT http://localhost:8080/emps（body 里带 id + 3 条 exprList）；③ 日志三条 SQL 顺序：____ → ____ → ____；④ 新经历 id = ____（老的是 ____）

  参考答案（做完再点开）

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

  1
  // 回显
  2
  @GetMapping("/{id}")
  3
  public Result getInfo(@PathVariable Integer id){
  4
      log.info("根据ID查询员工信息: {}", id);
  5
      return Result.success(empService.getInfo(id));
  6
  }
  7
  // 修改
  8
  @PutMapping
  9
  public Result update(@RequestBody Emp emp){
  10
      log.info("修改员工: {}", emp);
  11
      empService.update(emp);
  12
      return Result.success();
  13
  }
  14
  @Transactional(rollbackFor = Exception.class)
  15
  public void update(Emp emp) {
  16
      emp.setUpdateTime(LocalDateTime.now());
  17
      empMapper.updateById(emp);
  18
      empExprMapper.deleteByEmpIds(Arrays.asList(emp.getId()));
  19
      List<EmpExpr> exprList = emp.getExprList();
  20
      if(!CollectionUtils.isEmpty(exprList)){
  21
          exprList.forEach(e -> e.setEmpId(emp.getId()));
  22
          empExprMapper.insertBatch(exprList);
  23
      }
  24
  }

  显示更多显示更少

  2～3. 回显结果（本机实测）：GET /emps/41 返回 {"code":1,"msg":"success","data":{ "id":41, "username":"zhangwei", ..., "exprList":[ {"id":3,...,"company":"腾讯","job":"后端开发"}, {"id":4,...,"company":"字节跳动","job":"高级开发"} ]}}——一个对象 + 两条经历，老经历的 id 是 3、4。 4～5. 修改后的数据库与日志（本机实测）：

  1
  emp       ：id=41 → 张伟改 | job=4 | salary=15000 | dept_id=3
  2
  emp_expr  ：3 条（腾讯/后端开发、阿里云/技术专家、美团/架构师）
  3
  
  4
  ==>  Preparing: UPDATE emp SET username = ?, ..., update_time = ? WHERE id = ?
  5
  ==>  Preparing: delete from emp_expr where emp_id in ( ? )
  6
  ==>  Preparing: insert into emp_expr(emp_id, begin, end, company, job) values (?,?,?,?,?) , (?,?,?,?,?) , (?,?,?,?,?)

  三条 SQL 的顺序就是 Service 里那三件事：改基本信息 → 删老经历 → 插新经历。 6. 经历 id 的变化（本机实测）：新经历 id 是 5、6、7，老的两条 3、4 已经不存在了。id 会变是因为 emp_expr.id 是自增主键——老记录被 delete 删掉后，自增计数不会退回去，新插进去的三条只能往后拿号。这恰好证明库里那三条不是”改”出来的，而是新插的记录（先删后插的必然结果）。 7. 两个回答： ① 先改员工、再删老经历、最后插新经历：改员工和它没有依赖（用的是同一个 id）；关键是经历的两步——必须先删后插，否则如果”先插新的”，库里一度会同时存在老经历和新经历（那一刻数据是脏的），万一后面的删除没执行成功，就会留下”新旧混杂、经历翻倍”的结果；而且课程里”删”这一步无论如何都要做（不做就会重复），先删后插的顺序让中间态更干净，也让事务回滚时的语义不含糊； ② 后端的依据是前端提交的那份列表本身：用户在表单里加行、删行、改行，提交时这份列表就是”当前表单里的全部经历”，后端既不追问”哪条改了”，也不看 exprList[].id——直接把库里这个员工的经历全删掉，再把这份列表全部插入。所以”表单里剩几条，库里就有几条”，用户增删了多少行都自然对上（exprList[].id 在前端只是渲染用的，接口文档里标的是”非必须”，本机实测里它也确实换了一批新号）。