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

1. 拆三层的原因：原来的 Controller 一个方法里同时做了”读文件（数据访问）""解析封装（逻辑处理）""接收请求、响应数据”三件事，复用性差、难以维护；拆分是为了遵循单一职责原则（一个类只负责一件事）
2. 三层与职责：**controller（控制层）**接收前端发送的请求、对请求进行处理并响应数据；**service（业务逻辑层）**处理具体的业务逻辑；dao（数据访问层 / 持久层，Data Access Object）负责数据访问操作，包括数据的增、删、改、查
3. 调用方向：浏览器 → Controller → Service → Dao，单向；dao 只跟数据打交道，不反过来调 service
4. 包结构：com.itheima 下 controller（控制层）、service + service.impl（业务层接口与实现）、dao + dao.impl（数据访问层接口与实现）、pojo（实体类）；类名体现层：XxxController、XxxService/XxxServiceImpl、XxxDao/XxxDaoImpl
5. 每层先接口后实现：上层代码只依赖接口（这样以后换实现类时影响最小）——这一条是下一篇”分层解耦”的伏笔
6. dao 层这段干什么：getResourceAsStream("user.txt") + IoUtil.readUtf8Lines(in, new ArrayList<>())——把数据读出来，返回 List<String>（一行一个元素），不做任何业务加工
7. service 层这段干什么：List<String> lines = userDao.list(); 拿数据 → lines.stream().map(line -> {...}).toList() 解析封装成 List<User> → return userList;（业务逻辑就在 map 里）
8. controller 层这段干什么：@RestController 标识请求处理类、@RequestMapping("/list") 定路径，方法体只留两行——List<User> userList = userService.list(); 和 return userList;
9. 复用性与维护性的具体好处：数据来源换成数据库只改 dao；业务规则变了只改 service；接口地址/方式变了只改 controller；别的模块要用用户数据可以直接调 service，不用复制粘贴
10. 拆分是重构不是改需求：对外的接口合同（路径、返回数据）不变；实测本机最终代码访问 /list 仍是 HTTP/1.1 200 + Content-Type: application/json

二、裸写题#

• 2-1 把”全塞在 Controller 里”的代码拆成三层 下面这个类是上一个练习写出来的（能跑，但所有事都挤在一起）：

  1
  @RestController
  2
  public class UserController {
  3
  
  4
      @RequestMapping("/list")
  5
      public List<User> list() throws Exception {
  6
          // 1. 读文件
  7
          InputStream in = this.getClass().getClassLoader().getResourceAsStream("user.txt");
  8
          ArrayList<String> lines = IoUtil.readLines(in, StandardCharsets.UTF_8, new ArrayList<>());
  9
  
  10
          // 2. 解析封装
  11
          List<User> userList = lines.stream().map(line -> {
  12
              String[] parts = line.split(",");
  13
              Integer id = Integer.parseInt(parts[0]);
  14
              String username = parts[1];
  15
              String password = parts[2];
  16
              String name = parts[3];
  17
              Integer age = Integer.parseInt(parts[4]);
  18
              LocalDateTime updateTime = LocalDateTime.parse(parts[5],
  19
                      DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
  20
              return new User(id, username, password, name, age, updateTime);
  21
          }).collect(Collectors.toList());
  22
  
  23
          // 3. 响应数据
  24
          return userList;
  25
      }
  26
  }

  显示更多显示更少

  请把它按三层架构拆开，写出拆分后每一层的代码（含包名）：

  1. 把”读文件”的部分挪到数据访问层的一个类里（这一层要有一个接口 + 一个实现类）；
  2. 把”把文本解析成用户对象”的部分挪到业务层（同样接口 + 实现类）；
  3. 控制层里只留下”接收请求、响应数据”；
  4. 在每层的 package 上一行用中文注释写清”这是哪一层、职责是什么”。 （练习文件 test_37_三层架构拆分.java 里按 dao / service / controller 三块给了写作区。）
  提示（先自己想，实在想不出再点开）

  一级 · 思路：先按”读文件 → 加工 → 返回”把原方法切成三段，再从下往上写：最底下放”读文件”，中间放”加工”，最上面只留”调用 + 返回” 二级 · 方法：包用 com.itheima.dao(.impl) / com.itheima.service(.impl) / com.itheima.controller；dao 接口 UserDao 的方法返回 List<String>（一行一条），实现类 UserDaoImpl 里读文件；service 接口 UserService 的方法返回 List<User>，实现类 UserServiceImpl 里 new UserDaoImpl() + 解析；controller 里 new UserServiceImpl() + 调 list()；注解仍然是 @RestController + @RequestMapping("/list") 三级 · 骨架：dao：public interface UserDao { List<String> findAll(); } + class UserDaoImpl implements UserDao { ...读文件... }；service：public interface UserService { List<User> findAll(); } + class UserServiceImpl implements UserService { private UserDao userDao = new ____(); ... }；controller：class UserController { private UserService userService = new ____(); @RequestMapping("/list") public List<User> list(){ List<User> userList = ____.findAll(); return ____; } }

  参考答案（做完再点开）

  拆完是四个文件（包名按课程习惯）：

  1
  // ============ 数据访问层 dao ============
  2
  package com.itheima.dao;
  3
  
  4
  import java.util.List;
  5
  
  6
  public interface UserDao {
  7
      /** 加载用户数据（一行一条文本） */
  8
      public List<String> findAll();
  9
  }

  1
  // ============ 数据访问层 dao 的 实现 ============
  2
  package com.itheima.dao.impl;
  3
  
  4
  import cn.hutool.core.io.IoUtil;
  5
  import com.itheima.dao.UserDao;
  6
  
  7
  import java.io.InputStream;
  8
  import java.util.ArrayList;
  9
  import java.util.List;
  10
  
  11
  public class UserDaoImpl implements UserDao {
  12
      @Override
  13
      public List<String> findAll() {
  14
          InputStream in = this.getClass().getClassLoader().getResourceAsStream("user.txt");
  15
          return IoUtil.readUtf8Lines(in, new ArrayList<>());
  16
      }
  17
  }

  显示更多显示更少

  1
  // ============ 业务逻辑层 service 的 实现 ============
  2
  package com.itheima.service.impl;
  3
  
  4
  import com.itheima.dao.UserDao;
  5
  import com.itheima.dao.impl.UserDaoImpl;
  6
  import com.itheima.pojo.User;
  7
  import com.itheima.service.UserService;
  8
  
  9
  import java.time.LocalDateTime;
  10
  import java.time.format.DateTimeFormatter;
  11
  import java.util.List;
  12
  
  13
  public class UserServiceImpl implements UserService {
  14
  
  15
      private UserDao userDao = new UserDaoImpl();   // 业务层需要 dao 帮它取数据
  16
  
  17
      @Override
  18
      public List<User> findAll() {
  19
          List<String> lines = userDao.findAll();      // ① 要数据
  20
          List<User> userList = lines.stream().map(line -> {   // ② 业务加工
  21
              String[] parts = line.split(",");
  22
              return new User(
  23
                      Integer.parseInt(parts[0]), parts[1], parts[2], parts[3],
  24
                      Integer.parseInt(parts[4]),
  25
                      LocalDateTime.parse(parts[5], DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
  26
          }).toList();
  27
          return userList;                            // ③ 交差
  28
      }
  29
  }

  显示更多显示更少

  1
  // ============ 控制层 controller ============
  2
  package com.itheima.controller;
  3
  
  4
  import com.itheima.pojo.User;
  5
  import com.itheima.service.UserService;
  6
  import com.itheima.service.impl.UserServiceImpl;
  7
  import org.springframework.web.bind.annotation.RequestMapping;
  8
  import org.springframework.web.bind.annotation.RestController;
  9
  
  10
  import java.util.List;
  11
  
  12
  @RestController
  13
  public class UserController {
  14
  
  15
      private UserService userService = new UserServiceImpl();   // 控制层需要业务层帮它办事
  16
  
  17
      @RequestMapping("/list")
  18
      public List<User> list() {
  19
          List<User> userList = userService.findAll();   // ① 调 service
  20
          return userList;                               // ② 响应数据
  21
      }
  22
  }

  显示更多显示更少

  （UserService 接口就是 public interface UserService { List<User> findAll(); }，包在 com.itheima.service。） 检查点：① 控制层的方法体只剩”调 service + return”，读文件的代码一行都不剩；② user.txt 只被 dao 层提起（成立的话说明”数据访问”职责已经归位）；③ 启动工程访问 /list，返回的 JSON 和拆分前一模一样。

• 2-2 这段话该写在哪个文件里 一个”员工管理”的三层架构工程，现在要加下面这几个功能。请为每条写出：改哪一个包（层）里的哪个文件（接口还是实现类也要写清），并说明理由：

  1. 员工数据从内存里的 List 改成从 emp.txt 读；
  2. 员工姓名入库时要统一去掉前后空格；
  3. 新增一个接口 GET /emps，把员工列表返回给浏览器；
  4. 以后员工的薪资要用”元”为单位展示（原来存的是”分”）；
  5. 员工数据要按入职时间倒序返回。 （练习文件 test_37_每段代码属于哪一层.java 里给了表格与写作区。）
  提示（先自己想，实在想不出再点开）

  一级 · 思路：对每一条问一句”这件事是跟数据存取有关，还是跟业务规则有关，还是跟请求响应有关” 二级 · 方法：碰数据来源/读写方式 → dao 包（XxxDao / XxxDaoImpl）；碰”数据怎么算、怎么加工” → service 包（XxxService / XxxServiceImpl）；碰”暴露什么地址、收什么参数、返回什么” → controller 包（XxxController） 三级 · 骨架：com.itheima.____.Xxx____Impl；如果是”新增一个接口”，除了实现类，接口里也要加方法签名

  参考答案（做完再点开）

  需求	改哪一层	具体文件	理由
  ① 数据来源从内存 List 改成读 emp.txt	dao（数据访问层）	com.itheima.dao.impl.EmpDaoImpl（实现类里换读法，接口 EmpDao 的方法签名通常不用改）	“数据从哪来、怎么读写”是数据访问的职责
  ② 姓名统一去空格	service（业务逻辑层）	com.itheima.service.impl.EmpServiceImpl	这是”业务规则”（数据要怎么处理），不是存取问题
  ③ 新增接口 GET /emps	controller（控制层）	com.itheima.controller.EmpController 加一个方法	“暴露什么地址、把结果响应出去”是控制层的职责（如果 service 还没有对应方法，EmpService/EmpServiceImpl 里也要补）
  ④ 薪资的分转成元	service（业务逻辑层）	com.itheima.service.impl.EmpServiceImpl	单位换算是业务规则
  ⑤ 按入职时间倒序返回	service（业务逻辑层）	com.itheima.service.impl.EmpServiceImpl	“结果怎么排”属于业务逻辑（如果排序要下推到数据库，也可以让 dao 直接按条件查）
  一句话检验：dao 只管”把数据搬进搬出”，service 管”数据怎么算”，controller 管”对外的接口长什么样”。

• 2-3 为什么要先写接口再写实现类 课程代码里每一层都是”一个接口 + 一个实现类”（UserService / UserServiceImpl，UserDao / UserDaoImpl）。请回答：

  1. 上层（比如 controller）是依赖接口还是依赖实现类？在代码里体现为哪一行是”接口类型”、哪一行是”实现类名称”？
  2. 如果哪天要换实现（比如业务规则变了，要写一个新的 UserServiceImpl2），依赖接口的写法能帮你省掉什么麻烦？
  3. 这种写法和下一篇要讲的”分层解耦”有什么关系？（一句话即可） （练习文件 test_37_接口与实现类.java 里给了写作区。）
  提示（先自己想，实在想不出再点开）

  一级 · 思路：盯住那一行成员变量：等号左边的类型和等号右边 new 出来的东西，分别是什么？ 二级 · 方法：左边是接口类型（UserService），右边是实现类（new UserServiceImpl()）——左边写的是”我需要一个能干这些活的东西”，右边写的是”具体用谁” 三级 · 骨架：private ____ userService = new ____();（左接口、右实现）

  参考答案（做完再点开）

  1. 依赖接口。那一行是：

     1
     private UserService userService = new UserServiceImpl();
     2
     //      ↑ 接口类型（能干什么）        ↑ 具体实现（谁来干）

     成员变量的类型是接口 UserService；new 出来的才是实现类 UserServiceImpl。
  2. 换实现时，上层的类型声明不用改（还是 UserService），只需要改”new 的那一下”——上游的方法调用（userService.list()）全部照旧，编译不会因为”类型不对”而全线报错。
  3. 关系：这一行正是耦合点——虽然类型是接口，但”用哪个实现”还是写死在代码里（new UserServiceImpl()）。下一篇要做的分层解耦就是把这个 new 从上层代码里拿掉，交给 IOC 容器去创建、用依赖注入送进来：那时这行只剩左边的接口类型 + 一个注解。

三、综合题#

• 3-1 照着课程把用户列表案例拆成三层 拿上一篇（36 篇）做出来的”单文件版”工程，动手拆成三层，每拆一步都跑一次工程确认接口没坏：

  1. 建包：controller、service + service.impl、dao + dao.impl、pojo（实体类 User 如果还没建就先建）；
  2. 写 dao：接口 UserDao 里定义”取数据”的方法（返回 List<String>），实现类 UserDaoImpl 里把读 user.txt 的代码搬过来；
  3. 写 service：接口 UserService 里定义”查询所有用户”的方法（返回 List<User>），实现类 UserServiceImpl 里调 dao 拿文本、用 stream().map(...) 解析封装；
  4. 改 controller：把原来方法里的读文件与解析代码删掉，只留”调 service + 返回”，成员变量从 new UserServiceImpl() 里拿 service；
  5. 启动工程，重新验证：curl -si http://localhost:8080/list（看响应头和状态码）、浏览器打开 http://localhost:8080/user.html（看表格还是 8 行）；
  6. 记录一次”需求变更演练”：把 dao 里读的文件名改成 user2.txt（复制一份数据、改几个名字），只改这一个文件，重启后看页面变化——体会”改数据来源只动 dao”。 （练习文件 test_37_综合_把案例拆成三层.java 里按这 6 步给了写作区。）

  涉及知识点

  知识点	在这里的应用
  单一职责原则	一个类只负责一件事：取数据 / 算业务 / 对接口
  三层职责	controller 接收请求响应数据、service 业务逻辑、dao 数据访问
  包与命名	controller / service(.impl) / dao(.impl) / pojo；XxxController / XxxService(+Impl) / XxxDao(+Impl)
  接口与实现	上层依赖接口类型，new 出来的才是实现类
  调用链	Controller → Service → Dao 单向
  重构验证	接口路径与响应数据必须不变（200 + application/json）

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

  一级 · 思路：从下往上搬——先把”读文件”搬到最底层，再把”解析”搬到中间，最后让最上层只剩”调用 + 返回”；每搬一次就编译一次，别一口气全改完 二级 · 方法：UserDao.findAll() 返回 List<String>；UserService.findAll() 返回 List<User>；Controller 里 private UserService userService = new UserServiceImpl();；@RequestMapping("/list") 的方法体只剩 List<User> userList = userService.findAll(); return userList; 三级 · 骨架：dao interface UserDao { List<String> ____(); } / service interface UserService { List<User> ____(); } / controller @____ public class UserController { private UserService userService = new ____(); @____("/list") public List<User> list(){ return ____.findAll(); } }

  参考答案（做完再点开）

  3-1 六步的落地结果：

  1. 包结构（三个包 + 实体类）：

     1
     com/itheima/
     2
     ├── controller/UserController.java
     3
     ├── service/UserService.java + service/impl/UserServiceImpl.java
     4
     ├── dao/UserDao.java + dao/impl/UserDaoImpl.java
     5
     └── pojo/User.java

  2. dao 层（接口 + 实现）：

     1
     public interface UserDao { List<String> findAll(); }

     1
     public class UserDaoImpl implements UserDao {
     2
         @Override
     3
         public List<String> findAll() {
     4
             InputStream in = this.getClass().getClassLoader().getResourceAsStream("user.txt");
     5
             return IoUtil.readUtf8Lines(in, new ArrayList<>());
     6
         }
     7
     }

  3. service 层（接口 + 实现）：接口 List<User> findAll();；实现类 private UserDao userDao = new UserDaoImpl(); + userDao.findAll() 拿到文本 + stream().map(...) 解析成 List<User> 返回。
  4. controller：private UserService userService = new UserServiceImpl();，方法体只剩：

     1
     @RequestMapping("/list")
     2
     public List<User> list() {
     3
         List<User> userList = userService.findAll();
     4
         return userList;
     5
     }

  5. 验证（本机实测就是这套代码跑到最终版本后测的）：

     1
     $ curl -si "http://localhost:8080/list" | head -4
     2
     HTTP/1.1 200
     3
     Content-Type: application/json
     4
     Transfer-Encoding: chunked

     浏览器里 user.html 仍是 8 行数据——分层改的是内部结构，接口和页面一行没变。
  6. 变更演练：把 UserDaoImpl 里的文件名改成 user2.txt（先复制一份 user.txt 改个名，再改几条数据），重启后页面立刻跟着变——只动了 dao 层一个文件，这就是”换数据来源只改数据访问层”的体感。练习文件里记下你改的文件名和页面变化即可。