一、SpringBoot简介

1、SpringBoot开发步骤

2、官网构建工程

3、SpringBoot概述

二、配置文件

1、配置文件格式

2、yaml格式

3、yaml配置文件数据读取

三、多环境配置

1、yam文件

2、properties文件

3、命令行启动参数设置

四、SpringBoot整合

1、SpringBoot整合junit

2、SpringBoot整合mybatis

一、SpringBoot简介

1、SpringBoot开发步骤

▶ 创建新块

▷ 点击 `+` 选择 `New Module` 创建新模块

▷ 选择 `Spring Initializr` ，用来创建 `SpringBoot` 工程

以前我们选择的是 `Maven` ，今天选择 `Spring Initializr` 来快速构建 `SpringBoot` 工程。而在 `Module SDK` 这一项选择我们安装的 `JDK` 版本。

▷ 对 `SpringBoot` 工程进行相关的设置

我们使用这种方式构建的 `SpringBoot` 工程其实也是 `Maven` 工程，而该方式只是一种快速构建的方式而已。

注意：打包方式这里需要设置为 `Jar`

▷ 选中 `Web`，然后勾选 `Spring Web`

由于我们需要开发一个 `web` 程序，使用到了 `SpringMVC` 技术，所以按照下图红框进行勾选

▷ 下图界面不需要任何修改，直接点击 `Finish` 完成 `SpringBoot` 工程的构建

经过以上步骤后就创建了如下结构的模块，它会帮我们自动生成一个 `Application` 类，而该类一会再启动服务器时会用到

注意：

1. 在创建好的工程中不需要创建配置类
2. 创建好的项目会自动生成其他的一些文件，而这些文件目前对我们来说没有任何作用，所以可以将这些文件删除。可以删除的目录和文件下：
● `.mvn`
● `.gitignore`
● `HELP.md`
● `mvnw`
● `mvnw.cmd`

▶ 创建 `Controller`

在 `com.itheima.controller` 包下创建 `BookController` ，代码如下：
@RestController
@RequestMapping("/books")
public class BookController {

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("id ==> "+id);
        return "hello , spring boot!";
    }
}
▶ 启动服务器

运行 `SpringBoot` 工程不需要使用本地的 `Tomcat` 和插件，只运行项目 `com.itheima` 包下的 `Application` 类，我们就可以在控制台看出如下信息

▶ 进行测试

使用 `Postman` 工具来测试我们的程序

▶ 对比

坐标：

`Spring` 程序中的坐标需要自己编写，而且坐标非常多

`SpringBoot` 程序中的坐标是我们在创建工程时进行勾选自动生成的

web3.0配置类

`Spring` 程序需要自己编写这个配置类。这个配置类大家之前编写过，肯定感觉很复杂

`SpringBoot` 程序不需要我们自己书写

配置类

`Spring/SpringMVC` 程序的配置类需要自己书写。而 `SpringBoot` 程序则不需要书写。

注意：基于Idea的 `Spring Initializr` 快速构建 `SpringBoot` 工程时需要联网。

2、官网构建工程

▶ 具体骤

▷ 进入SpringBoot官网

官网地址如下：https://spring.io/projects/spring-boot

进入到 `SpringBoot` 官网后拖到最下方就可以看到如下内容

然后点击 `Spring Initializr` 超链接就会跳转到如下页面

这个页面内容是不是感觉很眼熟的，这和我们使用 `Idea` 快速构建 `SpringBoot` 工程的界面基本相同。在上面页面输入对应的信息

▷ 选择依赖

选择 `Spring Web` 可以点击上图右上角的 `ADD DEPENDENCIES... CTRL + B` 按钮，就会出现如下界面

▷ 生成工程

以上步骤完成后就可以生成 `SpringBoot` 工程了。在页面的最下方点击 `GENERATE CTRL + 回车` 按钮生成工程并下载到本地，如下图所示

打开下载好的压缩包可以看到工程结构和使用 `Idea` 生成的一模一样，如下图

而打开 `pom.xml` 文件，里面也包含了父工程和 `Spring Web` 的依赖。通过上面官网的操作，我们知道 `Idea` 中快速构建 `SpringBoot` 工程其实就是使用的官网的快速构建组件，那以后即使没有 `Idea` 也可以使用官网的方式构建 `SpringBoot` 工程。

▶ SpringBoot工程快速动

▷ 打包

由于我们在构建 `SpringBoot` 工程时已经在 `pom.xml` 中配置了如下插件
<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
所以我们只需要使用 `Maven` 的 `package` 指令打包就会在 `target` 目录下生成对应的 `Jar` 包。

注意：该插件必须配置，不然打好的 `jar` 包也是有问题的。

▷ 启动

进入 `jar` 包所在位置，在 `命令提示符` 中输入如下命令
jar -jar springboot_01_quickstart-0.0.1-SNAPSHOT.jar
执行上述命令就可以看到 `SpringBoot` 运行的日志信息

3、SpringBoot概述

`SpringBoot` 是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。

原始 `Spring` 环境搭建和开发存在以下问：

● 配置繁琐
● 依赖设置繁琐

`SpringBoot` 程序优点恰巧就是针对 `Spring` 的缺点

● 自动配置。这个是用来解决 `Spring` 程序配置繁琐的问题
● 起步依赖。这个是用来解决 `Spring` 程序依赖设置繁琐的问题
● 辅助功能（内置服务器,...）。我们在启动 `SpringBoot` 程序时既没有使用本地的 `tomcat` 也没有使用 `tomcat` 插件，而是使用 `SpringBoot` 内置的服务器。

▶ 起步依赖

我们使用 `Spring Initializr` 方式创建的 `Maven` 工程的的 `pom.xml` 配置文件中自动生成了很多包含 `starter` 的依赖，如下图

▷ 探索父工程

从上面的文件中可以看到指定了一个父工程，我们进入到父工程，发现父工程中又指定了一个父工程，如下图所示

再进入到该父工程中，在该工程中我们可以看到配置内容结构如下图所示

上图中的 `properties` 标签中定义了各个技术软件依赖的版本，避免了我们在使用不同软件技术时考虑版本的兼容问题。在 `properties` 中我们找 `servlet` 和 `mysql` 的版本如下图

`dependencyManagement` 标签是进行依赖版本锁定，但是并没有导入对应的依赖；如果我们工程需要那个依赖只需要引入依赖的 `groupid` 和 `artifactId` 不需要定义 `version`。

而 `build` 标签中也对插件的版本进行了锁定，如下图

▷ 探索依赖

在我们创建的工程中的 `pom.xml` 中配置了如下依赖

进入到该依赖，查看 `pom.xml` 的依赖会发现它引入了如下的依赖

里面的引入了 `spring-web` 和 `spring-webmvc` 的依赖，这就是为什么我们的工程中没有依赖这两个包还能正常使用 `springMVC` 中的注解的原因。而依赖 `spring-boot-starter-tomcat` ，从名字基本能确认内部依赖了 `tomcat`，所以我们的工程才能正常启动。

结论：以后需要使用技术，只需要引入该技术对应的起步依赖即可

▶ 小结

startr

● `SpringBoot` 中常见项目名称，定义了当前项目使用的所有项目坐标，以达到减少依赖配置的目的

parent

● 所有 `SpringBoot` 项目要继承的项目，定义了若干个坐标版本号（依赖管理，而非依赖），以达到减少依赖冲突的目的

● `spring-boot-starter-parent`（2.5.0）与 `spring-boot-starter-parent`（2.4.6）共计57处坐标版本不同

实际开发

● 使用任意坐标时，仅书写GAV中的G和A，V由SpringBoot提供

○ G：groupid
○ A：artifactId
○ V：version

● 如发生坐标错误，再指定version（要小心版本冲突）

▶ 程序启动

创建的每一个 `SpringBoot` 程序时都包含一个类似于下面的类，我们将这个类称作引导类
@SpringBootApplication
public class Springboot01QuickstartApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(Springboot01QuickstartApplication.class, args);
    }
}
注：

● `SpringBoot` 在创建项目时，采用jar的打包方式

● `SpringBoot` 的引导类是项目的入口，运行 `main` 方法就可以启动项目因为我们在 `pom.xml` 中配置了 `spring-boot-starter-web` 依赖，而该依赖通过前面的学习知道它依赖 `tomcat` ，所以运行 `main` 方法就可以使用 `tomcat` 启动咱们的工程。

▶ 切换web服务器

现在我们启动工程使用的是 `tomcat` 服务器，那能不能不使用 `tomcat` 而使用 `jetty` 服务器。而要切换 `web` 服务器就需要将默认的 `tomcat` 服务器给排除掉，怎么排除呢？使用 `exclusion` 标签
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <groupId>org.springframework.boot</groupId>
        </exclusion>
    </exclusions>
</dependency>
现在我们运行引导类可以吗？运行一下试试，打印的日志信息如下：

程序直接停止了，为什么呢？那是因为排除了 `tomcat` 服务器，程序中就没有服务器了。所以此时不光要排除 `tomcat` 服务器，还要引入 `jetty` 服务器。在 `pom.xml` 中因为 `jetty` 的起步依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
接下来再次运行引导类，在日志信息中就可以看到使用的是 `jetty` 服务器

二、配置文件

1、配置文件格式

我们现在启动服务器默认的端口号是 `8080`，访问路径可以书写为
http://localhost:8080/books/1
在线上环境我们还是希望将端口号改为 `80`，这样在访问的时候就可以不写端口号了，如下
http://localhost/books/1
而 `SpringBoot` 程序如何修改呢？`SpringBoot` 提供了多种属性配置方：

● `application.properties`
server.port=80
● `application.yml`
server:
    port: 81
● `application.yaml`
server:
   port: 82
注意：`SpringBoot` 程序的配置文件名必须是 `application` ，只是后缀名不同而已。

▶ 环境准备

创建一个新工程 `springboot_02_base_config` 用来演示不同的配置文件，工程环境和入门案例一模一样，结构如下：

在该工程中的 `com.itheima.controller` 包下创建一个名为 `BookController` 的控制器。内容如下：
@RestController
@RequestMapping("/books")
public class BookController {

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("id ==> "+id);
        return "hello , spring boot!";
    }
}
▶ 不同配置文件演

● application.properties配置文件

现在需要进行配置，配合文件必须放在 `resources` 目录下，而该目录下有一个名为 `application.properties` 的配置文件，我们就可以在该配置文件中修改端口号，在该配置文件中书写 `port` ，`Idea` 就会提示，如下

`application.properties` 配置文件内容如下：
server.port=80
启动服务，会在控制台打印出日志信息，从日志信息中可以看到绑定的端口号已经修改了

● application.yml配置文件

删除 `application.properties` 配置文件中的内容。在 `resources` 下创建一个名为 `application.yml` 的配置文件，在该文件中书写端口号的配置项，格式如下：
server:
    port: 81
注意：在`:`后，数据前一定要加空格。

而在 `yml` 配置文件中也是有提示功能的，我们也可以在该文件中书写 `port` ，然后 `idea` 就会提示并书写成上面的格式

启动服务，可以在控制台看到绑定的端口号是 `81`

● application.yaml配置文件

删除 `application.yml` 配置文件和 `application.properties` 配置文件内容，然后在 `resources` 下创建名为 `application.yaml` 的配置文件，配置内容和后缀名为 `yml` 的配置文件中的内容相同，只是使用了不同的后缀名而已。

`application.yaml` 配置文件内容如下：
server:
    port: 83
启动服务，在控制台可以看到绑定的端口号

注意：在配合文件中如果没有提示，可以使用以下方式解：

○ 点击 `File` 选中 `Project Structure`

○ 弹出如下窗口，按图中标记红框进行选择

○ 通过上述操作，会弹出如下窗口

○ 点击上图的 `+` 号，弹出选择该模块的配置文件

○ 通过上述几步后，就可以看到如下界面。`properties` 类型的配合文件有一个，`ymal` 类型的配置文件有两个

▶ 三种配合文件的优先级

在三种配合文件中分别配置不同的端口号，启动服务查看绑定的端口号。用这种方式就可以看到哪个配置文件的优先级更高一些

`application.properties` 文件内容如下：
server.port=80
`application.yml` 文件内容如下：
server:
    port: 81
`application.yaml` 文件内容如下：
server:
    port: 82
启动服务，在控制台可以看到使用的端口号是 `80`。说明 `application.properties` 的优先级最高。注释掉 `application.properties` 配置文件内容。再次启动服务，在控制台可以看到使用的端口号是 `81`，说明 `application.yml` 配置文件为第二优先级。

从上述的验证结果可以确定三种配置文件的优先级是：

`application.properties` > `application.yml` > `application.yaml`

注意：
○ `SpringBoot` 核心配置文件名为 `application`
○ `SpringBoot` 内置属性过多，且所有属性集中在一起修改，在使用时，通过提示键+关键字修改属性
例如要设置日志的级别时，可以在配置文件中书写 `logging`，就会提示出来。配置内容如下
logging:
   level:
       root: info
2、yaml格式

YAML（YAML Ain't Markup Language），一种数据序列化格式。这种格式的配置文件在近些年已经占有主导地位，那么这种配置文件和前期使用的配置文件是有一些优势的，我们先看之前使用的配置文件。

最开始我们使用的是 `xml` ，格式如下：
<enterprise>
    <name>itcast</name>
    <age>16</age>
    <tel>4006184000</tel>
</enterprise>
而 `properties` 类型的配置文件如下
enterprise.name=itcast
enterprise.age=16
enterprise.tel=4006184000
`yaml` 类型的配置文件内容如下
enterprise:
    name: itcast
    age: 16
    tel: 4006184000
优点：

● 容易阅读

`yaml` 类型的配置文件比 `xml` 类型的配置文件更容易阅读，结构更加清晰

● 容易与脚本语言交互

● 以数据为核心，重数据轻格式

`yaml` 更注重数据，而 `xml` 更注重格式

● YAML 文件扩展名：

○ `.yml` (主流)
○ `.yaml`

上面两种后缀名都可以，以后使用更多的还是 `yml` 的。

▶ 语法则

● 大小写敏感

● 属性层级关系使用多行描述，每行结尾使用冒号结束

● 使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许使用Tab键），空格的个数并不重要，只要保证同层级的左侧对齐即可。

● 属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）

● # 表示注释

核心规则：数据前面要加空格与冒号隔开

数组数据在数据书写位置的下方使用减号作为数据开始符号，每行书写一个数据，减号与数据间空格分隔，例如
enterprise:
  name: itcast
  age: 16
  tel: 4006184000
  subject:
    - Java
    - 前端
    - 大数据
3、yaml配置文件数据读取

▶ 使用 @Value注解

使用 `@Value("表达式")` 注解可以从配合文件中读取数据，注解中用于读取属性名引用方式是：`${一级属性名.二级属性名……}`

我们可以在 `BookController` 中使用 `@Value` 注解读取配合文件数据，如下
@RestController
@RequestMapping("/books")
public class BookController {
    
    @Value("${lesson}")
    private String lesson;
    @Value("${server.port}")
    private Integer port;
    @Value("${enterprise.subject[0]}")
    private String subject_00;

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println(lesson);
        System.out.println(port);
        System.out.println(subject_00);
        return "hello , spring boot!";
    }
}
▶ Environment对象

上面方式读取到的数据特别零散，`SpringBoot` 还可以使用 `@Autowired` 注解注入 `Environment` 对象的方式读取数据。这种方式 `SpringBoot` 会将配置文件中所有的数据封装到 `Environment` 对象中，如果需要使用哪个数据只需要通过调用 `Environment` 对象的 `getProperty(String name)` 方法获取。具体代码如下：
@RestController
@RequestMapping("/books")
public class BookController {
    
    @Autowired
    private Environment env;
    
    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println(env.getProperty("lesson"));
        System.out.println(env.getProperty("enterprise.name"));
        System.out.println(env.getProperty("enterprise.subject[0]"));
        return "hello , spring boot!";
    }
}
注意：这种方式，框架内容大量数据，而在开发中我们很少使用。

▶ 自定义对象

`SpringBoot` 还提供了将配置文件中的数据封装到我们自定义的实体类对象中的方式。具体操作如：

○ 将实体类 `bean` 的创建交给 `Spring` 管理。

在类上添加 `@Component` 注解

○ 使用 `@ConfigurationProperties` 注解表示加载配置文件

在该注解中也可以使用 `prefix` 属性指定只加载指定前缀的数据

○ 在 `BookController` 中进行注入

▷ 具体代码如下：

`Enterprise` 实体类内容如下：
@Component
@ConfigurationProperties(prefix = "enterprise")
public class Enterprise {
    private String name;
    private int age;
    private String tel;
    private String[] subject;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getTel() {
        return tel;
    }

    public void setTel(String tel) {
        this.tel = tel;
    }

    public String[] getSubject() {
        return subject;
    }

    public void setSubject(String[] subject) {
        this.subject = subject;
    }

    @Override
    public String toString() {
        return "Enterprise{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", tel='" + tel + '\'' +
                ", subject=" + Arrays.toString(subject) +
                '}';
    }
}
`BookController` 内容如下：
@RestController
@RequestMapping("/books")
public class BookController {
    
    @Autowired
    private Enterprise enterprise;

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println(enterprise.getName());
        System.out.println(enterprise.getAge());
        System.out.println(enterprise.getSubject());
        System.out.println(enterprise.getTel());
        System.out.println(enterprise.getSubject()[0]);
        return "hello , spring boot!";
    }
}
注意：

使用第三种方式，在实体类上有如下警告提示

这个警告提示解决是在 `pom.xml` 中添加如下依赖即可
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

三、多环境配置

以后在工作中，对于开发环境、测试环境、生产环境的配置肯定都不相同，比如我们开发阶段会在自己的电脑上安装 `mysql` ，连接自己电脑上的 `mysql` 即可，但是项目开发完毕后要上线就需要该配置，将环境的配置改为线上环境的。

来回的修改配置会很麻烦，而 `SpringBoot` 给开发者提供了多环境的快捷配置，需要切换环境时只需要改一个配置即可。不同类型的配置文件多环境开发的配置都不相同。

1、yam文件

▶ 在 `application.yml` 中使用 `---` 来分割不同的配置，内容如下
#开发
spring:
  profiles: dev #给开发环境起的名字
server:
  port: 80
---
#生产
spring:
  profiles: pro #给生产环境起的名字
server:
  port: 81
---
#测试
spring:
  profiles: test #给测试环境起的名字
server:
  port: 82
---
上面配置中 `spring.profiles` 是用来给不同的配置起名字的。而如何告知 `SpringBoot` 使用哪段配置呢？可以使用如下配置来启用都一段配置
#设置启用的环境
spring:
  profiles:
    active: dev  #表示使用的是开发环境的配置
综上所述，`application.yml` 配置文件内容如下
#设置启用的环境
spring:
  profiles:
    active: dev

---
#开发
spring:
  profiles: dev
server:
  port: 80
---
#生产
spring:
  profiles: pro
server:
  port: 81
---
#测试
spring:
  profiles: test
server:
  port: 82
---
注意：

在上面配置中给不同配置起名字的 `spring.profiles` 配置项已经过时。最新用来起名字的配置项是
#开发
spring:
  config:
    activate:
      on-profile: dev
2、properties文件

▶ `properties` 类型的配置文件配置多环境需要定义不同的配置件

● `application-dev.properties` 是开发环境的配置文件。我们在该文件中配置端口号为 `80`
server.port=80
● `application-test.properties` 是测试环境的配置文件。我们在该文件中配置端口号为 `81`
server.port=81
● `application-pro.properties` 是生产环境的配置文件。我们在该文件中配置端口号为 `82`
server.port=82
`SpringBoot` 只会默认加载名为 `application.properties` 的配置文件，所以需要在 `application.properties` 配置文件中设置启用哪个配置文件，配置如下:
spring.profiles.active=pro
3、命令行启动参数设置

使用 `SpringBoot` 开发的程序以后都是打成 `jar` 包，通过 `java -jar xxx.jar` 的方式启动服务的。那么就存在一个问题，如何切换环境呢？因为配置文件打到的jar包中了。

我们知道 `jar` 包其实就是一个压缩包，可以解压缩，然后修改配置，最后再打成jar包就可以了。这种方式显然有点麻烦，而 `SpringBoot` 提供了在运行 `jar` 时设置开启指定的环境的方式，如下
java –jar xxx.jar –-spring.profiles.active=test
那么这种方式能不能临时修改端口号呢？也是可以的，可以通过如下方式
java –jar xxx.jar –-server.port=88
当然也可以同时设置多个配置，比如即指定启用哪个环境配置，又临时指定端口，如下
java –jar springboot.jar –-server.port=88 –-spring.profiles.active=test
进行测试后就会发现命令行设置的端口号优先级高（也就是使用的是命令行设置的端口号），配置的优先级其实 `SpringBoot` 官网已经进行了说明，参见 :
https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-external-config
进入上面网站后会看到如下页面

如果使用了多种方式配合同一个配置项，优先级高的生效。

▶ 配置文件分类

有这样的场景，我们开发完毕后需要测试人员进行测试，由于测试环境和开发环境的很多配置都不相同，所以测试人员在运行我们的工程时需要临时修改很多配置，如下
java –jar springboot.jar –-spring.profiles.active=test --server.port=85 --server.servlet.context-path=/heima --server.tomcat.connection-timeout=-1 …… …… …… …… ……
针对这种情况，`SpringBoot` 定义了配置文件不同的放置的位置；而放在不同位置的优先级时不同的。

`SpringBoot` 中4级配置文件放置位：

● 1级：classpath：application.yml
● 2级：classpath：config/application.yml
● 3级：file ：application.yml
● 4级：file ：config/application.yml

说明：级别越高优先级越高

四、SpringBoot整合

1、SpringBoot整合junit

▶ 环境准备

创建一个名为 `springboot_07_test` 的 `SpringBoot` 工程，工程目录结构如下

在 `com.itheima.service` 下创建 `BookService` 接口，内容如下
public interface BookService {
    public void save();
}
在 `com.itheima.service.impl` 包写创建一个 `BookServiceImpl` 类，使其实现 `BookService` 接口，内容如下
@Service
public class BookServiceImpl implements BookService {
    @Override
    public void save() {
        System.out.println("book service is running ...");
    }
}
▷ 编写测试类

在 `test/java` 下创建 `com.itheima` 包，在该包下创建测试类，将 `BookService` 注入到该测试类中
@SpringBootTest
class Springboot07TestApplicationTests {

    @Autowired
    private BookService bookService;

    @Test
    public void save() {
        bookService.save();
    }
}
注意：这里的引导类所在包必须是测试类所在包及其子包。
例如：
○ 引导类所在包是 `com.itheima`
○ 测试类所在包是 `com.itheima`
如果不满足这个要求的话，就需要在使用 `@SpringBootTest` 注解时，使用 `classes` 属性指定引导类的字节码对象。如 `@SpringBootTest(classes = Springboot07TestApplication.class)`

2、SpringBoot整合mybatis

▶ 创建块

● 创建新模块，选择 `Spring Initializr`，并配置模块相关基础信息

● 选择当前模块需要使用的技术集（MyBatis、MySQL）

▶ 定义实体类

在 `com.itheima.domain` 包下定义实体类 `Book`，内容如下
public class Book {
    private Integer id;
    private String name;
    private String type;
    private String description;
    
    //setter and  getter
    
    //toString
}
▶ 定义dao接口

在 `com.itheima.dao` 包下定义 `BookDao` 接口，内容如下
public interface BookDao {
    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);
}
▶ 定义测试类

在 `test/java` 下定义包 `com.itheima` ，在该包下测试类，内容如下、
@SpringBootTest
class Springboot08MybatisApplicationTests {

    @Autowired
    private BookDao bookDao;

    @Test
    void testGetById() {
        Book book = bookDao.getById(1);
        System.out.println(book);
    }
}
▶ 编写配置

我们代码中并没有指定连接哪儿个数据库，用户名是什么，密码是什么。所以这部分需要在 `SpringBoot` 的配置文件中进行配合。

在 `application.yml` 配置文件中配置如下内容
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db
    username: root
    password: root
▶ 测试

运行测试方法，我们会看到如下错误信息

错误信息显示在 `Spring` 容器中没有 `BookDao` 类型的 `bean`。为什么会出现这种情况呢？

原因是 `Mybatis` 会扫描接口并创建接口的代码对象交给 `Spring` 管理，但是现在并没有告诉 `Mybatis` 哪个是 `dao` 接口。而我们要解决这个问题需要在`BookDao` 接口上使用 `@Mapper` ，`BookDao` 接口改进为
@Mapper
public interface BookDao {
    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);
}
注意：
`SpringBoot` 版本低于2.4.3(不含)，Mysql驱动版本大于8.0时，需要在url连接串中配置时区 `jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC`，或在MySQL数据库端配置时区解决此问题。

▶ 使用Druid数据源

现在我们并没有指定数据源，`SpringBoot` 有默认的数据源，我们也可以指定使用 `Druid` 数据源，按照以下步骤现

● 导入 `Druid` 依赖
  <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.16</version>
  </dependency>
● 在 `application.yml` 配置文件配置

可以通过 `spring.datasource.type` 来配置使用什么数据源。配置文件内容可以改进为
spring:
    datasource:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
      username: root
      password: root
      type: com.alibaba.druid.pool.DruidDataSource