SpringBoot笔记

2022-12-28 11:55 580人阅读评论(0)

程序猿萌新又接触了一大批优秀的框架🐻。

文章目录

一、SpringBoot 概述
二、SpringBoot 快速入门
三、 SpringBoo项目结构
四、配置文件
五、SpringBoot整合JUnit
- 1. 回顾Spring整合JUnit
- 2. SpringBoot整合JUnit
六、SpringBoot整合SpringMVC
- 1. 设置拦截器
- 2. 静态资源访问
七、SpringBoot整合MyBatis
八、彩蛋

一、SpringBoot 概述

SpringBoot 可以轻松创建独立的、基于Sring的生产级应用程序，而这只需要一些Spring很少的配置。SpringBoot 是现在最主流的开发框架，它提供一站式的开发体验，大幅度提高我们的开发效率。

Spring官网：https://spring.io/

springBoot官网：https://spring.io/projects/spring-boot

随着 Spring 不断的发展，涉及的领域越来越多，项目整合开发需要配置各种各样的文件，慢慢变得不那么简单易用，违背了最初的理念，甚至人称配置地狱。SpringBoot 正是在这样的一个背景下被抽象出来的开发框架，目的为了让大家更容易的使用 Spring 、更容易的集成各种常用的中间件、开源软件；

Spring的缺点：配置繁琐、依赖设置繁琐。

SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。也就是说，它并不是用来替代 Spring 的解决方案，而是和 Spring 框架紧密结合用于提升 Spring 开发体验的工具。SpringBoot 以约定优于配置的核心思想，默认帮我们进行了很多设置，多数 SpringBoot 应用只需要很少的 Spring 配置。同时它集成了大量常用的第三方库配置（例如 Redis、MongoDB、JPA、RabbitMQ、Quartz 等等），SpringBoot 应用中这些第三方库几乎可以零配置的开箱即用。

简单来说就是SpringBoot其实不是什么新的框架，它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，spring boot整合了很多框架 (spring-boot-starter-xxx）。

SpringBoot 出生名门，从一开始就站在一个比较高的起点，又经过这几年的发展，生态足够完善，SpringBoot 已经当之无愧成为 Java 领域最热门的技术。

SpringBoot功能：

创建独立的Spring应用程序。
内嵌web容器Tomcat、Jetty或Undertow（无需部署war包，通过打好的jar包就可以直接运行应用程序）。
提供一站式的 “starter” 依赖，以简化Maven配置（需要整合什么框架，直接导对应框架的starter依赖即可）。
尽可能自动配置Spring和第三方库（除非特殊情况，否则几乎不需要我们进行配置）。
提供生产就绪功能，如：指标、运动状况检查和外部化配置。
没有代码生成，也没有XML配置要求。

总结：SpringBoot用来简化Spring应用的初始搭建以及开发过程(只需Spring很少的配置)，特点：约定优于配置。

不要被框架限制了自己，学框架使用、思想、底层原理(如设计模式等等)。

二、SpringBoot 快速入门

1. 前期准备

在maven的setting.xml文件中配置阿里云仓库镜像、jdk编译版本。

<mirrors>
    <!-- 阿里云仓库镜像 -->
    <mirror>
        <id>nexus-aliyun</id>
        <mirrorOf>central</mirrorOf>
        <name>Nexus aliyun</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public</url>
    </mirror>
</mirrors>

<profiles>
    <!--配置jdk8版本编译-->
    <profile>
        <id>jdk-1.8</id>
        <activation>
            <activeByDefault>true</activeByDefault>
            <jdk>1.8</jdk>
        </activation>
        <properties>
            <maven.compiler.source>1.8</maven.compiler.source>
            <maven.compiler.target>1.8</maven.compiler.target>
            <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
        </properties>
    </profile>
</profiles>

在IDEA中配置maven：在不联网的情况下使用本地插件构建项目。

-DarchetypeCatalog=internal -Dfile.encoding=GB2312

2. 快速创建SpringBoot项目

通Maven项目导依赖和插件，以及编写主类构建 (常用)

1、创建Maven模块

2、导入依赖

<!--父工程-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.5</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>


<dependencies>
    <!--springmvc的启动器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>


<build>
    <!--配置项目打包后的名称-->
    <finalName>springboot_quick</finalName>
    <plugins>
        <!--打包插件-->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

pom文件完整描述：

<?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:指定了pom文件的模型版本(Maven3必须是4.0.0)-->
    <modelVersion>4.0.0</modelVersion>

    <!--groupId:表示项目所以群组信息（群组id）-->
    <groupId>org.example</groupId>
    <!--artifactId:表示项目在组内的唯一标识（通常理解为项目id、项目名）-->
    <artifactId>springboot_01_quickstart</artifactId>
    <!--version:项目版本-->
    <version>1.0-SNAPSHOT</version>
    <!--packaging:项目的打包方式,jar(默认,可以省略不写)、war(web项目)、pom(聚合工程)-->
    <packaging>jar</packaging>
    <!--项目描述-->
    <description>Demo Project for Spring Boot</description>
    

    <!--properties:用于存放各种属性,包括自定义属性-->
    <properties>
        <!--jdk的编译版本-->
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    

    <!--parent:父工程项目相关信息-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    

    <!-- dependencies:管理依赖jar包的坐标信息(常用) -->
    <dependencies>
        <!--springmvc的启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <!--build:用于配置项目的构建信息-->
    <build>
        <!--finalName:配置项目打包后的名称-->
        <finalName>springboot_quick</finalName>
        <!--plugins:配置构建项目所需要的插件-->
        <plugins>
            <!--打包插件-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3、编写启动类（放在com.baidou包下）

package com.baidou;

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

/**
 * SpringBoot启动类(入口类)
 *
 * @author 白豆五
 * @version 2022/12/25 20:05
 * @since JDK8
 */
@SpringBootApplication // 表示当前类是SpringBoot启动类,这个注解内部活非常多
public class HelloApplication {
   
    public static void main(String[] args) {
   
        SpringApplication.run(HelloApplication.class, args);
    }
}

4、编写控制器类（路由）

package com.baidou.controller;

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

/**
 * 处理请求,将内容返回给页面
 * @author 白豆五
 * @version 2022/12/25 20:07
 * @since JDK8
 */
@RestController  // @RestController=@Controller+@ResponeBody
@RequestMapping("test")
public class HelloController {
   

    @GetMapping("hello")
    public String hello() {
   
        System.out.println("收到了一个请求~");
        return "Hello SpringBoot!!!";
    }
}

5、运行启动类的main方法(启动springboot程序)

项目启动成功后是这个样子的：

6、测试访问：http:localhost:8080/test/hello

3. 其他方式创建SpringBoot项目

① 通过IDEA上的【spring initializr】脚手架构建。（了解）

1、首先点击【spring initializr】，然后配置项目使用的jdk环境，最后点击【next】。

2、填写项目的配置信息。

3、选择依赖，勾选web支持，最后点【next】。

4、配置项目名称和路径。

5、编写一个HelloController。

package com.baidou.controller;

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

/**
 * 接收请求并将数据响应到页面
 * @author 白豆五
 * @version 2022/8/24 18:05
 * @since JDK8
 */
@RestController
public class HelloController {
   

    @GetMapping("/hello")
    public String hello(){
   
        return "Hello World!";
    }
}

6、启动springboot项目，跟之前运行Java程序一样，快捷键：shift+f10。

7、测试访问：http://localhost:8080/hello。

到这里你已经学会SpringBoot项目的基本创建和运行流程啦😊

② 通过官网上的Spring Initializer构建。（了解）

通过网页来创建springboot项目并下载到本地，使用的时候用IDEA导入即可。

Spring Initializer：https://start.springboot.io/ 、https://start.spring.io/
阿里提供的脚手架：https://start.aliyun.com

（扩展：搭建个人Spring Initializr服务器）

4. SpringBoot的三种启动方式

第一种方式：运行启动类的main方法启动SpringBoot项目。

第二种方式：在当前项目路径下使用maven命令去运行springboo项目。

mvn spring-boot:run

或者在IDEA右侧Maven面板上执行命名：

第三种方式：打包部署的方式运行SpringBoot项目。

1、将项目打包，命令如下：

mvn clean package

或者使用MavenHelper插件手动为项目打包：

2、运行项目jar包，命令如下：

java -jar xx.jar

三、 SpringBoo项目结构

1. 目录结构

pom.xml 文件

指定了一个父工程（parent）：指定当前项目为SpringBoot，帮助我们声明了starter依赖的版本（spring-boot-starter-xxx）。
项目元数据：包名，项目名，版本号。
指定了properties信息：指定了java的编译版本为1.8。
导入依赖：spring-boot-starter（所有场景启动器最底层的依赖，常规依赖自导入）
打包插件：spring-boot-maven-plugin。

.gitignore 文件

src 目录

--src  
	--main
	 	--java            // Java源码文件目录
			--包名
			   启动类.java      // 我们编写的类,需要放在启动类的子包中或者同级包下
		--resources        // 资源目录
			--static       // 存放静态资源的
			--templates    // 存放模板页面的
			application.properties  // SpringBoot提供的唯一的配置文件
	--test  // 单元测试

完整项目结构

springboot_01_quickstart  //工程根目录
|---target                //工程编译打包输出目录
|---.gitignore            //上传Git的时候忽略一些文件和目录
|---pom.xml               //管理Maven依赖
+---src   
   +---main              //项目主目录
   |   +---java          //Java源码文件目录
   |   |   \---com
   |   |       \---baidou
   |   |           |---controller
   |   |           |---service
   |   |           |---mapper
   |   |           |---pojo
   |   |           |---config
   |   |           |---...
   |   |           \---HelloApplication //SpringBoot主类
   |   | 
   |   \---resources         //资源文件目录
   |       |---static        //放静态资源文件,如 js、css等
   |       |---templates     //页面模板,如 Thymeleaf、FreeMarker等
   |       \---application.yml    //SpringBoot核心配置文件
   | 
   \---test       //单元测试目录
       +---java   //单元测试Java源码文件目录
       |   \---com
       |       \---baidou
       |           |---controller
       |           |---service
       |           |---dao
       |           |---pojo
       |           |---config
       |           |---...
       |           \---SpringBootDemoApplicationTests //SpringBoot测试主类
       \---resources         //单元测试资源文件目录

target目录：Maven打包后会将编译后的.class文件和依赖的jar包等资源文件放到这个目录里。
pom.xml文件：用来管理项目和依赖jar包。
src目录：存放Java源码程序、程序配置文件、资源文件等，是开发用到的主目录。
.gitignore文件：用来配置一些不需要通过Git进行版本控制的文件或目录。

使用 tree 命名生成目录树（扩展）

生成目录结构：tree
生成目录结构（包括文件）：tree /f

2. 父工程

父项工程做依赖管理(可以锁定依赖的版本，减少依赖冲突)，例如我们自己的项目继承了 spring-boot-starter-parent 父工程，就代表我们的项目也是SpringBoot项目：

<!--父工程-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.5</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

然后spring-boot-starter-parent又继承了 spring-boot-dependencies父工程。

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.4.5</version>
</parent>

在spring-boot-dependencies中几乎声明了所有开发中常用的依赖版本。

dependencyManagement依赖管理：（springboot父工程里面管理了一些依赖版本，父工程不会直接导入这些依赖，而是留给子工程用，当然我们也可以导入没被SpringBoo管理的依赖）

我们项目继承父工程后，导入依赖无需关注版本号，如发生坐标错误再指定version（注意：要小心版本冲突）。

<dependencies>
    <!--springmvc的启动器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--junit的启动器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
</dependencies>

3. 起步依赖/启动器（starter）

spring官网中，提供了大量功能的起步依赖：https://docs.spring.io/spring-boot/docs/2.4.13/reference/html/using-spring-boot.html#using-boot-starter

SpringBoot将所有的功能场景都抽取出来，做成一个个的starter （启动器），只需要在项目中引入这些starter即可，所有相关的依赖便会自动导进来，例如：

spring-boot-starter-web，用于web开发。
spring-boot-starter-test，用于单元测试。
spring-boot-starter-mail，用于邮件服务。
spring-boot-starter-redis，用于Redis。
…
通用格式：spring-boot-starter-xxx 。

当引入起步依赖时不需要写版本号(直接写GAV中的GA，群组id和项目即可)，因为我们项目pom.xml中引入了springboot父工程（父工程做版本控制），但是如果导入的包没有在SpringBoot依赖中管理就需要手动配置版本了。

<!--父工程-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.6</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

<!--导入的依赖-->
<dependencies>
    <!--springmvc的启动器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <!--starter默认不需要写版本号-->
    </dependency>
    <!--junit的启动器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <!--starter默认不需要写版本号-->
        <scope>test</scope> <!--只在测试的时候使用-->
    </dependency>
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.7.6</version>
    </dependency>
</dependencies>

总结：起步依赖starter整合了很多常用功能，可以减少大量重复性工作。

4. 辅助功能

例如：SpringBoot项目内置了tomcat服务器。（springboot默认使用tomcat）
如果不想用tomcat，可以切换成jetty，jetty比tomcat更轻量级，可扩展性更强（相较于Tomcat），谷歌应用引擎（GAE）已经全面切换为Jetty。
在【web起步依赖】中排除【tomcat起步依赖】，然后再单独导入【jetty起步依赖】即可。

<dependencies>
    <!--springmvc的启动器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <!--web起步依赖环境中,排除tomcat起步依赖 -->
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

    <!--web容器:jetty-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jetty</artifactId>
    </dependency>
</dependencies>

四、配置文件

1. 配置文件格式

SpringBoot提供了3种核心配置文件：

application.yml
application.properties
application.yaml （yaml和yml是一个东东）

1.1 修改服务器端口

application.properties：

# 配置web服务器端口号
server.port=80

application.yml：

server:
  port: 81

application.yaml：

server:
  port: 82

1.2 解决SpringBoot配置文件没有提示问题

1.3 SpringBoot配置文件加载顺序

同级目录下：application.properties(优先级最高) > application.yml > application.yaml

注意事项：

SpringBoot核心配置文件名为：application。
SpringBoot内置属性过多，且所有属性集中在一起修改，在使用时，通过提示键+关键字修改属性。
springboot常用的属性：https://docs.spring.io/spring-boot/docs/2.1.9.RELEASE/reference/htmlsingle/#appendix

2. YAML

2.1 为什么要用YAML？

SpringBoot使用 application.properties 和 application.yml 这两个作为全局配置文件，properties是一种常见的配置文件格式；
配置文件的作用就是来配置某些信息，修改某些默认值，在我们创建springboot项目时它会自动创建application.properties文件；
properties它有一个缺点，就是结构不清晰，不能体现配置项的相关性和层次性。
这里引入一种新的配置文件的形式就是yaml配置文件(YAML Ain’t Markup Langua，一种数据序列化格式)，后缀名为yml，它以数据为中心(重数据轻格式)，比json和xml更高效；
而且yml配置文件格式方便查阅；

如下几种配置文件存储数据对比：

# xml格式
<students>
    <student>
       <name>张三</name>	
       <age>21</age>	
       <sex>男</sex>	
    </student>
</students>



# json
{
	"name":"李四",
	"age":18,
	"sex":"女"
}


# properties
person.name=王五
person.age=29
person.sex=boy


# yaml
person:
	name: aopmin
	age: 18
	sex: maleale

2.2 YAML基本语法

以键值对的方式存储数据，kv之间有空格；
大小写敏感；
使用空格缩进表示层级关系；
缩进不允许使用tab，只允许空格；
对缩进的空格数目没有要求，只要同级元素左侧对齐即可；
#表示注释；
字符串无需加引号，如果要加的话双引号不会转义，单引号会转义。

2.3 YAML数据类型

1、字面量： 单个的、不可再分的值。如 date、boolean、string、number、null

k: v

示例：

port: 8080
name: aopmin
age: 18

2、对象（映射/字典）： 键值对的集合。如 map、hash、set、object

# 行内写法
k: {
   v1,v2,v3}

# 层级写法
k: 
 k1: v1  #k1表示k的属性
 k2: v2
 k3: v3

示例：

student:  
	name: 张三
	age: 18
	sex: 男

数组（列表）： 一组按次序排列的值。array、list、queue

# 行内写法
k: [v1,v2,v3]
#层级写法
k:
 - v1
 - v2
 - v3

示例：

hobbies: [Java,PHP,Python]

hobbies: 
   - Java
   - PHP
   - Python

2.4获取主配置文件信息的三种方式

方式1、使用@Value注解读取properties或者yml文件中的内容，属性名引用方式：${一级属性名.二级属性名……}。

yaml文件：

version: 1.0-SNAPSHOT # 字面量

student: # 对象
  name: aopmin
  age: 18
  sex: 男
  hobbies: # 数组
    - Java
    - PHP
    - Python

使用@Value注解读取yml单个数据：

@RestController
public class HelloController {
   

    //使用@Value读取单个数据
    @Value("${version}")
    private String version;

    @Value("${student.age}")
    private int age;

    @Value("${student.hobbies[2]}")
    private String hobbie3; // 获取数组中第3个元素


    @GetMapping("hello")
    public String hello() {
   
        System.out.println(version);
        System.out.println(age);
        System.out.println(hobbie3);
        return "helloworld";
    }
}

方式2、将全部数据封装到Environment对象

yaml文件：

version: 1.0-SNAPSHOT # 字面量

student: # 对象
  name: aopmin
  age: 18
  sex: 男
  hobbies: # 数组
    - Java
    - PHP
    - Python

将ymal全部数据封装到Environment对象，使用的时候注入即可，然后通过Environment对象的getProperty()方法获取指定属性值：

@RestController
public class HelloController {
   
    
    // 依赖注入
    @Autowired
    private Environment env; //Spring提供的

    @GetMapping("hello")
    public String hello() {
   
        System.out.println(env.getProperty("version"));
        System.out.println(env.getProperty("student.name"));
        System.out.println(env.getProperty("student.hobbies[0]"));
        return "helloworld";
    }
}

方式3、把指定数据封装到自定义类的对象中（常用）

如果在yml文件中需要编写大量的自定义配置，并且具有统一的前缀时，采用如下方式：

yaml文件：

version: 1.0-SNAPSHOT # 字面量

student: # 对象
  name: aopmin
  age: 18
  sex: 男
  hobbies: # 数组
    - Java
    - PHP
    - Python

自定义类与配置文件绑定：

@Data //lombok注解
@Component // 把这个类添加到Spring容器中 
@ConfigurationProperties(prefix = "student") //将这个类与配置文件前缀为student绑定,把yaml中student配置信息注入到当前类的Bean对象中
public class StudentProperties {
   
    private String name;
    private int age;
    private String sex;
    private List<String> hobbies;
}

controller：

@RestController
public class HelloController {
   

    @Autowired
    private StudentProperties student;

    @GetMapping("hello")
    public StudentProperties hello() {
   
        return student;
    }
}

解决自定义对象封装数据警告问题（可选操作）

需要向pom.xml导入依赖（插件可选操作），然后重启项目更新元数据：

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


<!--<build>-->
<!--    <plugins>-->
<!--        <plugin>-->
<!--            <groupId>org.springframework.boot</groupId>-->
<!--            <artifactId>spring-boot-maven-plugin</artifactId>-->
<!--            <configuration>-->
<!--                <excludes>-->
<!--                    <exclude>-->
<!--                        <groupId>org.springframework.boot</groupId>-->
<!--                        <artifactId>spring-boot-configuration-processor</artifactId>-->
<!--                    </exclude>-->
<!--                </excludes>-->
<!--            </configuration>-->
<!--        </plugin>-->

<!--        &lt;!&ndash; 添加配置跳过测试-start &ndash;&gt;-->
<!--        <plugin>-->
<!--            <groupId>org.apache.maven.plugins</groupId>-->
<!--            <artifactId>maven-surefire-plugin</artifactId>-->
<!--            <version>2.22.1</version>-->
<!--            <configuration>-->
<!--                <skipTests>true</skipTests>-->
<!--            </configuration>-->
<!--        </plugin>-->
<!--        &lt;!&ndash; 添加配置跳过测试-end &ndash;&gt;-->
<!--    </plugins>-->
<!--</build>

3. 多环境配置

在实际开发中，项目的开发环境(development，简称dev)、测试环境(test)、生产环境(production，简称pro)的配置信息可能会不一致，那么如何快速切换呢?

多环境启动配置：通过application.properties或者application.yml文件多环境切换。
多环境开发配置：Maven中设置多环境属性。
将其他环境的application.yml文件与项目打好的jar包放到同级目录，然后启动jar包就会用到这个其他环境的application.yml配置。

3.1 通过application.yml文件多环境启动配置

application-dev.yml（开发环境）

server:
  #  项目端口号
  port: 8080
  servlet:
  # 项目路径
    context-path: /

application-pro.yml(生成环境)

server:
  #  项目端口号
  port: 8081
  servlet:
    # 项目路径
    context-path: /boot

在application.yml文件中添加一个配置项spring.profiles.active = 环境名：(主启动配置文件）

（官方推荐使用这个 spring.config.activate.on-profile=环境名激活指定的环境）

spring:
  profiles: 
    active: dev # 配置默认使用开发环境

在部署工程时，通过命令 java -jar xxx.jar --spring.profiles.active=环境即可：

java -jar demo01.jar --spring.profiles.active=pro

3.2 多环境启动命令格式

带参数启动SpringBoot项目：

java –jar springboot.jar --spring.profiles.active=test
java –jar springboot.jar --server.port=88
java –jar springboot.jar --server.port=88 --spring.profiles.active=test

参数加载优先顺序：https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-external-config

3.3 通过maven多环境开发配置

Maven与SpringBoot多环境兼容配置（用maven控制指定环境，然后yml中引用maven配置的属性激活对应的环境，打包的时候可以使用maven命令为指定环境进行打包）（比较麻烦了解即可）

前期准备application.yml：

# 设置启动环境
spring:
  profiles:
    active: dev # 默认激活开发环境

---
# 开发
spring:
  profiles: dev #开发环境id
server:
  #  项目端口号
  port: 8080
  servlet:
    # 项目路径
    context-path: /
---
# 生产
spring:
  profiles: pro #生产环境id
server:
  #  项目端口号
  port: 8081
  servlet:
    # 项目路径
    context-path: /demo
---
# 测试
spring:
  profiles: test #测试环境id
server:
  #  项目端口号
  port: 8082
  servlet:
    # 项目路径
    context-path: /test

1、在项目pom文件中配置maven多环境属性

<!--maven多环境配置-->
<profiles>
    <!--开发环境-->
    <profile>
        <!--环境id-->
        <id>dev_env</id>
        <!--配置激活application.yml中dev环境-->
        <properties>
            <profile.active>dev</profile.active>
        </properties>
        <!--设置默认激活环境-->
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
    </profile>
    <!--生产环境-->
    <profile>
        <id>pro_env</id>
        <properties>
            <profile.active>pro</profile.active>
        </properties>
    </profile>
    <!--测试环境-->
    <profile>
        <id>test_env</id>
        <properties>
            <profile.active>test</profile.active>
        </properties>
    </profile>
</profiles>

2、导入属性加载过滤器插件：

<build>
    <plugins>
        <plugin>
            <artifactId>maven-resources-plugin</artifactId>
            <configuration>
                <encoding>utf-8</encoding>
                <useDefaultDelimiters>true</useDefaultDelimiters>
            </configuration>
        </plugin>
    </plugins>
</build>

3、在SpringBoot核心配置文件application.xml中引用Maven属性:

# 设置启动环境
spring:
  profiles:
    active: ${
   profile.active} # 引用maven上的多环境配置

---
# 开发
spring:
  profiles: dev #开发环境id
server:
  #  项目端口号
  port: 8080
  servlet:
    # 项目路径
    context-path: /
---
# 生产
spring:
  profiles: pro #生产环境id
server:
  #  项目端口号
  port: 8081
  servlet:
    # 项目路径
    context-path: /demo
---
# 测试
spring:
  profiles: test #测试环境id
server:
  #  项目端口号
  port: 8082
  servlet:
    # 项目路径
    context-path: /test

4、使用Maven命令打包并切换生产环境

mvn clear package -P pro_env

5、测试

ok已经成功用生产环境部署项目了。

3.4 配置文件分类

多级文件的作用：1级与2级留做系统打包后设置通用属性，3级与4级用于系统开发阶段设置通用属性。

配置文件可以出现在以下四种位置：

1级： file:config/application.yml 【优先级最高】
2级： file:application.yml
3级：classpath:config/application.yml
4级：classpath:application.yml 【优先级最低】

五、SpringBoot整合JUnit

1. 回顾Spring整合JUnit

1、导入依赖：

<!--junit 保证在4.12(含)之上-->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
</dependency>
<!--spring整合junit 版本务必和其他的spring的一致-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>5.2.10.RELEASE</version>
</dependency>

2、测试类：要配置Spring整合Junit专用的类加载器以及配置类所在的地方

// 使用Spring整合Junit专用的类加载器
@RunWith(SpringJUnit4ClassRunner.class)
// 加载配置文件或者配置类
@ContextConfiguration(classes = {
   SpringConfig.class}) //加载配置类
//@ContextConfiguration(locations={"classpath:applicationContext.xml"})//加载配置文件
public class AccountServiceTest {
   
    //支持自动装配注入bean
    @Autowired
    private AccountService accountService;

    @Test
    public void testFindById(){
   
        System.out.println(accountService.findById(1));
    }

    @Test
    public void testFindAll(){
   
        System.out.println(accountService.findAll());
    }
}

2. SpringBoot整合JUnit

1、导入Junit起步依赖：

<!--Junit起步依赖-->
<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-test</artifactId>
</dependency>

2、编写测试类 (注意：测试类必须放在和启动类相同的包下，或者放在启动类所在包的子包下)

@SpringBootTest
public class GoodMapperTest {
   
    
    @Autowired
   private GoodMapper goodMapper;
    @Test
    public void test0() {
   
        System.out.println(goodMapper.selectById(536563d));
    }

    @Test
    public void test1() {
   

        Good good = new Good(12345d,"测试数据",1d,3d,3d,new Date(),"测试数据","测试数据");
        boolean save = goodMapper.save(good);
        System.out.println(save);
    }

    @Test
    public void test2() {
   
        Good good = new Good(12345d,"测试数据122",1222d,322d,322d,new Date(),"测试2数据","测试数据");
        boolean save = goodMapper.updateById(good);
        System.out.println(save);
    }

    @Test
    public void test3() {
   
        boolean b = goodMapper.deleteById(562379d);
        System.out.println(b);
    }
}

如果测试类无法注入Bean，在测试类上添加@ContextConfiguration(classes = 启动类.class)即可。

报错信息：非法状态异常，找不到@SpringBootConfiguration注解标注的SpringBoot配置类，需要使用@ContextConfiguration 或者 @SpringBootTest(classes=xxx)注解加载配置类。

六、SpringBoot整合SpringMVC

1. 设置拦截器

1、导入依赖web开发起步依赖：

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

2、编写Controller：

@RestController
@RequestMapping("books")
public class BookController {
   

    @GetMapping("hello")
    public String hello() {
   
    	 System.out.println("接收了一个请求~~~");
        return "helloworld";
    }
}

3、在com.baidou.handler包下编写拦截器：（拦截器功能：登录认证、权限验证、记录日志、性能监控等等）

package com.baidou.handler;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 拦截器
 * 定义一个去实现HandlerInterceptor接口重写preHandle方法
 * @author 白豆五
 * @version 2022/12/27 
 * @since JDK8
 */
@Component
public class MyInterceptor implements HandlerInterceptor {
   

    // 处理器执行前被调用
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
   
        System.out.println("拦截器执行了~");
        return true;
    }
}

4、在com.baidou.config包下创建一个MvcConfig配置类：（注册拦截器）

方式1：继承WebMvcConfigurationSupport，但是默认静态资源路径不好使，必须重新映射。
方式2：实现WebMvcConfigurer接口，默认静态资源路径好使，还可以重新映射。

package com.baidou.config;

import com.baidou.handler.MyInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.*;

/**
 * springmvc配置类
 *
 * @author 白豆五
 * @version 2022/12/27 
 * @since JDK8
 */
@Configuration
public class MvcConfig implements WebMvcConfigurer {
   

    // 注入拦截器bean    
    @Autowired
    private MyInterceptor myInterceptor;

    // 配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
   
        //拦截/books/hello请求
        registry.addInterceptor(myInterceptor).addPathPatterns("/books/hello");
    }
}

5、测试访问：

2. 静态资源访问

方式1：使用springboot默认提供的静态资源访问路径

查看org.springframework.boot.autoconfigure.web.WebProperties类的源码，静态资源可以放到如下几个类路径的下面：（推荐使用/static/，见名知意）

/META-INF/resources/
/resources/
/static/
/public/

方式2：通过mvc的配置类放行静态资源

package com.baidou.config;

import com.baidou.handler.MyInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.*;

/**
 * springmvc配置类
 *
 * @author 白豆五
 * @version 2022/12/27
 * @since JDK8
 */
@Configuration
public class MvcConfig implements WebMvcConfigurer {
   

    @Autowired
    private MyInterceptor myInterceptor;

    // 配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
   
        registry.addInterceptor(myInterceptor).addPathPatterns("/books/hello");
    }

    // 静态资源放行
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
   
        registry.addResourceHandler("/ym/**").addResourceLocations("classpath:/ym/");
        registry.addResourceHandler("/html/**").addResourceLocations("classpath:/html/");
    }
    

    // 页面跳转
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
   
        registry.addViewController("/").setViewName("forward:books.html");
    }
}

访问resources/ym目录下的b.html文件：

七、SpringBoot整合MyBatis

前期准备：数据库的sql脚本

-- 创建ssm_db数据库并设置字符编码
CREATE DATABASE IF NOT EXISTS ssm_db CHARACTER SET utf8;

-- 使用ssm_db数据库
USE ssm_db;

-- 创建tbl_book表
CREATE TABLE tbl_book(
    id INT PRIMARY KEY AUTO_INCREMENT, -- 图书编号
    TYPE VARCHAR(100), -- 图书类型
    NAME VARCHAR(100), -- 图书名称
    description VARCHAR(100) -- 图书描述
);
-- 初始化数据
INSERT INTO tbl_book VALUES(NULL,'计算机理论','Spring实战 第5版','Spring入门经典教材，深入理解Spring原理技术内幕');
INSERT INTO tbl_book VALUES(NULL,'计算机理论','Spring 5核心原理与30个类手写实战','十年沉淀之作,手写Spring精华思想');
INSERT INTO tbl_book VALUES(NULL,'计算机理论','Spring 5设计模式','深入Spring源码剖析,Spring源码蕴含的10大设计模式');

1. 回顾Spring整合MyBatis

1、导入依赖：

  <dependencies>
      <!--spring-jdbc-->  
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>5.2.10.RELEASE</version>
      </dependency>
    <!--spring-jdbc-->  
    <dependency> 
          <groupId>org.springframework</groupId>  
          <artifactId>spring-jdbc</artifactId>  
          <version>5.2.10.RELEASE</version> 
    </dependency>  
    <!--mybatis-->  
    <dependency> 
          <groupId>org.mybatis</groupId>  
          <artifactId>mybatis</artifactId>  
          <version>3.5.6</version> 
    </dependency>  
    <!--spring与mybatis整合-->  
    <dependency> 
          <groupId>org.mybatis</groupId>  
          <artifactId>mybatis-spring</artifactId>  
          <version>1.3.0</version> 
    </dependency>  
    <!--mysql驱动-->  
    <dependency> 
          <groupId>mysql</groupId>  
          <artifactId>mysql-connector-java</artifactId>  
          <version>5.1.47</version> 
    </dependency>  
          <!--druid-->  
    <dependency> 
          <groupId>com.alibaba</groupId>  
          <artifactId>druid</artifactId>  
          <version>1.1.16</version> 
    </dependency>  
  </dependencies>

2、创建SpringConfig配置类：(导入JdbcConfig、MyBatisConfig)

package com.baidou.config;

//Spring配置类
@ComponentScan({
   "com.baidou.service"})          //扫描组件(service包下的Bean)
@PropertySource("classpath:jdbc.properties")    //加载类路径下的配置文件
@Import({
   JdbcConfig.class,MybatisConfig.class}) //导入配置类
@EnableTransactionManagement //开启spring事务管理注解
public class SpringConfig {
   
}

jdbc.properties:

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm_db?useSSL=false
jdbc.username=root
jdbc.password=123456

3、创建JDBCConfig配置类（定义数据源、加载propertie中数据库连接信息）

package com.baidou.config;


/**
 * JdbcConfig:加载数据库连接信息、定义数据源、Spring事务管理
 *
 * @author 白豆五
 * @version 2022/12/27
 * @since JDK8
 */
public class JdbcConfig {
   
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    // 配置数据库连接池
    @Bean
    public DataSource dataSource() {
   
        DruidDataSource ds = new DruidDataSource();
        // 初始化四个基本参数
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }

    // Spring事务管理需要的平台事务管理器对象
    @Bean
    public PlatformTransactionManager platformTransactionManager(DataSource ds){
   
        DataSourceTransactionManager dstm = new DataSourceTransactionManager();
        dstm.setDataSource(ds);
        return dstm;
    }
}

4、创建MyBatisConfig配置类（定义SqlSessionFactoryBean、定义映射配置）

package com.baidou.config;

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

/**
 *
 * MyBatis配置类(SqlSessionFactoryBean、mapper扫描配置)
 *
 * @author 白豆五
 * @version 2022/12/27
 * @since JDK8
 */
public class MybatisConfig {
   

    // 定义Bean，返回工厂对象SqlSessionFactoryBean
    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource ds) {
   
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(ds);
        return factoryBean;
    }

    // 定义Bean，返回MapperScannerConfigurer mapper扫描配置
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
   
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        // 扫描dao包下的接口，并生成对应的代理对象，交给spring容器管理
        msc.setBasePackage("com.baidou.dao");
        return msc;
    }
}

2. SpringBoot整合MyBatis

1、导入mybatis起步依赖和驱动

<!--springboot整合mybatis-->
<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>
    <!--SpringBoot锁定的是8版本,因为我们用mysql5.7所以不建议使用默认的-->
    <version>5.1.47</version>
</dependency>

2、在application.yml中设置数据源参数

# 数据源配置
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/ssm_db?useSSL=false&serverTimezone=UTC
    username: root
    password: 123456
    
# mybatis配置
mybatis:
  configuration:
    # 开启驼峰映射      关键字:camel
    map-underscore-to-camel-case: true
    #  标准sql输出      关键字:logimpl
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

注意：Mysql驱动8版本需要在url中配置时区。

3、定义实体类、数据层接口

package com.baidou.entity;

//实体类
@Data
public class Book {
   
    private Integer id;
    private String type;
    private String name;
    private String description;
}

在mapper接口上添加@Mapper注解，springboot底层会自动创建代理对象:

package com.baidou.mapper;

// 操作数据库的接口
@Mapper //将当前接口创建的代理对象放入spring容器中
public interface BookMapper {
   
    @Insert("insert into tbl_book values (null,#{type},#{name},#{description})")
    int save(Book book);

    @Update("update tbl_book set type=#{type},name=#{name},description=#{description} where id=#{id}")
    int update(Book book);

    @Delete("delete from tbl_book where id=#{id}")
    int deleteById(Integer id);

    @Select("select * from tbl_book")
    List<Book> selectAll();

    @Select("select * from  tbl_book where id=#{id}")
    Book selectById(Integer id);
}

4、测试类中注入mapper接口，测试功能：

package com.baidou.test;

import com.baidou.entity.Book;
import com.baidou.mapper.BookMapper;
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
public class BookMapperTest {
   

    @Autowired
    private BookMapper bookMapper;

    @Test
    public void testSelectAll(){
   
        List<Book> books = bookMapper.selectAll();
        for (Book book : books) {
   
            System.out.println(book);
        }
    }
}

3. 切换数据库连接池

常见的数据库连接池

C3P0，是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。C3P0是异步操作的，缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能。目前使用它的开源项目有hibernate，spring等。C3P0有自动回收空闲连接功能。
DBCP（DataBase Connection Pool），是java数据库连接池的一种，由Apache开发，通过数据库连接池，可以让程序自动管理数据库连接的释放和断开。
Proxool，是sourceforge下的一个开源项目，这个项目提供一个健壮、易用的连接池，最为关键的是这个连接池提供监控的功能，方便易用，便于发现连接泄漏的情况。
Druid（德鲁伊），是阿里的一个开源项目，整个项目由数据库连接池、插件框架和SQL解析器组成。该项目主要是为了扩展JDBC的一些限制，可以让程序员实现一些特殊的需求，比如向密钥服务请求凭证、统计SQL信息、SQL性能收集、SQL注入检查、SQL翻译等，程序员可以通过定制来实现自己需要的功能。
Hikari（嘿咔蕊），是一个高性能的 JDBC 连接池组件，SpringBoot默认使用的连接池。（由小日子过得不错研发）

3.1 切换Druid连接池

1、导入druid依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>

2、在application.yml配置文件中通过spring.datasource.type指定连接池的核心类DruidDataSource。

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource  # 切换数据源
    url: jdbc:mysql:///ssm_db?useSSL=false&serverTimezone=UTC
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: 123456

3.2 通过starter整合Druid

默认配置—>约定优于配置—>起步依赖starter

1、导入druid起步依赖：

<!--druid起步依赖-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.15</version>
</dependency>

2、在application.yml文件中配置druid：

# druid连接池配置起步依赖基础配置
spring:
  datasource:
    druid: # 可以不用写driver
      url: jdbc:mysql://localhost:3306/ssm_db?useSSL=false
      username: root
      password: 123456