SpringBoot概念、快速入门、yaml语法、profile配置文件、SpringBoot整合Junit单元测试、SpringBoot整合Redis、SpringBoot整合MyBatis

SpringBoot 概念

SpringBoot提供了一种快速使用Spring的方式，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。2014 年 4 月，Spring Boot 1.0.0 发布。Spring的顶级项目之一(https://spring.io)。

Spring 缺点

1、 配置繁琐
虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多XML配置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。 Spring 3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。
所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但它要求的回报也不少。
2、依赖繁琐
项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。

SpringBoot 功能

1、自动配置
Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是SpringBoot自动完成的。
2、起步依赖
起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖 ，这些东西加在一起即支持某项功能。
简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。
3、辅助功能
提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。

Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式。

SpringBoot 概述总结

SpringBoot提供了一种快速开发Spring项目的方式，而不是对Spring功能上的增强。
Spring的缺点：

• 配置繁琐
• 依赖繁琐

SpringBoot功能：

• 自动配置
• 起步依赖：依赖传递
• 辅助功能

SpringBoot 快速入门

案例：
需求搭建SpringBoot工程，定义HelloController.hello()方法，返回”Hello SpringBoot!”。
案例：实现步骤
①、创建Maven项目
②、导入SpringBoot起步依赖
③、定义Controller
④、编写引导类
⑤、启动测试
具体实现步骤：
1、创建Maven项目，利用开发工具创建具体步骤不再赘述。
2、导入SpringBoot起步依赖，在创建好的Maven项目中选择pom.xml文件在文件中导入相应依赖。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <artifactId>qingbo-springboot-quick</artifactId>

    <!--Spring Boot需要继承的父工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.5.RELEASE</version>
    </parent>
    
    <dependencies>
        <!--Spring Boot Web开发的起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.3.5.RELEASE</version>
        </dependency>
        
    </dependencies>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

</project>

3、定义Controller

package com.qingbo.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Description: TODO
 * @author: ShiQingBo
 * @date: 2021年11月17日 13:45
 */
@RestController
public class HelloController {
    
    
    @RequestMapping(value = "hello")
    public String hello(){
    
    
        return "Hello Spring Boot !!!";
    }
}

4、编写引导类

package com.qingbo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @Description: TODO
 * @author: ShiQingBo
 * @date: 2021年11月17日 13:48
 */
// 引导类。Spring Boot项目的入口
@SpringBootApplication
public class HelloApplication {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(HelloApplication.class,args);
    }
}

⑤、启动测试，直接运行引导类HelloApplication.java中的main方法就可以启动项目了。
SpringBoot内置了一个Tomcat启动的时候，在控制台输出的日志记录中可看到，如下图所示

启动完成后在浏览器输入如下地址

http://localhost:8080/hello

页面输出结果：

Hello Spring Boot !!!

SpringBoot 快速入门总结

1、SpringBoot在创建项目时，使用jar的打包方式。
2、SpringBoot的引导类，是项目入口，运行main方法就可以启动项目。
3、使用SpringBoot和Spring构建的项目，业务代码编写方式完全一样。

SpringBoot 起步依赖原理分析

1、 spring-boot-starter-parent
在spring-boot-starter-parent中定义了各种技术的版本信息，组合了一套最优搭配的技术版本。
2、 spring-boot-starter-web
在各种starter中，定义了完成该功能需要的坐标合集，其中大部分版本信息来自于父工程。

我们的工程继承parent，引入starter后，通过依赖传递，就可以简单方便获得需要的jar包，并且不会存在
版本冲突等问题。

SpringBoot 配置

SpringBoot配置文件分类

SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用application.properties或者application.yml（application.yaml）进行配置。
.yml和.yaml后缀名文件是一类文件。

• properties文件：

server.port=8080

• yml文件:

server:
    port: 8080

SpringBoot提供了2种配置文件类型：properteis和yml/yaml
默认配置文件名称：application
在同一级目录下优先级为：properties > yml > yaml

YAML

YAML全称是 YAML Ain’t Markup Language 。YAML是一种直观的能够被电脑识别的的数据数据序列化格式，并且容易被人类阅读，容易和脚本语言交互的，可以被支持YAML库的不同的编程语言程序导入，比如： C/C++, Ruby, Python, Java, Perl, C#, PHP等。YML文件是以数据为核心的，比传统的xml方式更加简洁。
YAML文件的扩展名可以使用.yml或者.yaml。

几种配置文件的比较：
properties文件:

server.port=8080
server.address=127.0.0.1

xml文件:

<server>
    <port>8080</port>
    <address>127.0.0.1</address>
</server>

yml文件:

server:
  port: 8082
  address: 127.0.0.1

yml简洁，以数据为核心

YAML：基本语法

• 大小写敏感
• 数据值前边必须有空格，作为分隔符
• 使用缩进表示层级关系
• 缩进时不允许使用Tab键，只允许使用空格（各个系统 Tab对应的 空格数目可能不同，导致层次混乱）
• 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
• ’#‘ 表示注释，从这个字符一直到行尾，都会被解析器忽略。

例如：

server:
  port: 8082
  address: 127.0.0.1
  
name: abc

YAML：数据格式

• 对象(map)：键值对的集合。

# 对象
person:
  name: zhangsan
  age: 20

# 行内写法
person: {
    
    name: zhangsan,age: 20}

• 数组：一组按次序排列的值

address:
  - beijing
  - shanghai

# 行内写法
address: [beijing,shanghai]

• 纯量：单个的、不可再分的值

#纯量
msg1: 'hello \n world' #单引号忽略转义字符
msg2: "hello \n world" #双引号识别转义字符

YAML：参数引用

name: zhangsan

# 对象
person:
  name: ${
    
    name} #zhangsan

小结
配置文件类型

• properties：和以前一样
• yml/yaml：注意空格

yaml：简洁，以数据为核心

• 基本语法
  • 大小写敏感
  • 数据值前边必须有空格，作为分隔符
  • 使用空格缩进表示层级关系，相同缩进表示同一级
• 数据格式
  • 对象
  • 数组: 使用 “- ”表示数组每个元素
  • 纯量
• 参数引用
  • ${key}

读取配置文件内容

• @Value
• Environment
• @ConfigurationProperties

1、通过@Value的方式获取

①、配置文件application.yml中内容为

name: ZhangSan

# 对象
person:
  name: ${
    
    name} #zhangsan
  age: 20

# 行内写法
#person: {name: zhangsan,age: 20}

#数组
address:
  - beijing
  - shanghai

# 行内写法
#address: [beijing,shanghai]

#纯量
msg1: 'hello \n world' #单引号忽略转义字符
msg2: "hello \n world" #双引号识别转义字符

②、获取配置文件中值的代码如下：

package com.qingbo.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Description: TODO
 * @author: ShiQingBo
 * @date: 2021年11月17日 23:39
 */
@RestController
public class HelloController {
    
    

  // 获取name对应值
  @Value("${name}")
  private String name;

  // 获取person对象中的name值
  @Value("${person.name}")
  private String person_name;

  // 获取person对象中的age值
  @Value("${person.age}")
  private Integer person_age;

  // 通过数组下标获取数组address中的第一个值
  @Value("${address[0]}")
  private String address;

  // 获取msg1对应的值
  @Value("${msg1}")
  private String msg1;

  // 获取msg2对应的值
  @Value("${msg2}")
  private String msg2;

  @RequestMapping("/hello2")
  public String hello2(){
    
    
    System.out.println("name:"+name);
    System.out.println("person_name:"+person_name);
    System.out.println("person_age:"+person_age);
    System.out.println("address:"+address);
    System.out.println("msg1:"+msg1);
    System.out.println("msg2:"+msg2);
    return "Hello Spring Boot Quick2!";
  }
  
}

③、浏览器访问你地址

http://localhost:8080/hello2

控制台输出：

name:ZhangSan
person_name:ZhangSan
person_age:20
address:beijing
msg1:hello \n world
msg2:hello
world

2、通过Environment的方式获取

①、配置文件application.yml中内容为

name: ZhangSan

# 对象
person:
  name: ${
    
    name} #zhangsan
  age: 20

# 行内写法
#person: {name: zhangsan,age: 20}

#数组
address:
  - beijing
  - shanghai

# 行内写法
#address: [beijing,shanghai]

#纯量
msg1: 'hello \n world' #单引号忽略转义字符
msg2: "hello \n world" #双引号识别转义字符

②、获取值的代码如下

package com.qingbo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Description: TODO
 * @author: ShiQingBo
 * @date: 2021年11月17日 23:39
 */
@RestController
public class HelloController {
    
    
    
    @Autowired
    private Environment env;
    
    @RequestMapping("/hello2")
    public String hello2(){
    
    
        System.out.println("===================================");
        System.out.println(env.getProperty("person.name"));
        System.out.println(env.getProperty("address[0]"));
        return "Hello Spring Boot Quick2!";
    }
    
}

③、浏览器访问你地址

http://localhost:8080/hello2

控制台输出：

===================================
ZhangSan
beijing

3、通过@ConfigurationProperties的方式获取(对象和配置属性绑定)

①、配置文件application.yml中内容为

# 对象
person:
  name: ZhangSan
  age: 20
  address:
    - beijing
    - shanghai

②、获取值的代码如下
Person.java实体

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix = "person") // 设置前缀
public class Person {
    
    
    private String name;
    private Integer age;
    private String[] address;

    // getter/setter/toString 方法
}

package com.qingbo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    
    
    @Autowired
    private Person person;
    
    @RequestMapping("/hello2")
    public String hello2(){
    
    
        System.out.println("===================================");
        System.out.println(person);
        String[] address = person.getAddress();
        for (String s : address) {
    
    
            System.out.println(s);
        }
        return "Hello Spring Boot Quick2!";
    }
    
}

③、浏览器访问你地址

http://localhost:8080/hello2

控制台输出：

===================================
Person{name='ZhangSan', age=20}
beijing
shanghai

profile配置文件

我们在开发Spring Boot应用时，通常同一套程序会被安装到不同环境，比如：开发、测试、生产等。其中数据库地址、服务器端口等等配置都不同，如果每次打包时，都要修改配置文件，那么非常麻烦。profile功能就是来进行动态配置切换的。
1、profile配置方式

• 多profile文件方式：提供多个配置文件，每个代表一种环境。
  • application-dev.properties/yml 开发环境
  • application-test.properties/yml 测试环境
  • application-pro.properties/yml 生产环境
• yml多文档方式
  • 在yml文件中使用 — 分隔不同配置

2、profile激活方式

• 配置文件：在配置文件中配置：spring.profiles.active=dev
• 虚拟机参数：在VM options 指定：-Dspring.profiles.active=dev
• 命令行参数：java –jar xxx.jar --spring.profiles.active=dev

例如：多profile文件方式：提供多个配置文件，每个代表一种环境。

多profile文件方式：提供多个配置文件，每个代表一种环境。
application-dev.properties/yml 开发环境的文件内容如下：

server.port = 8081

application-test.properties/yml 测试环境的文件内容如下：

server.port = 8082

application-pro.properties/yml 生产环境的文件内容如下：

server.port = 8083

在application.properties配置文件中配置profiles激活的配置文件。
①、application.properties中的文件内容如下： 其激活的文件对应的是开发环境中的配置文件

# 激活profiles中的配置文件
spring.profiles.active=dev

运行项目时会有相应的提示如下：

...... : The following profiles are active: dev # 激活的配置文件是:dev
...... : Tomcat initialized with port(s): 8081 (http) # Tomcat 对应的端口时8081

②、application.properties中的文件内容如下： 其激活的文件对应的是生产环境中的配置文件

# 激活profiles中的配置文件
spring.profiles.active=pro

运行项目时会有相应的提示如下：

...... : The following profiles are active: pro # 激活的配置文件是:pro
...... : Tomcat initialized with port(s): 8083 (http) # Tomcat 对应的端口时8083

例如：yml多文档方式

yml多文档方式
application.yml文件内容如下：

---

server:
  port: 8081
# 开发环境
spring:
  profiles: dev
---

server:
  port: 8082
# 测试环境
spring:
  profiles: test
---

server:
  port: 8083
# 生产环境
spring:
  profiles: pro
---

# 激活profiles中的对应配置文件
spring:
  profiles:
    active: dev

其激活对应的是 dev 开发环境
运行项目时会有相应的提示如下：

...... : The following profiles are active: dev # 激活的配置文件是:dev
...... : Tomcat started on port(s): 8081 (http) with # Tomcat 对应的端口时8081

虚拟机参数：

在VM options 指定：-Dspring.profiles.active=dev
在IDEA中操作步骤如下：

运行项目时会有相应的提示如下：

...... : The following profiles are active: pro # 激活的配置文件是:dev
...... : Tomcat started on port(s): 8083 (http) with # Tomcat 对应的端口时8083

命令行参数：

命令行参数：java –jar xxx.jar --spring.profiles.active=dev
在IDEA中操作步骤如下：

运行项目时会有相应的提示如下：

...... : The following profiles are active: dev # 激活的配置文件是:dev
...... : Tomcat started on port(s): 8081 (http) with # Tomcat 对应的端口时8081

命令行运行jar包的方式：
1、在IDEA中进行Maven项目打包操作，选择IDEA右侧的Maven，然后选择需要打包的项目

打包完成之后

2、运行打包好的jar包，Windows下先打开 Windows PowerShell切换到jar包所在目录
然后运行jar包。

SpringBoot内部配置加载顺序

Springboot程序启动时，会从以下位置加载配置文件：
1、file:./config/：当前项目下的/config目录下
2、file:./ ：当前项目的根目录
3、classpath:/config/：classpath的/config目录
4、classpath:/ ：classpath的根目录
加载顺序为上文的排列顺序，高优先级配置的属性会生效。

SpringBoot外部配置加载

通过官网查看外部属性加载顺序：

https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html

SpringBoot整合Junit单元测试

实现步骤：
1、搭建SpringBoot工程
2、引入starter-test起步依赖
3、编写测试类
4、添加测试相关注解

• @RunWith(SpringRunner.class)
• @SpringBootTest(classes = 启动类.class)

5、编写测试方法

具体操作步骤：
1、搭建SpringBoot工程
利用IDEA快速构建SpringBoot工程的步骤如下：
【File】------【New】------创建SpringBoot项目选择Project/创建SpringBoot模块选择Module

2、引入starter-test起步依赖
利用IDEA快速构建SpringBoot工程会自动把依赖加入其中如下所示：

<dependencies>
        
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>
  <!--SpringBoot测试依赖-->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
  <!--junit单元测试依赖-->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.1</version>
    <scope>test</scope>
  </dependency>
  
</dependencies>

3、编写测试类
4、添加测试相关注解

• @RunWith(SpringRunner.class)
• @SpringBootTest(classes = 启动类.class)

5、编写测试方法
UserServiceTest.java

package com.qingbo.service;

import com.qingbo.SpringBootTestApplication;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @Description: 测试类
 * @author: ShiQingBo
 * @date: 2021年11月23日 22:47
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringBootTestApplication.class)
public class UserServiceTest {
    
    

    @Autowired
    public UserService userService;

    @Test
    public void testAdd(){
    
    
        userService.add();
    }
}

UserService.java

package com.qingbo.service;

import org.springframework.stereotype.Service;

/**
 * @Description: TODO
 * @author: ShiQingBo
 * @date: 2021年11月23日 22:44
 */
@Service
public class UserService {
    
    

    public String add(){
    
    
        System.out.println("SpringBootTest");
        return "add_OK";
    }
}

SpringBoot整合Redis

实现步骤：
1、搭建SpringBoot工程
2、引入redis起步依赖
3、配置redis相关属性
4、注入RedisTemplate模板
5、编写测试方法，测试

具体操作步骤：
1、搭建SpringBoot工程
利用IDEA快速构建SpringBoot工程的步骤如下：
【File】------【New】------创建SpringBoot项目选择Project/创建SpringBoot模块选择Module

2、引入redis起步依赖

<dependencies>
  <!--redis依赖-->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
        
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.1</version>
    <scope>test</scope>
  </dependency>
</dependencies>

3、配置redis相关属性
4、注入RedisTemplate模板
5、编写测试方法，测试

package com.qingbo;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @Description: 测试Redis整合
 * @author: ShiQingBo
 * @date: 2021年11月23日 23:28
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootRedisApplicationTest {
    
    
    // 注入RedisTemplate模板
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testSet(){
    
    
        // 存入数据
        redisTemplate.boundValueOps("name").set("ZhangSan");
    }

    @Test
    public void testGet(){
    
    
        // 获取数据
        Object name = redisTemplate.boundValueOps("name").get();
        System.out.println(name);
    }
}

SpringBoot整合MyBatis

实现步骤：
1、搭建SpringBoot工程
2、引入mybatis起步依赖，添加mysql驱动
3、编写DataSource和MyBatis相关配置
4、定义表和实体类
5、编写dao和mapper文件/纯注解开发
6、测试

具体实现步骤：
1、搭建SpringBoot工程
利用IDEA快速构建SpringBoot工程的步骤如下：
【File】------【New】------创建SpringBoot项目选择Project/创建SpringBoot模块选择Module

2、引入mybatis起步依赖，添加mysql驱动

<dependencies>
  <!--mybatis依赖坐标-->
  <dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.0</version>
  </dependency>

  <!--MySQL数据库驱动依赖坐标-->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
  </dependency>
        
  <!--spring boot 测试依赖坐标-->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
        
  <!--junit单元测试依赖坐标-->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.1</version>
    <scope>test</scope>
  </dependency>
        
</dependencies>

3、编写DataSource和MyBatis相关配置
在application.yml中引入DataSource

# datasource
spring:
  datasource:
    url: jdbc:mysql:///springboot
    username: root
    password: root66
    driver-class-name: com.mysql.cj.jdbc.Driver #com.mysql.jdbc.Driver 这个驱动类被启用

在application.yml中引入MyBatis相关配置

# datasource
spring:
  datasource:
    url: jdbc:mysql:///springboot
    username: root
    password: root66
    driver-class-name: com.mysql.cj.jdbc.Driver #com.mysql.jdbc.Driver 这个驱动类被启用

# mybatis
mybatis:
  config-location: #指定mybatis的核心配置文件
  mapper-locations: classpath:mapper/*Mapper.xml # mapper映射文件路径
  type-aliases-package: com.qingbo.domain #别名配置

4、定义表和实体类
创建表的SQL语句如下：

CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(32) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `password` varchar(32) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

User.java实体类如下：

package com.qingbo.domain;

/**
 * @Description: TODO
 * @author: ShiQingBo
 * @date: 2021年11月24日 0:07
 */
public class User {
    
    
    private Integer id;
    private String username;
    private String password;
    
//    getter/setter/toString 方法
  
}

5、编写dao和mapper文件/纯注解开发
UserMapper.java 纯注解

package com.qingbo.mapper;

import com.qingbo.domain.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

@Mapper
public interface UserMapper {
    
    
    @Select("select * from t_user ")
    List<User> findAll();
}

编写dao和mapper文件
UserXmlMapper.java

package com.qingbo.mapper;

import com.qingbo.domain.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @Description: TODO
 * @author: ShiQingBo
 * @date: 2021年11月24日 9:26
 */
@Mapper
@Repository
public interface UserXmlMapper {
    
    

    List<User> findAll();
}

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.qingbo.mapper.UserXmlMapper">
    <select id="findAll" resultType="user">
        select * from t_user
    </select>
</mapper>

6、测试

package com.qingbo;

import com.qingbo.domain.User;
import com.qingbo.mapper.UserMapper;
import com.qingbo.mapper.UserXmlMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class SpringbootMybatisApplicationTests {
    
    

  @Autowired
  public UserMapper userMapper;

  @Autowired
  public UserXmlMapper userXmlMapper;

  @Test
  public void testFindAll() {
    
    
    List<User> users = userMapper.findAll();
    System.out.println(users);
  }

  @Test
  public void testFindAll2() {
    
    
    List<User> users = userXmlMapper.findAll();
    System.out.println(users);
  }
}

控制台输出：

[User{id=1, username='zhangsan', password='123'}, User{id=2, username='lisi', password='234'}]

id=“findAll” resultType=“user”>
select * from t_user

6、测试  
```java
package com.qingbo;

import com.qingbo.domain.User;
import com.qingbo.mapper.UserMapper;
import com.qingbo.mapper.UserXmlMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class SpringbootMybatisApplicationTests {

  @Autowired
  public UserMapper userMapper;

  @Autowired
  public UserXmlMapper userXmlMapper;

  @Test
  public void testFindAll() {
    List<User> users = userMapper.findAll();
    System.out.println(users);
  }

  @Test
  public void testFindAll2() {
    List<User> users = userXmlMapper.findAll();
    System.out.println(users);
  }
}

控制台输出：

[User{id=1, username='zhangsan', password='123'}, User{id=2, username='lisi', password='234'}]