它在三层架构里站哪一格（PPT 第 15 页）#

PPT 第 15 页把三层架构和 MyBatis 的位置并排画了出来：

也就是说，三层架构没变、分层解耦的道理没变（38 篇），变的只是持久层这一格的实现方式：以前是手写 JDBC，现在是调 MyBatis 给的 Mapper 接口。PPT 上给这两个字的评语是——JDBC 那边繁琐，MyBatis 这边简洁、优雅。

1.1 创建工程、引入依赖（PPT 第 17 页）#

用 IDEA 的 Spring Initializr 建工程时，在依赖屏幕上勾三样（PPT 第 17 页的截图）：

• MyBatis Framework（MyBatis 与 SpringBoot 的整合依赖）
• MySQL Driver（MySQL 驱动，也就是上一篇 mysql-connector-j 那个 jar）
• Lombok（用来给实体类自动生成 getter/setter/toString 等）

勾选之后 IDEA 会往 pom.xml 里写完依赖，等价的手写内容是这样的（课程工程 springboot-mybatis-quickstart/pom.xml 的节选）：

1
<!-- MyBatis 与 SpringBoot 的整合起步依赖（勾 MyBatis Framework 就是它） -->
2
<dependency>
3
    <groupId>org.mybatis.spring.boot</groupId>
4
    <artifactId>mybatis-spring-boot-starter</artifactId>
5
    <version>3.0.3</version>
6
</dependency>
7

8
<!-- MySQL 驱动：版本由 SpringBoot 统一管理，所以只写 scope -->
9
<dependency>
10
    <groupId>com.mysql</groupId>
11
    <artifactId>mysql-connector-j</artifactId>
12
    <scope>runtime</scope>
13
</dependency>
14

15
<!-- Lombok：给实体类自动生成 getter/setter/toString/构造器 -->
16
<dependency>
17
    <groupId>org.projectlombok</groupId>
18
    <artifactId>lombok</artifactId>
19
    <optional>true</optional>
20
</dependency>
21

22
<!-- 单元测试 -->
23
<dependency>
24
    <groupId>org.springframework.boot</groupId>
25
    <artifactId>spring-boot-starter-test</artifactId>
26
    <scope>test</scope>
27
</dependency>

课程工程用的父工程版本是 spring-boot-starter-parent 3.2.10、Java 17（和第 30 篇的工程一致）。

1.2 准备数据库表和实体类（PPT 第 17 页）#

表就是上一篇一直在用的那张 user（41 篇那套库表的延续），课程资料里给的建表与数据脚本：

1
create table user(
2
    id int unsigned primary key auto_increment comment 'ID,主键',
3
    username varchar(20) comment '用户名',
4
    password varchar(32) comment '密码',
5
    name varchar(10) comment '姓名',
6
    age tinyint unsigned comment '年龄'
7
) comment '用户表';
8

9
insert into user(id, username, password, name, age) values
10
    (1, 'daqiao',   '123456',   '大乔', 22),
11
    (2, 'xiaoqiao', '123456',   '小乔', 18),
12
    (3, 'diaochan', '123456',   '貂蝉', 24),
13
    (4, 'lvbu',     '123456',   '吕布', 28),
14
    (5, 'zhaoyun',  '12345678', '赵云', 27);

表有了，还要一个”装数据”的实体类 User，属性名和列名一一对应（PPT 第 17 页的截图）：

1
package com.itheima.pojo;
2

3
import lombok.AllArgsConstructor;
4
import lombok.Data;
5
import lombok.NoArgsConstructor;
6

7
@Data                 // 生成 getter/setter/toString/equals/hashCode
8
@NoArgsConstructor    // 生成无参构造（MyBatis 封装结果时要用）
9
@AllArgsConstructor   // 生成全参构造（测试里 new User(...) 时省事）
10
public class User {
11
    private Integer id;       // ID
12
    private String username;  // 用户名
13
    private String password;  // 密码
14
    private String name;      // 姓名
15
    private Integer age;      // 年龄
16
}

1.3 配置数据源（PPT 第 17 页）#

PPT 第 17 页说得很明确：在 application.properties 里配数据库连接信息。四行，全部以 spring.datasource 打头：

1
# 数据库连接信息（password 换成你自己 MySQL 的密码）
2
spring.datasource.url=jdbc:mysql://localhost:3306/web01
3
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
4
spring.datasource.username=root
5
spring.datasource.password=1234

对照上一篇的 JDBC 代码看，这四行就是把当初硬编码在 Java 里的 url、用户名、密码搬到了配置文件里——52 篇会专门说这件事：JDBC 的痛点之一是”硬编码”，MyBatis 的第一个解法就是”配置化”。

2. 写 Mapper 接口、定义 SQL（PPT 第 17 页）#

最后一步只写一个接口，不用写实现类：

1
package com.itheima.mapper;
2

3
import com.itheima.pojo.User;
4
import org.apache.ibatis.annotations.Mapper;
5
import org.apache.ibatis.annotations.Select;
6

7
import java.util.List;
8

9
@Mapper // 程序运行时，MyBatis 会自动为该接口创建一个实现类对象（代理对象），并存入 IOC 容器
10
public interface UserMapper {
11

12
    /**
13
     * 查询所有用户
14
     */
15
    @Select("select id, username, password, name, age from user")
16
    public List<User> findAll();
17
}

三个关键点：

1. 接口名以 Mapper 结尾（UserMapper），放在 mapper 包下，和 PPT 的命名规范一致；
2. @Mapper 标在接口上——它的作用课程注释写得很清楚：程序运行时，MyBatis 会自动为该接口创建一个实现类对象（代理对象），并自动存入 IOC 容器。这也解释了后面测试类里为什么能 @Autowired 一个”没有实现类的接口”（39 篇讲过 IOC 容器与依赖注入）；
3. SQL 写在注解里：@Select("select ... from user")，把要发给数据库的 SQL 原样写进去。返回 List<User>，MyBatis 会自动把每一行结果封装成一个 User 对象。

本机实测：测试跑起来的样子#

1
User(id=1, username=daqiao, password=123456, name=大乔, age=22)
2
User(id=2, username=xiaoqiao, password=123456, name=小乔, age=18)
3
User(id=3, username=diaochan, password=123456, name=貂蝉, age=24)
4
User(id=4, username=lvbu, password=123456, name=吕布, age=28)
5
User(id=5, username=zhaoyun, password=12345678, name=赵云, age=27)

本机实测：这条日志长什么样#

1
==>  Preparing: select id, username, password, name, age from user
2
==> Parameters:
3
<==      Total: 5
4
User(id=1, username=daqiao, password=123456, name=大乔, age=22)
5
User(id=2, username=xiaoqiao, password=123456, name=小乔, age=18)
6
User(id=3, username=diaochan, password=123456, name=貂蝉, age=24)
7
User(id=4, username=lvbu, password=123456, name=吕布, age=28)
8
User(id=5, username=zhaoyun, password=12345678, name=赵云, age=27)

1
==>  Preparing: delete from user where id = ?
2
==> Parameters: 4(Integer)
3
执行完毕, 影响的记录数: 1

日志三行各有各的用处，读法如下：

1
mybatis:
2
  configuration:
3
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

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

1. MyBatis 的定义：一款优秀的持久层框架，用途是简化 JDBC 的开发；PPT 第 15 页原话就是这两句
2. 名字来历与官网：本是 Apache 的开源项目 iBatis，2010 年由 Apache 迁移到 Google Code 并改名 MyBatis，2013 年 11 月迁移到 GitHub；官网是 https://mybatis.org/mybatis-3/zh_CN/index.html
3. 在三层架构里的位置：controller 控制层 / service 业务层 / dao 持久层；持久层这一格从”手写 JDBC”换成”调 MyBatis 的 Mapper 接口”，PPT 给的评语是 JDBC 繁琐、MyBatis 简洁优雅
4. 入门程序四步：1.1 创建 SpringBoot 工程、引入 MyBatis 相关依赖 → 1.2 准备数据库表 user、实体类 User → 1.3 在 application.properties 中配置数据库连接信息 → 2 编写 MyBatis 的持久层接口，定义 SQL（注解 / XML）
5. Mapper 接口的命名规范与注解：接口命名规范为 XxxMapper（如 UserMapper），接口上必须加 @Mapper；@Mapper 的作用是程序运行时**自动为该接口创建实现类对象（代理对象）**并存入 IOC 容器
6. 数据源四行配置：spring.datasource.url=jdbc:mysql://localhost:3306/web01、spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver、spring.datasource.username=root、spring.datasource.password=1234（password 换成你自己 MySQL 的密码）
7. 单元测试注解与包名要求：测试类上要加 @SpringBootTest——会在单元测试运行时加载 SpringBoot 的环境；测试类所在包需要与引导类包名相同，或放在引导类所在包的子包下
8. SQL 提示（辅助配置一）：默认 MyBatis 里配置的 SQL 语句不被识别；产生原因是 IDEA 和数据库没有建立连接、不识别表信息；解决方式是在 IDEA 中配置 MySQL 数据库连接（Database → Data Source → MySQL，填 Host/Port/User/Password/Database）
9. 日志输出（辅助配置二）：默认看不到 SQL 执行日志，在 application.properties 加一行 mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl 即可
10. 本机实测的三行日志：==> Preparing: select id, username, password, name, age from user、==> Parameters:、<== Total: 5，随后 5 行 User(...)；deleteById(4) 那次是 Preparing: delete from user where id = ? + Parameters: 4(Integer) + 影响 1 行。#{…} 被翻译成了 ?，说明 MyBatis 走的是预编译 SQL

二、裸写题#

• 2-1 从零搭起一个能查用户数据的 MyBatis 工程 需求：新建一个 SpringBoot 工程，连上 web01 库的 user 表，用 MyBatis 把 5 条用户数据全部查出来并在控制台打印。 做完在文件末尾回答：为什么这个”持久层接口”没有实现类却能调用？接口上那个必须加的注解它到底做了什么？ （练习文件 test_51_MyBatis入门程序.java 里按步骤给了写作区。）

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

  一级 · 思路：按 PPT 的四步走——先让工程具备”操作数据库”的能力（加依赖），再准备好”要操作的表和装数据的类”，然后把连库信息交给配置文件，最后写一个只有声明、没有实现的接口让框架去干活 二级 · 方法：依赖是 mybatis-spring-boot-starter 与 mysql-connector-j；配置写在 application.properties 里、四行都以 spring.datasource. 打头；接口命名 XxxMapper、标上 @Mapper，方法上用 @Select("...") 写 SQL，返回 List<User> 三级 · 骨架：

  1
  <dependency>
  2
      <groupId>____.mybatis.spring.boot</groupId>
  3
      <artifactId>____</artifactId>
  4
      <version>3.0.3</version>
  5
  </dependency>

  1
  spring.datasource.____=jdbc:mysql://localhost:3306/web01
  2
  spring.datasource.____-class-name=com.mysql.cj.jdbc.Driver
  3
  spring.datasource.username=____
  4
  spring.datasource.password=____

  1
  ____            // 让 MyBatis 生成代理实现类对象的注解
  2
  public interface ____Mapper {
  3
      @____("select id, username, password, name, age from user")
  4
      public List<User> ____();
  5
  }

  参考答案（做完再点开）

  1. 依赖（pom.xml，勾了 MyBatis Framework + MySQL Driver 后 IDEA 自动生成，手写等价物如下）：

     1
     <dependency>
     2
         <groupId>org.mybatis.spring.boot</groupId>
     3
         <artifactId>mybatis-spring-boot-starter</artifactId>
     4
         <version>3.0.3</version>
     5
     </dependency>
     6
     <dependency>
     7
         <groupId>com.mysql</groupId>
     8
         <artifactId>mysql-connector-j</artifactId>
     9
         <scope>runtime</scope>
     10
     </dependency>

  2. 数据源（src/main/resources/application.properties）：

     1
     # 数据库连接信息（password 换成你自己 MySQL 的密码）
     2
     spring.datasource.url=jdbc:mysql://localhost:3306/web01
     3
     spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
     4
     spring.datasource.username=root
     5
     spring.datasource.password=1234

  3. 表与实体类：表用课程那份 user 建表脚本（5 条数据）；实体类 com.itheima.pojo.User 五个属性 id/username/password/name/age，用 Lombok 的 @Data、@NoArgsConstructor、@AllArgsConstructor 精简掉 getter/setter
  4. Mapper 接口（src/main/java/com/itheima/mapper/UserMapper.java）：

     1
     package com.itheima.mapper;
     2
     
     3
     import com.itheima.pojo.User;
     4
     import org.apache.ibatis.annotations.Mapper;
     5
     import org.apache.ibatis.annotations.Select;
     6
     
     7
     import java.util.List;
     8
     
     9
     @Mapper   // 运行时自动生成实现类对象（代理对象）并存入 IOC 容器
     10
     public interface UserMapper {
     11
         /** 查询所有用户 */
     12
         @Select("select id, username, password, name, age from user")
     13
         public List<User> findAll();
     14
     }

  5. 测试类（src/test/java/com/itheima/SpringbootMybatisQuickstartApplicationTests.java）：

     1
     @SpringBootTest   // 加载 SpringBoot 环境（IOC 容器）
     2
     class SpringbootMybatisQuickstartApplicationTests {
     3
     
     4
         @Autowired
     5
         private UserMapper userMapper;
     6
     
     7
         @Test
     8
         public void testFindAll(){
     9
             List<User> userList = userMapper.findAll();
     10
             userList.forEach(System.out::println);
     11
         }
     12
     }

  两个回答： ① 接口没有实现类却能调用，靠的是 @Mapper——程序运行时 MyBatis 会自动为该接口创建一个实现类对象（代理对象），并自动存入 IOC 容器；测试类里 @Autowired 注入的就是这个代理对象，方法调用时由它去执行注解里写的 SQL。 ② 接口上必须加的注解是 @Mapper（丢了它启动时就报找不到 bean，因为 IOC 容器里没有这个对象）。 本机实测：这样跑出来的 testFindAll 输出 5 行 User(...)（daqiao、xiaoqiao、diaochan、lvbu、zhaoyun），和上一篇 JDBC 版的解析结果一致。

• 2-2 只写”查询所有用户”这一段，并把日志打开读懂它 需求：工程的依赖、数据库、实体类都已备好，你只做两件事——① 写 Mapper 接口里的那个”查所有用户”的方法；② 写一个能跑起来的单元测试方法把它打印出来；③ 打开 MyBatis 日志配置，再跑一次，把控制台里 SQL 相关的那三行抄到练习文件里，并指出哪一行能证明”注解里的 #{} 变成了 ?”。 做完还要回答：测试类里注入的是一个接口，为什么不会报错？这个测试类能不能放到 com.itheima.test 包里？为什么？ （练习文件 test_51_查询所有用户.java 里给了写作区。）

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

  一级 · 思路：① 的答案只有”注解 + SQL + 返回值”三样东西；② 的测试方法离不开”注入接口 + 调用 + 打印”三步；③ 的日志配置是 application.properties 里的一行 mybatis 配置，抄的时候注意 Preparing、Parameters、Total 三种前缀 二级 · 方法：注解用 @Select；返回值是 List<User>；测试类要加 @SpringBootTest，用 @Autowired 注入 Mapper；日志配置项是 mybatis.configuration.log-impl，值是 org.apache.ibatis.logging.stdout.StdOutImpl；包名的问题回想”@SpringBootTest 要按包往上找引导类” 三级 · 骨架：

  1
  @____("select id, username, password, name, age from ____")
  2
  public List<User> ____();

  1
  @____
  2
  class MyTest {
  3
      @____
  4
      private ____ userMapper;
  5
  
  6
      @Test
  7
      public void testFindAll(){
  8
          List<User> userList = ____.____();
  9
          userList.forEach(____);
  10
      }
  11
  }

  参考答案（做完再点开）

  ① Mapper 接口里的方法：

  1
  @Select("select id, username, password, name, age from user")
  2
  public List<User> findAll();

  ② 测试方法（放在与引导类同包的 com.itheima 下）：

  1
  @SpringBootTest
  2
  class SpringbootMybatisQuickstartApplicationTests {
  3
  
  4
      @Autowired
  5
      private UserMapper userMapper;
  6
  
  7
      @Test
  8
      public void testFindAll(){
  9
          List<User> userList = userMapper.findAll();
  10
          userList.forEach(System.out::println);
  11
      }
  12
  }

  ③ 日志配置与三行实测日志：

  1
  mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

  1
  ==>  Preparing: select id, username, password, name, age from user
  2
  ==> Parameters:
  3
  <==      Total: 5

  能证明”#{} 变成了 ?”的是 Preparing: 那一行——注解里写的是 #{id}、#{username} 这种占位符，MyBatis 实际发出去的却是带 ? 的预编译 SQL，参数值单独放在 Parameters: 里（本机实测 deleteById(4)：Preparing: delete from user where id = ? + Parameters: 4(Integer)）。这正是上一篇”预编译 SQL”在 MyBatis 里的默认形态。 两个回答：

  • 注入接口不会报错，因为 @Mapper 让 MyBatis 在运行时生成了该接口的代理实现类对象并放进了 IOC 容器，@Autowired 按类型注入时容器里确实有这么一个对象。
  • 放到 com.itheima.test 包是可以的：@SpringBootTest 需要按包往上找带 @SpringBootApplication 的引导类，而引导类在 com.itheima 下、com.itheima.test 正是它的子包，找得到；真正会出问题的是放到与引导类无关的包（例如 com.other.test），那时就报找不到配置类的错。稳妥的做法就是与引导类同包，或放在引导类所在包的子包下。

• 2-3 让 IDEA 别再把你写的 SQL 当成一坨普通字符串 需求：Mapper 里的 @Select("select ...") 现在没有关键字高亮、列名没有提示、表名也不能跳转。请说出这是由什么原因造成的，并把两种解决办法各做一遍（做出效果即可，不用写代码），然后对比两种办法的效果差别。 （练习文件 test_51_查询所有用户.java 的最后一个作答区里给了写作区。）

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

  一级 · 思路：关键在”IDEA 手里有没有这张表的信息”——想想 IDEA 从哪儿才能拿到表结构 二级 · 方法：办法一是打开 IDEA 的 Database 面板 → + → Data Source → MySQL，填 Host/Port/User/Password/Database；办法二是光标停在字符串里按 Alt+Enter → Inject language or reference → 选 MySQL (SQL) 三级 · 骨架：办法一填五格：Host ____、Port ____、User ____、Password ____、Database ____，再点 ____ 按钮确认连通

  参考答案（做完再点开）

  原因（PPT 第 20 页原话）：idea 和数据库没有建立连接，不识别表信息。@Select("...") 里的内容在 IDEA 眼里本来只是普通字符串，它既不知道这是 SQL，更不知道库里有没有 user 这张表。 办法一（推荐）：Database 面板 → + → Data Source → MySQL，填 Host localhost、Port 3306、User root、Password 你自己的密码、Database web01，URL 一栏会自动拼成 jdbc:mysql://localhost:3306/web01，点 Test Connection 通过后 OK。 办法二（应急）：光标停在 @Select("...") 里 → Alt+Enter → Inject language or reference → 选 MySQL (SQL)，把这段字符串声明成 MySQL 方言的 SQL。 差别：办法二只解决”这是 SQL”这一层——关键字高亮有了，但它没有表结构的元数据，所以列名提示、表名跳转还是不行；办法一是把数据库连接交进了 IDEA，它拿到了整库的表结构，因此列名提示、跳转、在 IDEA 里直接执行 SQL 全都有。一句话：办法二靠”声明”，办法一靠”连接”。

三、综合题#

• 3-1 从零把入门工程跑通，并完成两项辅助配置的验证 照着 PPT 第 17-21 页的顺序完整做一遍，每一步都在练习文件里留下记录：

  1. 新建 SpringBoot 工程，勾上 MyBatis Framework 与 MySQL Driver（也可手写 pom 依赖）；
  2. 用课程脚本建好 web01.user（5 条数据），写好实体类 User（五个属性 + Lombok 注解）；
  3. 在 application.properties 里配置数据源四行（password 换成本机密码），同时加好 MyBatis 日志配置一行；
  4. 定义 UserMapper 接口，用注解写”查询所有用户”，返回 List<User>；
  5. 写 @SpringBootTest 测试类（注意包名），注入 Mapper 并打印结果，先把测试跑通；
  6. 把控制台里 SQL 日志的三行（Preparing / Parameters / Total）抄下来，标出每一行分别说明什么；
  7. 在 IDEA 里配好 MySQL 数据库连接（或先用 Alt+Enter 注入语言应急），对比配置前后 @Select 里的 SQL 有什么变化；
  8. 回答：这套工程里你自己写的代码一共几行？其中的连接信息、SQL 分别放在了哪里？ （练习文件 test_51_MyBatis入门程序.java 里按 8 步给了写作区。）

  涉及知识点

  知识点	在这里的应用
  入门四步	第 1~4 步——建工程引依赖、备表与实体类、配数据源、写 Mapper 接口
  @Mapper 与 IOC	第 4~5 步——接口没有实现类，靠代理对象注入
  @SpringBootTest 与包名	第 5 步——不加注解/包放错，测试跑不起来
  日志配置	第 3、6 步——log-impl 一行，换来三行可读日志
  SQL 提示	第 7 步——IDEA 连库（或注入语言）后才能识别 SQL
  预编译	第 6 步——日志里的 ? 就是上一篇的预编译

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

  一级 · 思路：这一题就是把本篇的四步 + 两项辅助配置照着做一遍，重点不是写多少代码，而是每一步都在你的机器上留下可验证的结果（测试通过、日志三行、SQL 变彩色） 二级 · 方法：依赖看 1.1；数据源与日志都在 application.properties；Mapper 用 @Mapper + @Select；测试类用 @SpringBootTest + @Autowired；IDEA 连库走 Database → Data Source → MySQL 三级 · 骨架：第 6 步要抄的三行以 ==> Preparing: / ==> Parameters: / <== Total: 开头；第 8 步的答案在想”哪些内容其实一行 Java 代码都没写”

  参考答案（做完再点开）

  1~5. 四块代码（与 2-1 的答案一致，这里只列关键部分）：

  1
  spring.datasource.url=jdbc:mysql://localhost:3306/web01
  2
  spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  3
  spring.datasource.username=root
  4
  spring.datasource.password=1234
  5
  mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

  1
  @Mapper
  2
  public interface UserMapper {
  3
      @Select("select id, username, password, name, age from user")
  4
      public List<User> findAll();
  5
  }

  1
  // 测试类（与引导类同包 com.itheima）
  2
  @SpringBootTest
  3
  class SpringbootMybatisQuickstartApplicationTests {
  4
      @Autowired
  5
      private UserMapper userMapper;
  6
  
  7
      @Test
  8
      public void testFindAll(){
  9
          userMapper.findAll().forEach(System.out::println);
  10
      }
  11
  }

  6. 本机实测抄下来的三行：

     1
     ==>  Preparing: select id, username, password, name, age from user
     2
     ==> Parameters:
     3
     <==      Total: 5

     Preparing = MyBatis 真正发给数据库的 SQL（这正是”排除故障时最想看的那一行”）；Parameters = 这次执行的参数值（本句没有参数，所以是空的）；Total = 返回结果的行数（5 行，和表里的 5 条数据对得上）。后面 5 行 User(...) 是测试代码自己打印的，不是 MyBatis 的日志。
  7. 配置前后：配置前 @Select("select ...") 是一段普通字符串（单一颜色、无提示、无跳转）；IDEA 连上 web01 后，同一段 SQL 关键字高亮、列名有提示、表名可跳转；用 Alt+Enter 注入 MySQL (SQL) 也能高亮，但因为没连库，列名提示与跳转仍然缺失。
  8. 这套工程里真正的”业务代码”只有 Mapper 接口里的 3 行（@Mapper + 方法声明 + @Select 注解）。连接信息搬到了 application.properties（配置化，不再硬编码在 Java 里），SQL 写在注解里（不用再手写 ResultSet 解析），连接的获取与释放交给框架（连接池，下一篇 52 的痛点表里会一项项对上）。这三件事，正好就是 MyBatis 相对 JDBC 的价值。