SpringBoot--基本使用（配置、整合SpringMVC、Druid、Mybatis、基础特性）

一.介绍

但是无论使用XML、注解、Java配置类还是他们的混合用法，你都会觉得配置文件过于复杂和繁琐，让人头疼！

SpringBoot 帮我们简单、快速地创建一个独立的、生产级别的 Spring 应用（说明：SpringBoot底层是Spring），大多数 SpringBoot 应用只需要编写少量配置即可快速整合 Spring 平台以及第三方技术！

SpringBoot的主要目标是：

• 为所有 Spring 开发提供更快速、可广泛访问的入门体验。
• 开箱即用，设置合理的默认值，但是也可以根据需求进行适当的调整。
• 提供一系列大型项目通用的非功能性程序（如嵌入式服务器、安全性、指标、运行检查等）。
• 约定大于配置，基本不需要主动编写配置类、也不需要 XML 配置文件。

总结：简化开发，简化配置，简化整合，简化部署，简化监控，简化运维。

1.为什么依赖不需要写版本？

• 每个boot项目都有一个父项目spring-boot-starter-parent
• parent的父项目是spring-boot-dependencies
• 父项目 版本仲裁中心，把所有常见的jar的依赖版本都声明好了。
• 比如：mysql-connector-j

2.启动器(Starter)是何方神圣？

导入starter-web：导入了web开发场景

• 1、场景启动器导入了相关场景的所有依赖：starter-json、starter-tomcat、springmvc
• 2、每个场景启动器都引入了一个spring-boot-starter，核心场景启动器。
• 3、核心场景启动器引入了spring-boot-autoconfigure包。
• 4、spring-boot-autoconfigure里面囊括了所有场景的所有配置。
• 5、只要这个包下的所有类都能生效，那么相当于SpringBoot官方写好的整合功能就生效了。
• 6、SpringBoot默认却扫描不到 spring-boot-autoconfigure下写好的所有配置类。（这些配置类给我们做了整合操作），默认只扫描主程序所在的包。

3.@SpringBootApplication注解的功效？

​ @SpringBootApplication添加到启动类上，是一个组合注解，他的功效由具体的子注解实现！

@SpringBootConfiguration//1.配置类
@EnableAutoConfiguration//2.自动加载其他的配置类
@ComponentScan//3.扫描包
public @interface SpringBootApplication {}

@SpringBootApplication注解起到以下几个主要作用：

1.自动配置：@SpringBootApplication注解包含了@EnableAutoConfiguration注解，用于启用Spring Boot的自动配置机制。

• SpringBoot默认只能扫描自己主程序所在的包及其下面的子包，扫描不到 spring-boot-autoconfigure包中官方写好的配置类

• @EnableAutoConfiguration：SpringBoot 开启自动配置的核心。

• • 1. 是由@Import(AutoConfigurationImportSelector.class)提供功能：批量给容器中导入组件。
  • 2. SpringBoot启动会默认加载 152个配置类。
  • 3. 这152个配置类来自于spring-boot-autoconfigure下 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件指定的
  • 项目启动的时候利用 @Import 批量导入组件机制把 autoconfigure 包下的152 xxxxAutoConfiguration类导入进来（自动配置类）
  • 虽然导入了152个自动配置类

• 按需生效：

• • 并不是这152个自动配置类都能生效

  • 每一个自动配置类，都有条件注解@ConditionalOnxxx，只有条件成立，才能生效

那么多的自动配置类，必须在一定的条件下才能生效；也就是说，我们加载了这么多的配置类，但不是所有的都生效了。

xxxxAutoConfiguration自动配置类

• 1、给容器中使用@Bean 放一堆组件。
• 2、每个自动配置类都可能有这个注解@EnableConfigurationProperties(ServerProperties.class)，用来把配置文件中配的指定前缀的属性值封装到 xxxProperties属性类中
• 3、以Tomcat为例：把服务器的所有配置都是以server开头的。配置都封装到了属性类中。
• 4、给容器中放的所有组件的一些核心参数，都来自于xxxProperties。**xxxProperties**都是和配置文件绑定。
• 只需要改配置文件的值，核心组件的底层参数都能修改

核心流程：

1. 导入starter，就会导入autoconfigure包。
2. autoconfigure 包里面 有一个文件 META-INF/spring/**org.springframework.boot.autoconfigure.AutoConfiguration**.imports,里面指定的所有启动要加载的自动配置类
3. @EnableAutoConfiguration 会自动的把上面文件里面写的所有自动配置类都导入进来。xxxAutoConfiguration 是有条件注解进行按需加载
4. xxxAutoConfiguration给容器中导入一堆组件，组件都是从 xxxProperties中提取属性值
5. xxxProperties又是和配置文件进行了绑定

**效果：**导入starter、修改配置文件，就能修改底层行为。

2.组件扫描：@SpringBootApplication注解包含了@ComponentScan注解，用于自动扫描并加载应用程序中的组件，例如控制器（Controllers）、服务（Services）、存储库（Repositories）等。它默认会扫描@SpringBootApplication注解所在类的包及其子包中的组件，并将它们纳入Spring Boot应用程序的上下文中，使它们可被自动注入和使用。

//默认扫描的路径是主程序所在子包
@SpringBootApplication(scanBasePackages = "com.neu")//通过scanBasePackages修改默认扫描路径

3.声明配置类：@SpringBootApplication注解本身就是一个组合注解，它包含了@Configuration注解，将被标注的类声明为配置类。配置类可以包含Spring框架相关的配置、Bean定义，以及其他的自定义配置。通过@SpringBootApplication注解，开发者可以将配置类与启动类合并在一起，使得配置和启动可以同时发生。

总的来说，@SpringBootApplication注解的主要作用是简化Spring Boot应用程序的配置和启动过程。它自动配置应用程序、扫描并加载组件，并将配置和启动类合二为一，简化了开发者的工作量，提高了开发效率。

4.启动源码

//这是一个springboot应用
@SpringBootApplication
public class SpringbootdemoApplication {public static void main(String[] args) {//1.返回ioc容器ConfigurableApplicationContext run = SpringApplication.run(SpringbootdemoApplication.class, args);//2.接收ioc容器名称输出String[] names = run.getBeanDefinitionNames();for (String s :names) {System.out.println(s);}}
}

5.如何学好SpringBoot

整合redis：

• 选场景：spring-boot-starter-data-redis

  • 场景AutoConfiguration 就是这个场景的自动配置类

• 写配置：

  • 分析到这个场景的自动配置类开启了哪些属性绑定关系

    @EnableConfigurationProperties(RedisProperties.class)

    修改redis相关的配置

• 分析组件：

  • 分析到 RedisAutoConfiguration 给容器中放了 StringRedisTemplate

    给业务代码中自动装配 StringRedisTemplate

• 定制化

  • 修改配置文件

    自定义组件，自己给容器中放一个 StringRedisTemplate

二.SpringBoot3配置文件

2.1属性配置文件使用

1. 配置文件

   在 resource 文件夹下面新建 application.properties 配置文件

# application.properties 为统一配置文件
# 内部包含: 固定功能的key,自定义的key
# 此处的配置信息,我们都可以在程序中@Value等注解读取# 固定的key
# 启动端口号
server.port=80 # 自定义
spring.jdbc.datasource.driverClassName=com.mysql.cj.jdbc.driver
spring.jdbc.datasource.url=jdbc:mysql:///springboot_01
spring.jdbc.datasource.username=root
spring.jdbc.datasource.password=root

2. 读取配置文件

package com.atguigu.properties;import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;@Component
public class DataSourceProperties {@Value("${spring.jdbc.datasource.driverClassName}")private String driverClassName;@Value("${spring.jdbc.datasource.url}")private String url;@Value("${spring.jdbc.datasource.username}")private String username;@Value("${spring.jdbc.datasource.password}")private String password;

2.2 YAML配置文件使用

YAML格式相对于.properties文件具有更好的层次结构表示、自我描述性、注释支持、多行文本表示、复杂数据类型支持和更好的可读性。这些特点使YAML成为一种有力的配置文件格式，尤其适用于复杂的配置需求和人类可读的场景。然而，选择使用YAML还是.properties取决于实际需求和团队的偏好，简单的配置可以使用.properties，而复杂的配置可以选择YAML以获得更多的灵活性和可读性

1. yaml语法说明1. 数据结构用树形结构呈现，通过缩进来表示层级，2. 连续的项目（集合）通过减号 ” - ” 来表示3. 键值结构里面的key/value对用冒号 ” : ” 来分隔。4. YAML配置文件的扩展名是yaml 或 yml5. 例如：

# YAML配置文件示例
app_name: 我的应用程序
version: 1.0.0
author: 张三database:host: localhostport: 5432username: adminpassword: password123features:- 登录- 注册- 仪表盘settings:analytics: truetheme: dark

3. 配置文件

spring:jdbc:datasource:driverClassName: com.mysql.jdbc.Driverurl: jdbc:mysql:///springboot_02username: rootpassword: rootserver:port: 80

4. 读取配置文件

   读取方式和properties一致

package com.atguigu.properties;import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;@Component
public class DataSourceProperties {@Value("${spring.jdbc.datasource.driverClassName}")private String driverClassName;@Value("${spring.jdbc.datasource.url}")private String url;@Value("${spring.jdbc.datasource.username}")private String username;@Value("${spring.jdbc.datasource.password}")private String password;

2.3 YAML配置文件使用

1. yaml格式介绍

   YAML（YAML Ain’t Markup Language）是一种基于层次结构的数据序列化格式，旨在提供一种易读、人类友好的数据表示方式。

   与.properties文件相比，YAML格式有以下优势：

   1. 层次结构：YAML文件使用缩进和冒号来表示层次结构，使得数据之间的关系更加清晰和直观。这样可以更容易理解和维护复杂的配置，特别适用于深层次嵌套的配置情况。
   2. 自我描述性：YAML文件具有自我描述性，字段和值之间使用冒号分隔，并使用缩进表示层级关系。这使得配置文件更易于阅读和理解，并且可以减少冗余的标点符号和引号。
   3. 注释支持：YAML格式支持注释，可以在配置文件中添加说明性的注释，使配置更具可读性和可维护性。相比之下，.properties文件不支持注释，无法提供类似的解释和说明。
   4. 多行文本：YAML格式支持多行文本的表示，可以更方便地表示长文本或数据块。相比之下，.properties文件需要使用转义符或将长文本拆分为多行。
   5. 类型支持：YAML格式天然支持复杂的数据类型，如列表、映射等。这使得在配置文件中表示嵌套结构或数据集合更加容易，而不需要进行额外的解析或转换。
   6. 更好的可读性：由于YAML格式的特点，它更容易被人类读懂和解释。它减少了配置文件中需要的特殊字符和语法，让配置更加清晰明了，从而减少了错误和歧义。

   综上所述，YAML格式相对于.properties文件具有更好的层次结构表示、自我描述性、注释支持、多行文本表示、复杂数据类型支持和更好的可读性。这些特点使YAML成为一种有力的配置文件格式，尤其适用于复杂的配置需求和人类可读的场景。然而，选择使用YAML还是.properties取决于实际需求和团队的偏好，简单的配置可以使用.properties，而复杂的配置可以选择YAML以获得更多的灵活性和可读性

2. yaml语法说明

   1. 数据结构用树形结构呈现，通过缩进来表示层级，
   2. 连续的项目（集合）通过减号 ” - ” 来表示
   3. 键值结构里面的key/value对用冒号 ” : ” 来分隔。
   4. YAML配置文件的扩展名是yaml 或 yml
   5. 例如：

# YAML配置文件示例
app_name: 我的应用程序
version: 1.0.0
author: 张三database:host: localhostport: 5432username: adminpassword: password123features:- 登录- 注册- 仪表盘settings:analytics: truetheme: dark

3. 配置文件

spring:jdbc:datasource:driverClassName: com.mysql.jdbc.Driverurl: jdbc:mysql:///springboot_02username: rootpassword: rootserver:port: 80

4. 读取配置文件

   读取方式和properties一致

package com.atguigu.properties;import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;@Component
public class DataSourceProperties {@Value("${spring.jdbc.datasource.driverClassName}")private String driverClassName;@Value("${spring.jdbc.datasource.url}")private String url;@Value("${spring.jdbc.datasource.username}")private String username;@Value("${spring.jdbc.datasource.password}")private String password;// 生成get set 和 toString方法public String getDriverClassName() {return driverClassName;}public void setDriverClassName(String driverClassName) {this.driverClassName = driverClassName;}public String getUrl() {return url;}public void setUrl(String url) {this.url = url;}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;}@Overridepublic String toString() {return "DataSourceProperties{" +"driverClassName='" + driverClassName + '\'' +", url='" + url + '\'' +", username='" + username + '\'' +", password='" + password + '\'' +'}';}
}

2.3 批量配置文件注入

@ConfigurationProperties是SpringBoot提供的重要注解, 他可以将一些配置属性批量注入到bean对象。

1. 创建类，添加属性和注解

   在类上通过@ConfigurationProperties注解声明该类要读取属性配置

   prefix=“spring.jdbc.datasource” 读取属性文件中前缀为spring.jdbc.datasource的值。前缀和属性名称和配置文件中的key必须要保持一致才可以注入成功

package com.atguigu.properties;import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;@Component
@ConfigurationProperties(prefix = "spring.jdbc.datasource")
public class DataSourceConfigurationProperties {private String driverClassName;private String url;private String username;private String password;
}

2.4 多环境配置和使用

1. 需求

   在Spring Boot中，可以使用多环境配置来根据不同的运行环境（如开发、测试、生产）加载不同的配置。SpringBoot支持多环境配置让应用程序在不同的环境中使用不同的配置参数，例如数据库连接信息、日志级别、缓存配置等。

   以下是实现Spring Boot多环境配置的常见方法：

   1. 属性文件分离：将应用程序的配置参数分离到不同的属性文件中，每个环境对应一个属性文件。例如，可以创建application-dev.properties、application-prod.properties和application-test.properties等文件。在这些文件中，可以定义各自环境的配置参数，如数据库连接信息、端口号等。然后，在application.properties中通过spring.profiles.active属性指定当前使用的环境。Spring Boot会根据该属性来加载对应环境的属性文件，覆盖默认的配置。
   2. YAML配置文件：与属性文件类似，可以将配置参数分离到不同的YAML文件中，每个环境对应一个文件。例如，可以创建application-dev.yml、application-prod.yml和application-test.yml等文件。在这些文件中，可以使用YAML语法定义各自环境的配置参数。同样，通过spring.profiles.active属性指定当前的环境，Spring Boot会加载相应的YAML文件。
   3. 命令行参数(动态)：可以通过命令行参数来指定当前的环境。例如，可以使用--spring.profiles.active=dev来指定使用开发环境的配置。

   通过上述方法，Spring Boot会根据当前指定的环境来加载相应的配置文件或参数，从而实现多环境配置。这样可以简化在不同环境之间的配置切换，并且确保应用程序在不同环境中具有正确的配置。

2. 多环境配置（基于方式b实践）

   创建开发、测试、生产三个环境的配置文件

   application-dev.yml（开发）

spring:jdbc:datasource:driverClassName: com.mysql.cj.jdbc.Driverurl: jdbc:mysql:///devusername: rootpassword: root

application-test.yml（测试）

spring:jdbc:datasource:driverClassName: com.mysql.cj.jdbc.Driverurl: jdbc:mysql:///testusername: rootpassword: root

application-prod.yml（生产）

spring:jdbc:datasource:driverClassName: com.mysql.cj.jdbc.Driverurl: jdbc:mysql:///produsername: rootpassword: root

3. 环境激活

#在application.yaml
spring:profiles:active: dev

三.整合SpringMVC

3.1自动配置

1、整合web场景

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

2、引入了 autoconfigure功能

3、@EnableAutoConfiguration注解使用@Import(AutoConfigurationImportSelector.class)批量导入组件

4、加载 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件中配置的所有组件

5、所有自动配置类如下

org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration
org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration
====以下是响应式web场景和现在的没关系======
org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.ReactiveMultipartAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.WebSessionIdResolverAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.error.ErrorWebFluxAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.function.client.ClientHttpConnectorAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration
================以上没关系=================
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration

6、绑定了配置文件的一堆配置项

• 1、SpringMVC的所有配置 spring.mvc
• 2、Web场景通用配置 spring.web
• 3、文件上传配置 spring.servlet.multipart
• 4、服务器的配置 server: 比如：编码方式

3.2默认配置

默认配置：

1. 包含了 ContentNegotiatingViewResolver 和 BeanNameViewResolver 组件，方便视图解析
2. 默认的静态资源处理机制： 静态资源放在 static 文件夹下即可直接访问
3. 自动注册了 Converter,GenericConverter,Formatter组件，适配常见数据类型转换和格式化需求
4. 支持 HttpMessageConverters，可以方便返回json等数据类型
5. 注册 MessageCodesResolver，方便国际化及错误消息处理
6. 支持 静态 index.html
7. 自动使用ConfigurableWebBindingInitializer，实现消息处理、数据绑定、类型转化、数据校验等功能

重要：

• 如果想保持 boot mvc 的默认配置*，并且自定义更多的 mvc 配置，如：interceptors,formatters,view controllers\等。可以使用@Configuration**注解添加一个* WebMvcConfigurer 类型的配置类，并不要标注 @EnableWebMvc
• 如果想保持 boot mvc 的默认配置，但要自定义核心组件实例，比如：RequestMappingHandlerMapping,RequestMappingHandlerAdapter, 或ExceptionHandlerExceptionResolver，给容器中放一个 WebMvcRegistrations 组件即可
• 如果想全面接管 Spring MVC，@Configuration 标注一个配置类，并加上 @EnableWebMvc注解，实现 WebMvcConfigurer 接口

总结：

给容器中写一个配置类@Configuration实现 WebMvcConfigurer但是不要标注 **@EnableWebMvc**注解，实现手自一体的效果。

3.3 web相关配置

位置：application.yml

# web相关的配置
# https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties.server
server:# 端口号设置port: 80# 项目根路径servlet:context-path: /boot

当涉及Spring Boot的Web应用程序配置时，以下是五个重要的配置参数：

1. `server.port`: 指定应用程序的HTTP服务器端口号。默认情况下，Spring Boot使用8080作为默认端口。您可以通过在配置文件中设置`server.port`来更改端口号。
2. `server.servlet.context-path`: 设置应用程序的上下文路径。这是应用程序在URL中的基本路径。默认情况下，上下文路径为空。您可以通过在配置文件中设置`server.servlet.context-path`属性来指定自定义的上下文路径。
3. `spring.mvc.view.prefix`和`spring.mvc.view.suffix`: 这两个属性用于配置视图解析器的前缀和后缀。视图解析器用于解析控制器返回的视图名称，并将其映射到实际的视图页面。`spring.mvc.view.prefix`定义视图的前缀，`spring.mvc.view.suffix`定义视图的后缀。
4. `spring.resources.static-locations`: 配置静态资源的位置。静态资源可以是CSS、JavaScript、图像等。默认情况下，Spring Boot会将静态资源放在`classpath:/static`目录下。您可以通过在配置文件中设置`spring.resources.static-locations`属性来自定义静态资源的位置。
5. `spring.http.encoding.charset`和`spring.http.encoding.enabled`: 这两个属性用于配置HTTP请求和响应的字符编码。`spring.http.encoding.charset`定义字符编码的名称（例如UTF-8），`spring.http.encoding.enabled`用于启用或禁用字符编码的自动配置。

这些是在Spring Boot的配置文件中与Web应用程序相关的一些重要配置参数。根据您的需求，您可以在配置文件中设置这些参数来定制和配置您的Web应用程序

3.4 静态资源处理

WebMvcAutoConfiguration原理

1. 生效条件

@AutoConfiguration(after = { DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,ValidationAutoConfiguration.class }) //在这些自动配置之后
@ConditionalOnWebApplication(type = Type.SERVLET) //如果是web应用就生效，类型SERVLET、REACTIVE 响应式web
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class) //容器中没有这个Bean，才生效。默认就是没有
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)//优先级
@ImportRuntimeHints(WebResourcesRuntimeHints.class)
public class WebMvcAutoConfiguration { 
}

2.效果

1. 放了两个Filter：

2. 1. HiddenHttpMethodFilter；页面表单提交Rest请求（GET、POST、PUT、DELETE）
   2. FormContentFilter： 表单内容Filter，GET（数据放URL后面）、POST（数据放请求体）请求可以携带数据，PUT、DELETE 的请求体数据会被忽略

3. 给容器中放了WebMvcConfigurer组件；给SpringMVC添加各种定制功能

4. 1. 所有的功能最终会和配置文件进行绑定
   2. WebMvcProperties： spring.mvc配置文件
   3. WebProperties： spring.web配置文件

	@Configuration(proxyBeanMethods = false)@Import(EnableWebMvcConfiguration.class) //额外导入了其他配置@EnableConfigurationProperties({ WebMvcProperties.class, WebProperties.class })@Order(0)public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer, ServletContextAware{}

3.WebMvcConfigurer接口

提供了配置SpringMVC底层的所有组件入口

4.静态资源规则源码

@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {if (!this.resourceProperties.isAddMappings()) {logger.debug("Default resource handling disabled");return;}//1、addResourceHandler(registry, this.mvcProperties.getWebjarsPathPattern(),"classpath:/META-INF/resources/webjars/");addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (registration) -> {registration.addResourceLocations(this.resourceProperties.getStaticLocations());if (this.servletContext != null) {ServletContextResource resource = new ServletContextResource(this.servletContext, SERVLET_LOCATION);registration.addResourceLocations(resource);}});
}

1. 规则一：访问： /webjars/**路径就去 classpath:/META-INF/resources/webjars/下找资源.

2. maven 导入依赖

3. 规则二：访问： /**路径就去 静态资源默认的四个位置找资源

4. 1. classpath:/META-INF/resources/
   2. classpath:/resources/
   3. classpath:/static/
   4. classpath:/public/

5. 规则三：静态资源默认都有缓存规则的设置

6. 1. 所有缓存的设置，直接通过配置文件： spring.web
   2. cachePeriod： 缓存周期； 多久不用找服务器要新的。 默认没有，以s为单位
   3. cacheControl： HTTP缓存控制；https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Caching
   4. useLastModified：是否使用最后一次修改。配合HTTP Cache规则

如果浏览器访问了一个静态资源 index.js，如果服务这个资源没有发生变化，下次访问的时候就可以直接让浏览器用自己缓存中的东西，而不用给服务器发请求。

registration.setCachePeriod(getSeconds(this.resourceProperties.getCache().getPeriod()));
registration.setCacheControl(this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl());
registration.setUseLastModified(this.resourceProperties.getCache().isUseLastModified());

在WEB开发中我们需要引入一些静态资源 , 例如 : HTML , CSS , JS , 图片等 , 如果是普通的项目静态资源可以放在项目的webapp目录下。现在使用Spring Boot做开发 , 项目中没有webapp目录 , 我们的项目是一个jar工程，那么就没有webapp，我们的静态资源该放哪里呢？

1. 默认路径

   在springboot中就定义了静态资源的默认查找路径：

package org.springframework.boot.autoconfigure.web;
//..................
public static class Resources {private static final String[] CLASSPATH_RESOURCE_LOCATIONS = new String[]{"classpath:/META-INF/resources/", "classpath:/resources/", "classpath:/static/", "classpath:/public/"};private String[] staticLocations;private boolean addMappings;private boolean customized;private final Chain chain;private final Cache cache;public Resources() {this.staticLocations = CLASSPATH_RESOURCE_LOCATIONS;this.addMappings = true;this.customized = false;this.chain = new Chain();this.cache = new Cache();}
//...........        

默认的静态资源路径为：

· classpath:/META-INF/resources/

· classpath:/resources/

· classpath:/static/

· classpath:/public/

我们只要静态资源放在这些目录中任何一个，SpringMVC都会帮我们处理。 我们习惯会把静态资源放在classpath:/static/ 目录下。在resources目录下创建index.html文件

打开浏览器输入 : http://localhost:8080/index.html

2. 覆盖路径

# web相关的配置
# https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties.server
server:# 端口号设置port: 80# 项目根路径servlet:context-path: /boot
spring:web:resources:# 配置静态资源地址,如果设置,会覆盖默认值static-locations: classpath:/webapp

访问地址：http://localhost/boot/login.html

3.4 自定义拦截器(SpringMVC配置)

1. 拦截器声明

package com.atguigu.interceptor;import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;@Component
public class MyInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {System.out.println("MyInterceptor拦截器的preHandle方法执行....");return true;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {System.out.println("MyInterceptor拦截器的postHandle方法执行....");}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {System.out.println("MyInterceptor拦截器的afterCompletion方法执行....");}
}

2. 拦截器配置

   正常使用配置类，只要保证，配置类要在启动类的同包或者子包方可生效！

package com.atguigu.config;import com.atguigu.interceptor.MyInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;@Configuration
public class MvcConfig implements WebMvcConfigurer {@Autowiredprivate MyInterceptor myInterceptor ;/*** /**  拦截当前目录及子目录下的所有路径 /user/**   /user/findAll  /user/order/findAll* /*   拦截当前目录下的以及子路径   /user/*     /user/findAll* @param registry*/@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(myInterceptor).addPathPatterns("/**");}
}

3.5内容协商

一套系统适配多端数据返回

默认规则

1. SpringBoot 多端内容适配。

2. 基于请求头内容协商：（默认开启）

3. 客户端向服务端发送请求，携带HTTP标准的Accept请求头。

4. Accept: application/json、text/xml、text/yaml
   2. 服务端根据客户端请求头期望的数据类型进行动态返回

5. 基于请求参数内容协商：（需要开启）

6. 发送请求 GET /projects/spring-boot?format=json
   2. 匹配到 @GetMapping(“/projects/spring-boot”)
   3. 根据参数协商，优先返回 json 类型数据【需要开启参数匹配设置】
   4. 发送请求 GET /projects/spring-boot?format=xml,优先返回 xml 类型数据

3.6错误处理

错误处理的自动配置都在ErrorMvcAutoConfiguration中，两大核心机制：

• 1. SpringBoot 会自适应****处理错误，响应页面或**JSON数据
• 2. SpringMVC的错误处理机制依然保留，MVC处理不了，才会交给boot进行处理

• 发生错误以后，转发给/error路径，SpringBoot在底层写好一个 BasicErrorController的组件，专门处理这个请求

	@RequestMapping(produces = MediaType.TEXT_HTML_VALUE) //返回HTMLpublic ModelAndView errorHtml(HttpServletRequest request, HttpServletResponse response) {HttpStatus status = getStatus(request);Map<String, Object> model = Collections.unmodifiableMap(getErrorAttributes(request, getErrorAttributeOptions(request, MediaType.TEXT_HTML)));response.setStatus(status.value());ModelAndView modelAndView = resolveErrorView(request, response, status, model);return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);}@RequestMapping  //返回 ResponseEntity, JSONpublic ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {HttpStatus status = getStatus(request);if (status == HttpStatus.NO_CONTENT) {return new ResponseEntity<>(status);}Map<String, Object> body = getErrorAttributes(request, getErrorAttributeOptions(request, MediaType.ALL));return new ResponseEntity<>(body, status);}

• 错误页面是这么解析到的

//1、解析错误的自定义视图地址
ModelAndView modelAndView = resolveErrorView(request, response, status, model);
//2、如果解析不到错误页面的地址，默认的错误页就是 error
return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);

容器中专门有一个错误视图解析器

@Bean
@ConditionalOnBean(DispatcherServlet.class)
@ConditionalOnMissingBean(ErrorViewResolver.class)
DefaultErrorViewResolver conventionErrorViewResolver() {return new DefaultErrorViewResolver(this.applicationContext, this.resources);
}

SpringBoot解析自定义错误页的默认规则

	@Overridepublic ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status, Map<String, Object> model) {ModelAndView modelAndView = resolve(String.valueOf(status.value()), model);if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);}return modelAndView;}private ModelAndView resolve(String viewName, Map<String, Object> model) {String errorViewName = "error/" + viewName;TemplateAvailabilityProvider provider = this.templateAvailabilityProviders.getProvider(errorViewName,this.applicationContext);if (provider != null) {return new ModelAndView(errorViewName, model);}return resolveResource(errorViewName, model);}private ModelAndView resolveResource(String viewName, Map<String, Object> model) {for (String location : this.resources.getStaticLocations()) {try {Resource resource = this.applicationContext.getResource(location);resource = resource.createRelative(viewName + ".html");if (resource.exists()) {return new ModelAndView(new HtmlResourceView(resource), model);}}catch (Exception ex) {}}return null;}

容器中有一个默认的名为 error 的 view； 提供了默认白页功能

@Bean(name = "error")
@ConditionalOnMissingBean(name = "error")
public View defaultErrorView() {return this.defaultErrorView;
}

封装了JSON格式的错误信息

	@Bean@ConditionalOnMissingBean(value = ErrorAttributes.class, search = SearchStrategy.CURRENT)public DefaultErrorAttributes errorAttributes() {return new DefaultErrorAttributes();}

规则：

1. 解析一个错误页

2. 1. 如果发生了500、404、503、403 这些错误
3. 1. 1. 如果有模板引擎，默认在 classpath:/templates/error/精确码.html
      2. 如果没有模板引擎，在静态资源文件夹下找 精确码.html
4. 2. 如果匹配不到精确码.html这些精确的错误页，就去找5xx.html，4xx.html模糊匹配
5. 1. 1. 如果有模板引擎，默认在 classpath:/templates/error/5xx.html
      2. 如果没有模板引擎，在静态资源文件夹下找 5xx.html

6. 如果模板引擎路径templates下有 error.html页面，就直接渲染

最佳实战

• 前后分离

• • 后台发生的所有错误，@ControllerAdvice + @ExceptionHandler进行统一异常处理。

• 服务端页面渲染

• • 不可预知的一些，HTTP码表示的服务器或客户端错误
• • • 给classpath:/templates/error/下面，放常用精确的错误码页面。500.html，404.html
    • 给classpath:/templates/error/下面，放通用模糊匹配的错误码页面。 5xx.html，4xx.html
• • 发生业务错误
• • • 核心业务，每一种错误，都应该代码控制，跳转到自己定制的错误页。
    • 通用业务，classpath:/templates/error.html页面，显示错误信息。

页面，JSON，可用的Model数据如下

3.7嵌入容器

Servlet容器：管理、运行Servlet组件（Servlet、Filter、Listener）的环境，一般指服务器

1.自动配置原理

• SpringBoot 默认嵌入Tomcat作为Servlet容器。
• 自动配置类是ServletWebServerFactoryAutoConfiguration，EmbeddedWebServerFactoryCustomizerAutoConfiguration
• 自动配置类开始分析功能。xxxxAutoConfiguration

@AutoConfiguration(after = {SslAutoConfiguration.class}
)
@AutoConfigureOrder(Integer.MIN_VALUE)
@ConditionalOnClass({ServletRequest.class})
@ConditionalOnWebApplication(type = Type.SERVLET
)
@EnableConfigurationProperties({ServerProperties.class})
@Import({BeanPostProcessorsRegistrar.class, ServletWebServerFactoryConfiguration.EmbeddedTomcat.class, ServletWebServerFactoryConfiguration.EmbeddedJetty.class, ServletWebServerFactoryConfiguration.EmbeddedUndertow.class})
public class ServletWebServerFactoryAutoConfiguration {

1. ServletWebServerFactoryAutoConfiguration 自动配置了嵌入式容器场景

2. 绑定了ServerProperties配置类，所有和服务器有关的配置 server

3. ServletWebServerFactoryAutoConfiguration 导入了 嵌入式的三大服务器 Tomcat、Jetty、Undertow

4. 1. 导入 Tomcat、Jetty、Undertow 都有条件注解。系统中有这个类才行（也就是导了包）
   2. 默认 Tomcat配置生效。给容器中放 TomcatServletWebServerFactory
   3. 都给容器中 ServletWebServerFactory放了一个 web服务器工厂（造web服务器的）
   4. web服务器工厂 都有一个功能，getWebServer获取web服务器
   5. TomcatServletWebServerFactory 创建了 tomcat。

5. ServletWebServerFactory 什么时候会创建 webServer出来。

6. ServletWebServerApplicationContextioc容器，启动的时候会调用创建web服务器

7. Spring**容器刷新（启动）**的时候，会预留一个时机，刷新子容器。onRefresh()

8. refresh() 容器刷新 十二大步的刷新子容器会调用 onRefresh()`；

	@Overrideprotected void onRefresh() {super.onRefresh();try {createWebServer();}catch (Throwable ex) {throw new ApplicationContextException("Unable to start web server", ex);}}

Web场景的Spring容器启动，在onRefresh的时候，会调用创建web服务器的方法。

Web服务器的创建是通过WebServerFactory搞定的。容器中又会根据导了什么包条件注解，启动相关的 服务器配置，默认EmbeddedTomcat会给容器中放一个 TomcatServletWebServerFactory，导致项目启动，自动创建出Tomcat。

2.最佳实践

用法：

• 修改server下的相关配置就可以修改服务器参数
• 通过给容器中放一个**ServletWebServerFactory**，来禁用掉SpringBoot默认放的服务器工厂，实现自定义嵌入任意服务器。

四.整合Druid数据源

1. 引入依赖

<?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><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.0.5</version></parent><groupId>com.atguigu</groupId><artifactId>springboot-starter-druid-04</artifactId><version>1.0-SNAPSHOT</version><properties><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><!--  web开发的场景启动器 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!-- 数据库相关配置启动器 jdbctemplate 事务相关--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency><!-- druid启动器的依赖  --><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-3-starter</artifactId><version>1.2.18</version></dependency><!-- 驱动类--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.28</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.28</version></dependency></dependencies><!--    SpringBoot应用打包插件--><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>

2. 启动类

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

3. 配置文件编写

   添加druid连接池的基本配置

spring:datasource:# 连接池类型 type: com.alibaba.druid.pool.DruidDataSource# Druid的其他属性配置 springboot3整合情况下,数据库连接信息必须在Druid属性下!druid:url: jdbc:mysql://localhost:3306/day01username: rootpassword: rootdriver-class-name: com.mysql.cj.jdbc.Driver# 初始化时建立物理连接的个数initial-size: 5# 连接池的最小空闲数量min-idle: 5# 连接池最大连接数量max-active: 20# 获取连接时最大等待时间，单位毫秒max-wait: 60000# 申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。test-while-idle: true# 既作为检测的间隔时间又作为testWhileIdel执行的依据time-between-eviction-runs-millis: 60000# 销毁线程时检测当前连接的最后活动时间和当前时间差大于该值时，关闭当前连接(配置连接在池中的最小生存时间)min-evictable-idle-time-millis: 30000# 用来检测数据库连接是否有效的sql 必须是一个查询语句(oracle中为 select 1 from dual)validation-query: select 1# 申请连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为truetest-on-borrow: false# 归还连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为truetest-on-return: false# 是否缓存preparedStatement, 也就是PSCache,PSCache对支持游标的数据库性能提升巨大，比如说oracle,在mysql下建议关闭。pool-prepared-statements: false# 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100max-pool-prepared-statement-per-connection-size: -1# 合并多个DruidDataSource的监控数据use-global-data-source-stat: truelogging:level:root: debug

五.整合Mybatis

5.1自动配置

SSM整合总结：

1. 导入 mybatis-spring-boot-starter

2. 配置数据源信息

3. 配置mybatis的**mapper接口扫描**与**xml映射文件扫描**

4. 编写bean，mapper，生成xml，编写sql 进行crud。事务等操作依然和Spring中用法一样

5. 效果：

6. 1. 所有sql写在xml中
   2. 所有mybatis配置写在application.properties下面

• jdbc场景的自动配置：

• • mybatis-spring-boot-starter导入 spring-boot-starter-jdbc，jdbc是操作数据库的场景
  • Jdbc场景的几个自动配置
• • • org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
• • • • 数据源的自动配置
      • 所有和数据源有关的配置都绑定在DataSourceProperties
      • 默认使用 HikariDataSource
• • • org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration
• • • • 给容器中放了JdbcTemplate操作数据库
• • • org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration
    • org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration
• • • • 基于XA二阶提交协议的分布式事务数据源
• • • org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration

• 支持事务

• 具有的底层能力：数据源、JdbcTemplate、事务

• MyBatisAutoConfiguration：配置了MyBatis的整合流程

• • mybatis-spring-boot-starter导入 mybatis-spring-boot-autoconfigure（mybatis的自动配置包），
  • 默认加载两个自动配置类：

• org.mybatis.spring.boot.autoconfigure.MybatisLanguageDriverAutoConfiguration

  • org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration
• • 必须在数据源配置好之后才配置
    • 给容器中SqlSessionFactory组件。创建和数据库的一次会话
    • 给容器中SqlSessionTemplate组件。操作数据库

• MyBatis的所有配置绑定在MybatisProperties

  • 每个Mapper接口的代理对象是怎么创建放到容器中。详见**@MapperScan**原理：
• • 利用@Import(MapperScannerRegistrar.class)批量给容器中注册组件。解析指定的包路径里面的每一个类，为每一个Mapper接口类，创建Bean定义信息，注册到容器中。

如何分析哪个场景导入以后，开启了哪些自动配置类。

找：classpath:/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件中配置的所有值，就是要开启的自动配置类，但是每个类可能有条件注解，基于条件注解判断哪个自动配置类生效了。

1. 导入依赖

<parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.0.5</version>
</parent><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>3.0.1</version></dependency><!-- 数据库相关配置启动器 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency><!-- druid启动器的依赖  --><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-3-starter</artifactId><version>1.2.18</version></dependency><!-- 驱动类--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.28</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.28</version></dependency></dependencies>

2. 配置文件

server:port: 80servlet:context-path: /
spring:datasource:type: com.alibaba.druid.pool.DruidDataSourcedruid:url: jdbc:mysql:///day01username: rootpassword: rootdriver-class-name: com.mysql.cj.jdbc.Drivermybatis:configuration:  # setting配置auto-mapping-behavior: fullmap-underscore-to-camel-case: truelog-impl: org.apache.ibatis.logging.slf4j.Slf4jImpltype-aliases-package: com.neu.pojo # 配置别名mapper-locations: classpath:/mapper/*.xml # mapperxml位置

5.3 声明式事务整合配置

依赖导入:

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

注：SpringBoot项目会自动配置一个 DataSourceTransactionManager，所以我们只需在方法（或者类）加上 @Transactional 注解，就自动纳入 Spring 的事务管理了

@Transactional
public void update(){User user = new User();user.setId(1);user.setPassword("test2");user.setAccount("test2");userMapper.update(user);
}

5.4 AOP整合配置

依赖导入:

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

直接使用aop注解即可:

@Component
@Aspect
public class LogAdvice {@Before("execution(* com..service.*.*(..))")public void before(JoinPoint joinPoint){System.out.println("LogAdvice.before");System.out.println("joinPoint = " + joinPoint);}}

六.基础特性

6.1SpringApplication

1.自定义banner

在banner转换网站生成banner文件

在application.propreties配置

spring.banner.location=banner.txt

2.自定义SpringApplication

import org.springframework.boot.Banner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class MyApplication {public static void main(String[] args) {//1.自定义SpringApplication底层配置SpringApplication application = new SpringApplication(MyApplication.class);//调整参数（配置文件的优先级高于程序）application.setBannerMode(Banner.Mode.OFF);//配置application，相当于在application.propreties中修改//2.运行application.run(args);}}

3.FluentBuilder API启动

new SpringApplicationBuilder().sources(Parent.class).child(Application.class).bannerMode(Banner.Mode.OFF).run(args);

6.2profile

环境隔离能力；快速切换开发、测试、生产环境

步骤：

1. 标识环境：指定哪些组件、配置在哪个环境生效
2. 切换环境：这个环境对应的所有组件和配置就应该生效

1. 使用

指定环境

• Spring Profiles 提供一种隔离配置的方式，使其仅在特定环境生效；
• 任何@Component, @Configuration 或 @ConfigurationProperties 可以使用 @Profile 标记，来指定何时被加载。【容器中的组件都可以被 @Profile标记】

环境激活

1. 配置激活指定环境； 配置文件

spring.profiles.active=production,hsqldb

1. 也可以使用命令行激活。–spring.profiles.active=dev,hsqldb

2. 还可以配置默认环境； 不标注@Profile 的组件永远都存在。

3. 1. 以前默认环境叫default
   2. spring.profiles.default=test

4. 推荐使用激活方式激活指定环境

环境包含

注意：

1. spring.profiles.active 和spring.profiles.default 只能用到 无 profile 的文件中，如果在application-dev.yaml中编写就是无效的
2. 也可以额外添加生效文件，而不是激活替换。比如：

spring.profiles.include[0]=common
spring.profiles.include[1]=local

最佳实战：

• 生效的环境 = 激活的环境/默认环境 + 包含的环境

• 项目里面这么用

• • 基础的配置mybatis、log、xxx：写到包含环境中
  • 需要动态切换变化的 db、redis：写到激活的环境中

2. Profile 分组

创建prod组，指定包含db和mq配置

spring.profiles.group.prod[0]=db
spring.profiles.group.prod[1]=mq

使用–spring.profiles.active=prod ，就会激活prod，db，mq配置文件

3. Profile 配置文件

• application-{profile}.properties可以作为指定环境的配置文件。

• 激活这个环境，配置就会生效。最终生效的所有配置是

• • application.properties：主配置文件，任意时候都生效
  • application-{profile}.properties：指定环境配置文件，激活指定环境生效

profile优先级 > application

6.3外部化配置

场景：线上应用如何快速修改配置，并应用最新配置？

• SpringBoot 使用 配置优先级 + 外部配置 简化配置更新、简化运维。
• 只需要给jar应用所在的文件夹放一个application.properties最新配置文件，重启项目就能自动应用最新配置

1.优先级配置

结论：配置可以写到很多位置，常见的优先级顺序：

• 命令行> 配置文件> springapplication配置

结论：包外 > 包内； 同级情况：profile配置 > application配置

所有参数均可由命令行传入，使用--参数项=参数值，将会被添加到环境变量中，并优先于配置文件。

比如java -jar app.jar --name="Spring",可以使用@Value("${name}")获取

启动端口？：命令行 > 9001 > 8001 > 9000 > 8000

2.外部配置

SpringBoot 应用启动时会自动寻找application.properties和application.yaml位置，进行加载。顺序如下：（后面覆盖前面）

1. 类路径: 内部

2. 类根路径

3. 类下/config包

4. 当前路径（项目所在的位置）

5. 1. 当前路径
   2. 当前下/config子目录
   3. /config目录的直接子目录

规律：最外层的最优先。

• 命令行 > 所有
• 包外 > 包内
• config目录 > 根目录
• profile > application

配置不同就都生效（互补），配置相同高优先级覆盖低优先级

3.导入配置

使用spring.config.import可以导入额外配置

spring.config.import=my.properties
my.property=value

无论以上写法的先后顺序，my.properties的值总是优先于直接在文件中编写的my.property。

4. 属性占位符

配置文件中可以使用 ${name:default}形式取出之前配置过的值。

app.name=MyApp
app.description=${app.name} is a Spring Boot application written by ${username:Unknown}

6.4单元测试

SpringBoot 提供一系列测试工具集及注解方便我们进行测试。
spring-boot-test提供核心测试能力，spring-boot-test-autoconfigure 提供测试的一些自动配置。
我们只需要导入spring-boot-starter-test 即可整合测试

组件测试

直接@Autowired容器中的组件进行测试

注解

• **@Test 😗*表示方法是测试方法。但是与JUnit4的@Test不同，他的职责非常单一不能声明任何属性，拓展的测试将会由Jupiter提供额外测试
• **@ParameterizedTest 😗*表示方法是参数化测试，下方会有详细介绍
• **@RepeatedTest 😗*表示方法可重复执行，下方会有详细介绍
• **@DisplayName 😗*为测试类或者测试方法设置展示名称
• **@BeforeEach 😗*表示在每个单元测试之前执行
• **@AfterEach 😗*表示在每个单元测试之后执行
• **@BeforeAll 😗*表示在所有单元测试之前执行
• **@AfterAll 😗*表示在所有单元测试之后执行
• **@Tag 😗*表示单元测试类别，类似于JUnit4中的@Categories
• **@Disabled 😗*表示测试类或测试方法不执行，类似于JUnit4中的@Ignore
• **@Timeout 😗*表示测试方法运行如果超过了指定时间将会返回错误
• **@ExtendWith 😗*为测试类或测试方法提供扩展类引用

import static org.junit.jupiter.api.Assertions.fail;
import static org.junit.jupiter.api.Assumptions.assumeTrue;import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;class StandardTests {@BeforeAllstatic void initAll() {}@BeforeEachvoid init() {}@DisplayName("😱")@Testvoid succeedingTest() {}@Testvoid failingTest() {fail("a failing test");}@Test@Disabled("for demonstration purposes")void skippedTest() {// not executed}@Testvoid abortedTest() {assumeTrue("abc".contains("Z"));fail("test should have been aborted");}@AfterEachvoid tearDown() {}@AfterAllstatic void tearDownAll() {}}