文章引用

同篇文章引自亮哥博客 SpringBoot2.X快速上手 : https://haoyongliang.gitee.io

Spring Boot - 01

1. SpringBoot 概述

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

image-20200825203923139

1.1 Spring 缺点

1.1.1 配置繁琐

虽然Spring的组件代码是轻量级的,但它的配置却是重量级的。一开始,Spring用XML配置,而且是很多 XML配置。Spring 2.5引入了基于注解的组件扫描,这消除了大量针对应用程序自身组件的显式XML配置。 Spring 3.0引入了基于Java的配置,这是一种类型安全的可重构配置方式,可以代替XML。

所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换,所 以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样,Spring实用,但它要求的回报也不少。

1.1.1 依赖繁琐

项目的依赖管理也是一件耗时耗力的事情。在环境搭建时,需要分析要导入哪些库的坐标,而且还需要分析导 入与之有依赖关系的其他库的坐标,一旦选错了依赖的版本,随之而来的不兼容问题就会严重阻碍项目的开发 进度。

1.2 SpringBoot 功能

1.2.1 自动配置

Spring Boot的自动配置是一个运行时(更准确地说,是应用程序启动时)的过程,考虑了众多因素,才决定 Spring配置应该用哪个,不该用哪个。该过程是SpringBoot自动完成的。

1.2.2 起步依赖

起步依赖本质上是一个Maven项目对象模型(Project Object Model,POM),定义了对其他库的传递依赖 ,这些东西加在一起即支持某项功能。 简单的说,起步依赖就是将具备某种功能的坐标打包到一起,并提供一些默认的功能。

1.2.3 辅助功能

提供了一些大型项目中常见的非功能性特性,如嵌入式服务器、安全、指标,健康检测、外部配置等。

1.3 小结

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

2. SpringBoot 快速入门

2.1 案例:需求

搭建SpringBoot工程,定义HelloController.hello()方法,返回”Hello SpringBoot!”。

2.2 案例:实现步骤

  1. 创建Maven项目

  2. 导入SpringBoot起步依赖

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    <?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>

    <groupId>com.itheima</groupId>
    <artifactId>springboot-helloworld</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--springboot工程需要继承的父工程-->
    <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.8.RELEASE</version>
    </parent>

    <dependencies>
    <!--web开发的起步依赖-->
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    </dependencies>

    </project>
  1. 定义Controller

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    package com.itheima.controller;

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

    @RestController
    public class HelloController {

    @RequestMapping("/hello")
    public String hello(){
    return " hello Spring Boot !";
    }
    }

  1. 编写引导类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    package com.itheima;

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

    /**
    * 引导类。 SpringBoot项目的入口
    */
    @SpringBootApplication
    public class HelloApplication {

    public static void main(String[] args) {
    SpringApplication.run(HelloApplication.class,args);
    }
    }

  1. 启动测试

2.3 小结

  1. SpringBoot在创建项目时,使用jar的打包方式。

  2. SpringBoot的引导类,是项目入口,运行main方法就可以启动项目。

  3. 使用SpringBoot和Spring构建的项目,业务代码编写方式完全一样。

3. SpringBoot 起步依赖原理分析

  1. spring-boot-starter-parent
  2. spring-boot-starter-web

3.1 小结

  1. 在spring-boot-starter-parent中定义了各种技术的版本信息,组合了一套最优搭配的技术版本。
  2. 在各种starter中,定义了完成该功能需要的坐标合集,其中大部分版本信息来自于父工程。
  3. 我们的工程继承parent,引入starter后,通过依赖传递,就可以简单方便获得需要的jar包,并且不会存在 版本冲突等问题。

4. SpringBoot 配置

4.1 配置文件分类

​ SpringBoot是基于约定的,所以很多配置都有默认值,但如果想使用自己的配置替换默认配置的话,就可以使用 application.properties或者application.yml(application.yaml)进行配置。

  1. properties:

    1
    server.port=8080
  1. yml:

    1
    2
    server:
    port: 8080
4.1.1 小结
  1. SpringBoot提供了2种配置文件类型:properteis和yml/yaml

  2. 默认配置文件名称:application

  3. 在同一级目录下优先级为:properties > yml > yaml

4.2 yaml

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

  1. properties:

    1
    2
    server.port=8080
    server.address=127.0.0.1
  1. xml:

    1
    2
    3
    4
    <server>
    <port>8080</port>
    <address>127.0.0.1</address>
    </server>
  1. yml:

    1
    2
    3
    4
    server:
    port: 8080
    address: 127.0.0.1

    简洁,以数据为核心

4.2.1 YAML:基本语法
  1. 大小写敏感
  2. 数据值前边必须有空格,作为分隔符
  3. 使用缩进表示层级关系
  4. 缩进时不允许使用Tab键,只允许使用空格(各个系统 Tab对应的 空格数目可能不同,导致层次混乱)。
  5. 缩进的空格数目不重要,只要相同层级的元素左侧对齐即可
  6. # 表示注释,从这个字符一直到行尾,都会被解析器忽略。
1
2
3
4
server:
port: 8080
address: 127.0.0.1
name: abc
4.2.2 YAML:数据格式
  1. 对象(map):键值对的集合。

    1
    2
    3
    4
    person:
    name: zhangsan
    # 行内写法
    person: {name: zhangsan}
  1. 数组:一组按次序排列的值

    1
    2
    3
    4
    5
    address:
    - beijing
    - shanghai
    # 行内写法
    address: [beijing,shanghai]
  1. 纯量:单个的、不可再分的值

    1
    2
    msg1: 'hello \n world' # 单引忽略转义字符
    msg2: "hello \n world" # 双引识别转义字符
4.2.3 YAML:参数引用
1
2
3
name: lisi
person:
name: ${name} # 引用上边定义的name值
4.2.4 小结
  1. 配置文件类型

     1. properties:和以前一样 

    ​ 2. yml/yaml:注意空格

  2. yaml:简洁,以数据为核心

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

4.3 读取配置文件内容

4.3.1 读取配置内容
  1. @Value

  2. Environment

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    package com.example.springbootday01fast;

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

    @RestController
    public class HelloController {

    @Value("${name}")
    private String name;
    @Value("${person.name}")
    private String name2;
    @Value("${person.age}")
    private int age;
    @Value("${address[1]}")
    private String beijing;

    @Autowired
    private Environment env;
    @RequestMapping("hello")
    public String hello(){
    System.out.println(name2);
    System.out.println(age);
    System.out.println(beijing);
    System.out.println(env.getProperty("address[0]"));
    return "hello spring boot+"+name;
    }
    }

  1. @ConfigurationProperties

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    package com.example.springbootday01fast;

    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;

    @Component
    @ConfigurationProperties(prefix = "person")
    public class Person {

    private String name;
    private int age;
    private String[] address;

    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[] getAddress() {
    return address;
    }

    public void setAddress(String[] address) {
    this.address = address;
    }
    }


    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    package com.example.springbootday01fast;

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

    @RestController
    public class HelloController {

    @Value("${name}")
    private String name;
    @Value("${person.name}")
    private String name2;
    @Value("${person.age}")
    private int age;
    @Value("${address[1]}")
    private String beijing;

    @Autowired
    private Environment env;
    @Autowired
    private Person person;
    @RequestMapping("hello")
    public String hello(){
    System.out.println(name2);
    System.out.println(age);
    System.out.println(beijing);
    System.out.println(env.getProperty("address[0]"));
    System.out.println(person.getAge());
    System.out.println(person.getAddress()[0]);
    return "hello spring boot+"+name;
    }
    }


4.4 profile

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.8.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.itheima</groupId>
<artifactId>springboot-profiles</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springboot-profiles</name>
<description>Demo project for Spring Boot</description>

<properties>
<java.version>1.8</java.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

</project>

1
spring.profiles.active=dev
  1. profile配置方式

    1. 多profile文件方式
    2. yml多文档方式
  2. profile激活方式

    1. 配置文件

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      ---

      server:
      port: 8085

      spring:
      profiles: dev
      ---

      server:
      port: 8086

      spring:
      profiles: test
      ---
      server:
      port: 8087

      spring:
      profiles: pro
      ---
      spring:
      profiles:
      active: dev
  1. 虚拟机参数

    1
    -Dspring.profiles.active=pro
  1. 命令行参数

    1
    java -jar .\springboot-day01-fast-0.0.1-SNAPSHOT.jar --spring.profiles.active=test
4.4.1 Profile-小结
  1. profile是用来完成不同环境下,配置动态切换功能的。

  2. profile配置方式

    1. 多profile文件方式:提供多个配置文件,每个代表一种环境
      1. application-dev.properties/yml 开发环境
      2. application-test.properties/yml 测试环境
      3. application-pro.properties/yml 生产环境
    2. yml多文档方式:
      1. 在yml中使用 — 分隔不同配置
  3. profile激活方式

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

4.5 内部配置加载顺序

Springboot程序启动时,会从以下位置加载配置文件:

  1. . file:./config/:当前项目下的/config目录下
  2. file:./ :当前项目的根目录
  3. classpath:/config/:classpath的/config目录
  4. classpath:/ :classpath的根目录

加载顺序为上文的排列顺序,高优先级配置的属性会生效

4.6 外部配置加载顺序

通过官网查看外部属性加载顺序:https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-external-config

5. SpringBoot 整合其他框架

5.1 SpringBoot整合Junit。

需求:SpringBoot整合Junit。

案例:实现步骤

  1. 搭建SpringBoot工程

  2. 引入starter-test起步依赖

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.8.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.itheima</groupId>
    <artifactId>springboot-junit</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-junit</name>
    <description>Demo project for Spring Boot</description>

    <properties>
    <java.version>1.8</java.version>
    </properties>

    <dependencies>
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    </dependency>

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

    <build>
    <plugins>
    <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
    </plugins>
    </build>

    </project>

  1. 编写测试类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    package com.itheima.springbootjunit;

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

    @SpringBootApplication
    public class SpringbootJunitApplication {

    public static void main(String[] args) {
    SpringApplication.run(SpringbootJunitApplication.class, args);
    }

    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.itheima.test;


import com.itheima.springbootjunit.SpringbootJunitApplication;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
* 测试类
*/

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringbootJunitApplication.class )
public class UserServiceTest {

@Test
public void test(){
System.out.println(111);
}
}


1
2
3
4
5
6
7
8
9
10
11
12
13
package com.itheima.springbootjunit;


import org.springframework.stereotype.Service;

@Service
public class UserService {

public void show(){
System.out.println("show....");
}
}

  1. 添加测试相关注解

     1.    @RunWith(SpringRunner.class)
          2.    @SpringBootTest(classes = 启动类.class)
  2. 编写测试方法

  3. 如果测试类和启动类在同一个包下,则加@SpringBootTest即可

5.2 SpringBoot整合Redis。

案例:实现步骤

  1. 搭建SpringBoot工程

  2. 引入redis起步依赖

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.8.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.itheima</groupId>
    <artifactId>springboot-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-redis</name>
    <description>Demo project for Spring Boot</description>

    <properties>
    <java.version>1.8</java.version>
    </properties>

    <dependencies>
    <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>
    </dependencies>

    <build>
    <plugins>
    <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
    </plugins>
    </build>

    </project>

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    package com.itheima.springbootredis;

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

    @SpringBootApplication
    public class SpringbootRedisApplication {

    public static void main(String[] args) {
    SpringApplication.run(SpringbootRedisApplication.class, args);
    }

    }

  1. 配置redis相关属性

    1
    2
    3
    4
    5
    spring:
    redis:
    host: 127.0.0.1 # redis的主机ip
    port: 6379

  1. 注入RedisTemplate模板

  2. 编写测试方法,测试

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    package com.itheima.springbootredis;

    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.BoundValueOperations;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.test.context.junit4.SpringRunner;

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class SpringbootRedisApplicationTests {

    @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);
    }

    }

5.3 SpringBoot整合MyBatis。

案例:实现步骤

  1. 搭建SpringBoot工程

  2. 引入mybatis起步依赖,添加mysql驱动

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.8.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.itheima</groupId>
    <artifactId>springboot-mybatis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-mybatis</name>
    <description>Demo project for Spring Boot</description>

    <properties>
    <java.version>1.8</java.version>
    </properties>

    <dependencies>
    <dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.0</version>
    </dependency>

    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <!--<scope>runtime</scope>-->
    </dependency>
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
    </dependency>
    </dependencies>

    <build>
    <plugins>
    <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
    </plugins>
    </build>

    </project>

  1. 编写DataSource和MyBatis相关配置 application.yml

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    # datasource
    spring:
    datasource:
    url: jdbc:mysql:///springboot?serverTimezone=UTC
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver


    # mybatis
    mybatis:
    mapper-locations: classpath:mapper/*.xml # mapper映射文件路径
    type-aliases-package: com.example.springbootday01mybatis.domain

    # config-location: # 指定mybatis的核心配置文件

  1. 定义表和实体类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    package com.example.springbootday01mybatis.domain;

    public class User {
    private int id;
    private String username;
    private String password;


    public int getId() {
    return id;
    }

    public void setId(int id) {
    this.id = id;
    }

    public String getUsername() {
    return username;
    }

    public void setUsername(String username) {
    this.username = username;
    }

    public String getPassword() {
    return password;
    }

    public void setPassword(String password) {
    this.password = password;
    }

    @Override
    public String toString() {
    return "User{" +
    "id=" + id +
    ", username='" + username + '\'' +
    ", password='" + password + '\'' +
    '}';
    }
    }


  1. 编写dao和mapper文件/纯注解开发

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    package com.example.springbootday01mybatis.mapper;

    import com.example.springbootday01mybatis.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 user")
    public List<User> findAll();
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    package com.example.springbootday01mybatis.mapper;

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

    import java.util.List;

    @Mapper
    public interface UserXmlMapper {
    List<User> findAll();
    }

1
2
3
4
5
6
7
<?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.example.springbootday01mybatis.mapper.UserXmlMapper">
<select id="findAll" resultType="user">
select * from user
</select>
</mapper>
  1. 测试

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    package com.example.springbootday01mybatis;

    import com.example.springbootday01mybatis.domain.User;
    import com.example.springbootday01mybatis.mapper.UserMapper;
    import com.example.springbootday01mybatis.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 SpringbootDay01MybatisApplicationTests {

    @Test
    void contextLoads() {
    }

    @Autowired
    private UserMapper userMapper;
    @Autowired
    private UserXmlMapper userXmlMapper;

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