Spring Boot入门

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

一、Spring和Spring Boot区别？

首先说下Spring，这个大家肯定不陌生，Spring框架为开发Java应用程序提供了全面的基础架构支持。它包含一些很好的功能，如依赖注入和开箱即用的模块，如：Spring JDBC 、Spring MVC 、Spring Security、 Spring AOP 、Spring ORM 、Spring Test，这些模块缩短应用程序的开发时间，提高了应用开发的效率例如，在Java Web开发的早期阶段，我们需要编写大量的代码来将记录插入到数据库中。但是通过使用Spring JDBC模块的JDBCTemplate，我们可以将操作简化为几行代码。
而tSpring Boot基本上是Spring框架的扩展，它消除了设置Spring应用程序所需的XML配置，为更快，更高效的开发生态系统铺平了道路。

二、springboot的优点在于哪些？为什么我们会用springboot

1.spring boot的优点

1.创建独立的spring应用
2.内嵌web服务器
3.自动starter依赖，简化构建配置
4.自动配置spring以及第三方功能
5.提供生产级别的监控，健康检查以及外部配置
6.无代码生成，无需编写xml

2.为什么我们会用boot

为什么我们会用spring boot，对于我来说我觉得优势在于用了spring boot不再有大量的xml配置，创建项目更快，且拥有spring所含功能，相比spring来说，没有什么理由不去用boot；
总的来说spring boot就是整合spring技术栈的一站式框架，且简化spring技术栈的快速开发脚手架

3.spring boot有哪些缺点

1.版本迭代快 需要关注变化
2.封装太深，内部原理复杂，不容易精通

三.spring boot的一些特性

1.依赖管理特性

使用了spring boot 我们只需要一个父项目 则不需要再声明一些第三方的版本号
例如：我们引入boot版本后

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.0.RELEASE</version>
  </parent>

我们点进去 dependencies

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

该依赖里配置很多三方依赖的版本 比如mysql、logback等 几乎声明了所有开发中常用的依赖版本号

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

1、见到很多 spring-boot-starter-* ： *就某种场景
2、只要引入starter，这个场景的所有常规需要的依赖我们都自动引入
3、SpringBoot所有支持的场景
4、见到的 *-spring-boot-starter： 第三方为我们提供的简化开发的场景启动器。
5、所有场景启动器最底层的依赖

可以修改默认版本号
1、查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。
2、在当前项目里面重写配置

    <properties>
        <mysql.version>5.1.43</mysql.version>
    </properties>

2.自动配置特性

● 自动配好Tomcat
○ 引入Tomcat依赖。
○ 配置Tomcat

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

● 自动配好SpringMVC
○ 引入SpringMVC全套组件
○ 自动配好SpringMVC常用组件（功能）
● 自动配好Web常见功能，如：字符编码问题
○ SpringBoot帮我们配置好了所有web开发的常见场景
● 默认的包结构
○ 主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
○ 无需以前的包扫描配置
○ 想要改变扫描路径，@SpringBootApplication(scanBasePackages=“com.xxx”)
■ 或者@ComponentScan 指定扫描路径

@SpringBootApplication
等同于
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(“com.xxx.boot”)整合

● 种配置拥有默认值
○ 默认配置最终都是映射到某个类上，如：MultipartProperties
○ 配置文件的值最终会绑定每个类上，这个类会在容器中创建对象
● 按需加载所有自动配置项
○ 非常多的starter
○ 引入了哪些场景这个场景的自动配置才会开启
○ SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面

3.容器功能

1.@Configuration
● 基本使用
● Full模式与Lite模式
○示例
○最佳实战
1）配置 类组件之间无依赖关系用Lite模式加速容器启动过程，减少判断
2）配置类组件之间有依赖关系，方法会被调用得到之前单实例组件，用Full模式
1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
2、配置类本身也是组件
3、proxyBeanMethods：代理bean的方法
Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
组件依赖必须使用Full模式默认。其他默认是否Lite模式
2.@Bean、@Component、@Controller、@Service、@Repository
作用都为注册组件到容器中
3.@ComponentScan、@Import
ComponentScan做的事情就是告诉Spring从哪里找到bean 包扫描
Import 给容器中自动创建出这该导入类型的组件、默认组件的名字就是全类名
例如：

@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
}

4.@Conditional
条件装配：满足Conditional指定的条件，则进行组件注入

在满足一定的条件下组件才生效
例如：
@ConditionalOnBean(Computer.class) 当容器中有Computer类型的组件下 该组件才会生效
5.原生配置文件导入
@ImportResource boot支持原生spring xml的注入 可将之前xml组件文件在boot项目中注入
6.@Qualifier
限定注入 当容器中有多种类型得对象时 应该加该注解指定对象得名称导入
7.配置绑定
@ConfigurationProperties
读取到properties文件中的内容，并且把它封装到JavaBean中，以供随时使用
例如：@ConfigurationProperties(prefix = “mycar”) 配置文件中mycar开始的能自动注入到java bean中
@EnableConfigurationProperties + @ConfigurationProperties
@EnableConfigurationProperties({XXXX.class}) 可以使@ConfigurationProperties注解生效 将该类型对象注册到容器中 当然@ConfigurationProperties + @Component是一样的效果

4.自动配置原理

点进去
@SpringBootApplication 进入

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication{}

该注解由三个注解合成
1）@SpringBootConfiguration
@Configuration。代表当前是一个配置类
2）@ComponentScan
指定扫描哪些，Spring注解；
3）@EnableAutoConfiguration
进入

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}

@AutoConfigurationPackage 自动配置包
@Import({AutoConfigurationImportSelector.class}) 给容器中导入一个AutoConfigurationImportSelector类型的组件 进入该类后

利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件

调用List configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
利用工厂加载 Map<String, List> loadSpringFactories(@Nullable ClassLoader classLoader)；得到所有的组件

从META-INF/spring.factories位置来加载一个文件。
默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories

虽然springboot会加载所有配置 但是并不是所有配置都生效 原因就是各个配置上加了很多条件注解
@ConditionalXXXXX 这是boot的按需开启自动配置项
当然我们也可以也可以更改这些配置 SpringBoot默认会在底层配好所有的组件。但是如果用户自己配置了以用户的优先
总结：
SpringBoot先加载所有的自动配置类 xxxxxAutoConfiguration，每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。xxxxProperties里面拿。xxxProperties和配置文件进行了绑定，生效的配置类就会给容器中装配很多组件，只要容器中有这些组件，相当于这些功能就有了
定制化配置
用户直接自己@Bean替换底层的组件
用户去看这个组件是获取的配置文件什么值就去修改

四.配置文件

1.支持yaml文件

语法：
key: value；kv之间有空格
大小写敏感
使用缩进表示层级关系
缩进不允许使用tab，只允许空格
缩进的空格数不重要，只要相同层级的元素左对齐即可
'#‘表示注释
字符串无需加引号，如果要加，’'与""表示字符串内容 会被 转义/不转义
数据类型：
支持字面量、对象、数组

五.Web开发

1.静态资源访问

1）静态资源目录
只要静态资源放在类路径下： /static (or /public or /resources or /META-INF/resources
启动项目都可以直接访问该静态资源
如何访问 ： 当前项目根路径/ + 静态资源名

原理： 静态映射/**。
请求进来，先去找Controller看能不能处理。不能处理的所有请求又都交给静态资源处理器。静态资源也找不到则响应404页面
2）静态资源访问前缀

spring:
  mvc:
    static-path-pattern: /res/**  
 （表示更改了静态资源访问路径前缀 访问时加上res/ 就去访问静态资源）
	
  resources:
    static-locations: [classpath:/xxx/]
  (表示告诉boot所有的静态资源在xxx文件下查找)

2.欢迎页支持

静态资源路径下 index.html
可以配置静态资源路径
但是不可以配置静态资源的访问前缀。否则导致 index.html不能被默认访问

spring:
#  mvc:
#    static-path-pattern: /res/**   这个会导致welcome page功能失效

3.自定义 Favicon

图标 就是在浏览器访问网站时候的网站图标
favicon.ico 放在静态资源目录下即可。访问前缀也不能配置 不然也会跟访问页面一样失效

4.静态资源配置原理

首先来到web项目配置类
● SpringBoot启动默认加载 xxxAutoConfiguration 类（自动配置类）
● SpringMVC功能的自动配置类 WebMvcAutoConfiguration，生效
该类种有一个内部类 如下图：

该类只有一个有参构造 当只有一个有参构造时 spring会从容器中获取该类型的组件注入
先了解一下有参构造器种参数内容
ResourceProperties resourceProperties；获取和spring.resources绑定的所有的值的对象
WebMvcProperties mvcProperties 获取和spring.mvc绑定的所有的值的对象
ListableBeanFactory beanFactory Spring的beanFactory
HttpMessageConverters 消息转换器 请求参数转换时使用
ResourceHandlerRegistrationCustomizer 资源处理器的自定义器。
DispatcherServletPath
ServletRegistrationBean 给应用注册Servlet、Filter…

该类导入了两个配置类 分别是WebMvcProperties.class, ResourceProperties.class
进入到两个配置类


配置文件的相关属性和xxx进行了绑定。
WebMvcProperties=spring.mvc、ResourceProperties=spring.resources
所以我们在yaml配置文件修改配置类的属性来达到我们想要的结果

比如说我们看下该自动配置类种添加静态资源管理的方法

!this.resourceProperties.isAddMappings()
进入这个方法的话 说明默认资源处理已禁用

public boolean isAddMappings() {
        return this.addMappings;
    }

来看看这个属性默认值

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 final ResourceProperties.Chain chain;
    private final ResourceProperties.Cache cache;

    public ResourceProperties() {
        this.staticLocations = CLASSPATH_RESOURCE_LOCATIONS;
        this.addMappings = true;
        this.chain = new ResourceProperties.Chain();
        this.cache = new ResourceProperties.Cache();
    }

    public String[] getStaticLocations() {
        return this.staticLocations;
    }

    public void setStaticLocations(String[] staticLocations) {
        this.staticLocations = this.appendSlashIfNecessary(staticLocations);
    }

addMappings 默认为true
这时我们可以在配置中关闭静态资源规则

spring:
  resources:
    add-mappings: false   禁用所有静态资源规则

这时我们也看到了staticLocations的默认值 这就说明了为什么springboot默认静态资源访问规则是这四个文件 我们仍可以在配置中修改该规则

5.请求参数处理

1.rest使用与原理
● @xxxMapping；
● Rest风格支持（使用HTTP请求方式动词来表示对资源的操作）
○ 以前：/getUser 获取用户 /deleteUser 删除用户 /editUser 修改用户 /saveUser 保存用户
○ 现在： /user GET-获取用户 DELETE-删除用户 PUT-修改用户 POST-保存用户
○ 核心Filter；HiddenHttpMethodFilter 这个是自动配置好的 但是必须得手动开启 才能使用rest风格

spring:
    mvc:
      hiddenmethod:
        filter:
          enabled: true   #开启页面表单的Rest功能

 用法： 表单method=post，需要加个参数 可以写在隐藏域 _method=put
SpringBoot中手动开启

Rest原理（表单提交要使用REST的时候）：
表单提交会带上_method=PUT
请求过来被HiddenHttpMethodFilter拦截
请求是否正常，并且是POST
获取到_method的值。
兼容以下请求；PUT.DELETE.PATCH
原生request（post），包装模式requesWrapper重写了getMethod方法，返回的是传入的值。
过滤器链放行的时候用wrapper。以后的方法调用getMethod是调用requesWrapper的。所以就能根据_method找到真正得方法调用



2.请求映射得原理
SpringMVC功能分析都从 org.springframework.web.servlet.DispatcherServlet-》doDispatch（）
先简单了解一下请求进来得处理流程

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

		try {
			ModelAndView mv = null;
			Exception dispatchException = null;

			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				// 找到当前请求使用哪个Handler（Controller的方法）处理
				mappedHandler = getHandler(processedRequest);
                
                //HandlerMapping：处理器映射。/xxx->>xxxx

容器中有很多HandlerMapping 其中RequestMappingHandlerMapping：保存了所有@RequestMapping 和handler的映射规则。所有的请求映射都在HandlerMapping中。
● SpringBoot自动配置欢迎页的 WelcomePageHandlerMapping 。访问 /能访问到index.html；
● SpringBoot自动配置了默认 的 RequestMappingHandlerMapping
● 请求进来，挨个尝试所有的HandlerMapping看是否有请求信息。
○ 如果有就找到这个请求对应的handler
○ 如果没有就是下一个 HandlerMapping
● 我们需要一些自定义的映射处理，我们也可以自己给容器中放HandlerMapping。自定义 HandlerMapping
3.普通参数与基本注解
@PathVariable 映射 URL 绑定的占位符
@RequestHeader 映射请求头数据
@ModelAttribute 会将客户端传递过来的参数按名称注入到指定对象中，并且会将这个对象自动加入ModelMap中，便于View层使用；
@RequestParam 最常用得 映射请求参数
@MatrixVariable 映射矩阵变量的值 url中多个变量用；分割
@CookieValue 用来获取Cookie中的值
@RequestBody 用来接收前端传递给后端的json字符串
4.复杂参数
Map、Model（map、model里面的数据会被放在request的请求域 request.setAttribute）、Errors/BindingResult、RedirectAttributes（ 重定向携带数据）、ServletResponse（response）、SessionStatus、UriComponentsBuilder、ServletUriComponentsBuilder
5.自定义类型参数
自己定义的对象 将前端传来的参数直接封装到对象中

6.数据响应与内容协商

返回值解析器：
● 1、返回值处理器判断是否支持这种类型返回值 supportsReturnType
● 2、返回值处理器调用 handleReturnValue 进行处理
● 3、RequestResponseBodyMethodProcessor 可以处理返回值标了@ResponseBody 注解的。
○ 1. 利用 MessageConverters 进行处理 将数据写为json
■ 1、内容协商（浏览器默认会以请求头的方式告诉服务器他能接受什么样的内容类型）
■ 2、服务器最终根据自己自身的能力，决定服务器能生产出什么样内容类型的数据，
■ 3、SpringMVC会挨个遍历所有容器底层的 HttpMessageConverter ，看谁能处理？
● 1、得到MappingJackson2HttpMessageConverter可以将对象写为json
● 2、利用MappingJackson2HttpMessageConverter将对象转为json再写出去。

SpringMVC到底支持哪些返回值：

ModelAndView
Model
View
ResponseEntity 
ResponseBodyEmitter
StreamingResponseBody
HttpEntity
HttpHeaders
Callable
DeferredResult
ListenableFuture
CompletionStage
WebAsyncTask
有 @ModelAttribute 且为对象类型的
@ResponseBody 注解 ---> RequestResponseBodyMethodProcessor；

HttpMessageConverter: 看是否支持将 此 Class类型的对象，转为MediaType类型的数据。
例子：Person对象转为JSON。或者 JSON转为Person

最终找到真正能转换的
MessageConverter->MappingJackson2HttpMessageConverter 把对象转为JSON（利用底层的jackson的objectMapper转换的）

内容协商：
根据客户端接收能力不同，返回不同媒体类型的数据。

只需要改变请求头中Accept字段。Http协议中规定的，告诉服务器本客户端可以接收的数据类型。
boot支持参数方式内容协商功能：
1.开启功能

spring:
    contentnegotiation:
      favor-parameter: true  #开启请求参数内容协商模式

2.发请求时候加上参数format 默认参数名称为format 默认只支持 json/xml两种格式 支持新的类型以及参数默认名称都可以自定义修改
参数方式和请求头中方式协商 优先以参数方式进行校验

协商原理：
● 1、判断当前响应头中是否已经有确定的媒体类型。MediaType
● 2、获取客户端（PostMan、浏览器）支持接收的内容类型。（获取客户端Accept请求头字段
● 3、遍历循环所有当前系统的 MessageConverter，看谁支持操作这个对象
● 4、找到支持操作该对象的converter，把converter支持的媒体类型统计出来。
● 5、客户端需要【application/xml】。服务端能力【10种、json、xml】
● 6、进行内容协商的最佳匹配媒体类型
● 7、用 支持 将对象转为 最佳匹配媒体类型 的converter。调用它进行转化 。

自定义 MessageConverter：

实现多协议数据兼容。json、xml、xxx
0、@ResponseBody 响应数据出去 调用 RequestResponseBodyMethodProcessor 处理
1、Processor 处理方法返回值。通过 MessageConverter 处理
2、所有 MessageConverter 合起来可以支持各种媒体类型数据的操作（读、写）
3、内容协商找到最终的 messageConverter；

请求时指定返回的类型为xxx 这时spring会为我们找到能处理的MessageConverter 处理完后返回媒体类型为xxx的请求

7.拦截器

spring的拦截器需要实现HandlerInterceptor 接口
该接口有三个方法
preHandle() 执行时间：目标方法执行之前
postHandle() 执行时间：目标方法执行完成以后
afterCompletion() 执行时间：页面渲染以后

配置拦截器：
1、编写一个拦截器实现HandlerInterceptor接口
2、拦截器注册到容器中（实现WebMvcConfigurer的addInterceptors）
3、指定拦截规则【如果是拦截所有，静态资源也会被拦截】

@Configuration
public class AdminWebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**")  //所有请求都被拦截包括静态资源
                .excludePathPatterns("/","/login","/css/**","/fonts/**","/images/**","/js/**"); //放行的请求
    }
}

拦截器的原理：
1、根据当前请求，找到HandlerExecutionChain【可以处理请求的handler以及handler的所有 拦截器】
2、先来顺序执行 所有拦截器的 preHandle方法
● 1、如果当前拦截器prehandler返回为true。则执行下一个拦截器的preHandle
● 2、如果当前拦截器返回为false。直接 倒序执行所有已经执行了的拦截器的 afterCompletion；
3、如果任何一个拦截器返回false。直接跳出不执行目标方法
4、所有拦截器都返回True。执行目标方法
5、倒序执行所有拦截器的postHandle方法。
6、前面的步骤有任何异常都会直接倒序触发 afterCompletion
7、页面成功渲染完成以后，也会倒序触发 afterCompletion
整个流程如图：

8.异常处理

1.默认规则
默认情况下，Spring Boot提供/error处理所有错误的映射
对于机器客户端，它将生成JSON响应，其中包含错误，HTTP状态和异常消息的详细信息。对于浏览器客户端，响应一个“ whitelabel”错误视图，以HTML格式呈现相同的数据

要对其进行自定义，添加View解析为error
error/下的4xx，5xx页面会被自动解析

2.定制错误处理逻辑
1）自定义错误页
○ error/404.html error/5xx.html；有精确的错误状态码页面就匹配精确，没有就找 4xx.html；如果都没有就触发白页
自定义异常处理器
spring底层有异常解析器 抛出的异常均由解析器去解析 能处理的异常则交相应的处理器去处理
例如
ExceptionHandlerExceptionResolver
ResponseStatusExceptionResolver
DefaultHandlerExceptionResolver
2）使用注解@ControllerAdvice（标注类上）+@ExceptionHandler（标注方法上）处理全局异常；（推荐使用）

底层是 ExceptionHandlerExceptionResolver（异常解析器 扫描所有标注ExceptionHandler的方法） 支持的 标注的方法则为一个异常处理器 当抛出异常该异常处理器能捕获 则捕获进行处理

3）@ResponseStatus+自定义异常 ；

我们自定义异常 在业务实现上抛出该异常 那么返回的错误信息则就是提示的信息
底层是 ResponseStatusExceptionResolver（异常解析器 该解析器扫描所有标注ResponseStatus的类） ，把responsestatus注解的信息底层调用 response.sendError(statusCode, resolvedReason)；tomcat发送的/error

3）Spring底层的异常，如 参数类型转换异常；DefaultHandlerExceptionResolver 处理框架底层的异常。
response.sendError(HttpServletResponse.SC_BAD_REQUEST, ex.getMessage());

自定义异常解析器
实现 HandlerExceptionResolver 处理异常；可以作为默认的全局异常处理规则 默认自定义解析器是最低优先级 可以加如@order指定最高优先级

3.异常处理自动配置原理
看下spring的自动配置类：ErrorMvcAutoConfiguration 自动配置异常处理规则

我们看到容器中的组件：类型：DefaultErrorAttributes -> 容器中id：errorAttributes
public class DefaultErrorAttributes implements ErrorAttributes, HandlerExceptionResolver
DefaultErrorAttributes：定义错误页面中可以包含哪些数据。
也看到了容器中的组件：类型：BasicErrorController --> 容器中id：basicErrorController（json+白页 适配响应）
处理默认 /error 路径的请求；页面响应 new ModelAndView(“error”, model)；

看到该controller专门处理/error的请求 这个请求路径可以修改

容器中的组件：类型：DefaultErrorViewResolver -> id：conventionErrorViewResolver
如果发生错误，会以HTTP的状态码 作为视图页地址（viewName），找到真正的页面
error/404、5xx.html
如果想要返回页面；就会找error视图【StaticView】。(默认是一个白页)

大致流程：
方法抛出异常 被捕获 捕获之后调用异常解析器进行处理 默认没有人处理 则接着抛出异常 最后请求结束时转发一个/error 请求
sprongmvc默认有一个controller专门处理/error请求
解析错误视图 根据状态码 /error/5XX.html 找到静态资源下下错误页面（默认全匹配 找） 返回返回响应

过滤器和拦截器的应用场景
拦截器应用场景：
拦截器本质上是面向切面编程（AOP），符合横切关注点的功能都可以放在拦截器中来实现，主要的应用场景包括：
登录验证，判断用户是否登录。
权限验证，判断用户是否有权限访问资源，如校验token
日志记录，记录请求操作日志（用户ip，访问时间等），以便统计请求访问量。
处理cookie、本地化、国际化、主题等。
性能监控，监控请求处理时长等。
通用行为：读取cookie得到用户信息并将用户对象放入请求，从而方便后续流程使用，还有如提取Locale、Theme信息等，只要是多个处理器都需要的即可使用拦截器实现）

过滤器应用场景
1）过滤敏感词汇（防止sql注入）
2）设置字符编码
3）URL级别的权限访问控制
4）压缩响应信息

六.数据访问

1.数据连接池

如果不配置任何连接池 spring底层默认用HikariDataSource

@Configuration(proxyBeanMethods = false)
	@Conditional(PooledDataSourceCondition.class)
	@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
	@Import({ DataSourceConfiguration.Hikari.class, DataSourceConfiguration.Tomcat.class,
			DataSourceConfiguration.Dbcp2.class, DataSourceConfiguration.OracleUcp.class,
			DataSourceConfiguration.Generic.class, DataSourceJmxConfiguration.class })
	protected static class PooledDataSourceConfiguration

相关配置

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db_xxx //连接地址
    username: root //用户名
    password: 123456	//密码
    driver-class-name: com.mysql.jdbc.Driver	//驱动

我们也常用Druid连接池
druid官方github地址：https://github.com/alibaba/druid
导入druid连接池方式
1.使用strarer启动器作为依赖，便可以实现纯yml配置（推荐使用）

 <!--数据源配置，纯yml配置，结合springboot的druid_start启动器实现-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

yml配置信息如下：

spring:
#数据源配置，纯yml配置
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/essm_dev?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
    username: essm_dev
    password: essm123456
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      # 初始化大小，最小，最大活跃数
      initial-size: 8
      min-idle: 8
      max-active: 20
      # 配置获取连接等待超时的时间，单位是毫秒
      max-wait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      time-between-eviction-runs-millis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      min-evictable-idle-time-millis: 30000
      max-evictable-idle-time-millis: 300000
      validation-query: SELECT 1
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      # 打开PSCache，并且指定每个连接上PSCache的大小
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      #配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙，slf4j（用log4j需要额外导入依赖，版本不同，这里也可以去掉slf4j）
      filters: stat,wall,slf4j
      # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
      connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
      # 配置监控服务器
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        reset-enable: true
        login-username: druid
        login-password: druid123

因为spring集成的druid自动导入的是spring:datasource:druid下 所以只需配置druid下各个配置就可实现自动注入
参考文档：https://github.com/alibaba/druid/tree/master/druid-spring-boot-starter

2.普通的阿里巴巴druid依赖

<!-- 加入阿里巴巴连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

注意：这种方式如果还按照之前的配置是不生效的 必须自定义配置类才能生效 这种方式所有配置可以直接卸载dataSource下 不用加druid

@Configuration
public class DruidConfig {
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druidDataSource() {
        return new DruidDataSource();
    }
 
    //后台监控:因为springboot内置了servlet容器，使用没有web.xml，可以用ServletRegistrationBean替代
    @Bean
    public ServletRegistrationBean statViewServlet() {
        ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
 
        //后台需要有人登陆，账号密码
        HashMap<String, String> initParameters = new HashMap<>();
 
        //增加配置
        initParameters.put("loginUsername", "admin");  //登陆参数是固定的
        initParameters.put("loginPassword", "123456");
 
        //允许谁可以访问
        initParameters.put("allow", "");
 
 
        bean.setInitParameters(initParameters);  //设置初始化参数
        return bean;
    }
 
}

2.整合MyBatis

导入依赖

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

配置模式
● 全局配置文件
● SqlSessionFactory: 自动配置好了
● SqlSession：自动配置了 SqlSessionTemplate 组合了SqlSession
● @Import(AutoConfiguredMapperScannerRegistrar.class）；
● Mapper： 只要我们写的操作MyBatis的接口标准了 @Mapper 就会被自动扫描进来

如何使用：
● 导入mybatis官方starter
● 编写mapper接口。标准@Mapper注解
● 编写sql映射文件并绑定mapper接口
● 在application.yaml中指定Mapper配置文件的位置，以及指定全局配置文件的信息 （建议；配置在mybatis.configuration）

1）直接在mapper中方法上加注解 @Select @update等等
2）使用xml映射（可以和注解模式混合使用）

MyBatis-Plus

 <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.1</version>
        </dependency>

自动配置
● MybatisPlusAutoConfiguration 配置类，MybatisPlusProperties 配置项绑定。mybatis-plus：xxx 就是对mybatis-plus的定制
● SqlSessionFactory 自动配置好。底层是容器中默认的数据源
● mapperLocations 自动配置好的。有默认值。classpath*:/mapper/**/*.xml；任意包的类路径下的所有mapper文件夹下任意路径下的所有xml都是sql映射文件。 建议以后sql映射文件，放在 mapper下
● 容器中也自动配置好了 SqlSessionTemplate
● @Mapper 标注的接口也会被自动扫描；建议直接 @MapperScan(“com.atguigu.admin.mapper”) 批量扫描就行

优点：
● 只需要我们的Mapper继承 BaseMapper 就可以拥有crud能力

七.其他功能

1.application-profile功能

● 默认配置文件 application.yaml；任何时候都会加载
● 指定环境配置文件 application-{dev}.yaml
● 激活指定环境
○ 配置文件激活
○ 命令行激活：java -jar xxx.jar --spring.profiles.active=prod --person.name=xx
■ 修改配置文件的任意值，命令行优先
● 默认配置与环境配置同时生效
● 同名配置项，profile配置优先

@Profile条件装配功能 可以作用到类上

@Configuration(proxyBeanMethods = false)
@Profile("production")
public class ProductionConfiguration {

    // ...

}

profile分组：

spring.profiles.group.production[0]=proddb
spring.profiles.group.production[1]=prodmq

使用：--spring.profiles.active=production  激活

2.外部化配置

springboot有加载配置文件的优先级 永远是序号大的优先 依次往上

1.Default properties (specified by setting SpringApplication.setDefaultProperties).
2. @PropertySource annotations on your @Configuration classes. Please note that such property sources are not added to the Environment until the application context is being refreshed. This is too late to configure certain properties such as logging.* and spring.main.* which are read before refresh begins.
3. Config data (such as application.properties files)
4. A RandomValuePropertySource that has properties only in random.*.
5. OS environment variables.
6. Java System properties (System.getProperties()).
7. JNDI attributes from java:comp/env.
8. ServletContext init parameters.
9. ServletConfig init parameters.
10. Properties from SPRING_APPLICATION_JSON (inline JSON embedded in an environment variable or system property).
11. Command line arguments.
12. properties attribute on your tests. Available on @SpringBootTest and the test annotations for testing a particular slice of your application.
13. @TestPropertySource annotations on your tests.
14. Devtools global settings properties in the $HOME/.config/spring-boot directory when devtools is active.

1、外部配置源
常用：Java属性文件、YAML文件、环境变量、命令行参数；

2、配置文件查找位置
(1) classpath 根路径
(2) classpath 根路径下config目录
(3) jar包当前目录
(4) jar包当前目录的config目录
(5) /config子目录的直接子目录
3、配置文件加载顺序：
当前jar包内部的application.properties和application.yml
当前jar包内部的application-{profile}.properties 和 application-{profile}.yml
引用的外部jar包的application.properties和application.yml
引用的外部jar包的application-{profile}.properties 和 application-{profile}.yml
4、指定环境优先，外部优先，后面的可以覆盖前面的同名配置项

---