Spring-Boot入门（雷丰阳）
spring启动原理分析
- 一、spring-Boot启动依赖
-
- 1、pom文件分析
-
- 1️⃣ maven插件
- 2️⃣ Spring-Boot父项目
- 3️⃣ spring-boot-starter启动器
- 2、主程序类，主入口类
- 3、使用Spring Initializer快速创建Spring Boot项目
- 二、spring-Boot配置文件
-
- 1、配置文件
- 2、YAML语法：
-
- 1️⃣ 基本语法
- 2️⃣ 值的写法
-
- 字面量：普通的值（数字，字符串，布尔）
- 对象、Map（属性和值）（键值对）；
- 数组（List、Set）；
- 3、 配置文件值注入
-
- 1️⃣properties配置文件在idea中默认utf-8可能会乱码
- 2️⃣ @Value获取值和@ConfigurationProperties获取值比较
- 3️⃣ 配置文件注入数据校验
- 4️⃣ @PropertySource&@ImportResource
- 4、配置文件占位符
-
- 1、随机数
- 2、占位符获取之前配置的值，如果没有可以是用：指定默认值
- 5、Profile
-
- 1️⃣ 多Profile文件
- 2️⃣ yml支持多文档块方式
- 3️⃣ 激活指定profile
- 6、配置文件加载位置
- 7、外部配置加载顺序
- 8、自动配置原理
-
- 1️⃣ 自动配置原理：
- 2️⃣ 细节
-
- 1、@Conditional派生注解（Spring注解版原生的@Conditional作用）
- 三、日志
-
- 1、日志框架
- 2、SLF4j使用
-
- 1、如何在系统中使用SLF4j
- 2、遗留问题
- 3、SpringBoot日志关系
- 4、日志使用
-
- 1、默认配置
- 2、指定配置
- 5、切换日志框架
- 四、Web开发
-
- 1、简介
- 2、SpringBoot对静态资源的映射规则；
- 3、模板引擎
-
- 1、引入Thymeleaf
- 2、Thymeleaf使用&语法
- 3、语法规则
- 4、SpringMVC自动配置
-
- 1）、SpringMVC auto Configruation
- 2）、扩展SpringMVC
- 5、如何修改SpringBoot的默认配置
-
- 1）、SpringBoot在自动配置很多组件的时候，先看容器中有没有用户自己配置的（@Bean、@Component）如果有就用用户配置的，如果没有，才自动配置；如果有些组件可以多个（ViewResolver）将用户配置的和自己的默认的组合起来；
- 2）、在SpringBoot中会有非常多的xxxxConfigurer帮助我们配置；
一、spring-Boot启动依赖
1、pom文件分析
1️⃣ maven插件
<build>
<plugins>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
plugin>
plugins>
build>
将这个应用打成jar包，直接使用java -jar的命令进行执行；
为什么java -jar 能运行jar文件
java命令 ： java -jar 和 java -cp
2️⃣ Spring-Boot父项目
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.3.1.RELEASEversion>
<relativePath/>
parent>
他的父项目
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-dependenciesartifactId>
<version>2.3.1.RELEASEversion>
parent>
他来真正管理Spring Boot应用里面所有依赖版本；
Spring Boot的版本仲裁中心；
以后我们导入依赖默认是不需要写版本；（没有在dependencies里面管理的依赖自然需要申明版本号）
3️⃣ spring-boot-starter启动器
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
spring-boot-starter-web：
spring-boot-starter：spring-boot场景启动器；帮助我们导入web模块正常运行所依赖的组件；
Spring Boot将所有的功能场景都提取出来，做成一个个的starters（启动器），只需要在项目里面引入这些starter相关场景所有依赖都会倒入进来。要用什么功能就导入什么场景的启动器。
2、主程序类，主入口类
/**
* @SpringBootApplication 来标注一个主程序类，说明这是一个spring Boot应用
*/
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
//Spring 应用启动起来
SpringApplication.run(DemoApplication.class, args);
}
}
@SpringBootApplication： Spring Boot应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main方法来启动SpringBoot应用；
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
excludeFilters = {@Filter(
type = FilterType.CUSTOM,
classes = {TypeExcludeFilter.class}
), @Filter(
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
@SpringBootConfiguration：spring Boot的配置类;
标注在某个类上，表示这是一个Spring Boot的配置类；
@Configuration：配置类上来标注这个注解；
配置类-------配置文件；配置类也是容器中的一个组件；@Component
@EnableAutoConfiguration:开启自动配置功能；
以前我们需要配置的东西，Spring Boot帮我们自动配置；@EnableAutoConfiguration告诉SpringBoot开启自动配置功能；这样自动配置才能生效；
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
***************************************************************
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
@AutoConfigurationPackage：自动配置包
@Import({AutoConfigurationPackages.Registrar.class});
Spring的底层注解@Import，给容器中导入一个组件；导入的组件由AutoConfigurationPackages.Registrar.class
将主配置类（@SpringBootApplication）的类所在包及下面所有的子包里面的组件扫描到Spring容器；
@Import({AutoConfigurationImportSelector.class})；
给容器中导入组件？
AutoConfigurationImportSelector:导入那些组件的选择器；
将所有需要导入的组件以全类名的方式返回；这些组件就会被添加到容器中；
会给容器导入非常多的自动配置类（xxxAutoConfiguration）;就是给容器中导入这个场景需要的所有组件，并配置好这些组件；
有了自动配置类，免去了我们手动编写配置注入功能组件等工作；
List configurations = SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, beanClassLoader);
Spring Boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，帮助我们进行自动配置工作；以前我们需要自己配置的东西，自动配置类都帮我们；
J2EE的整体整合解决方案和自动配置都在spring-boot-autoconfigure-2.3.0.RELEASE.jar
3、使用Spring Initializer快速创建Spring Boot项目
默认生成的Spring Boot项目；
- 主程序已经生成好了，我们只需要我们自己的逻辑
- resouces文件夹中目录结构
- static:保存所有的静态资源；js css images；
- templates：保存所有的模板页面；（Spring Boot默认使用嵌入式的Tomcat，默认不支持JSP页面）；可以使用模板引擎（freemarker、thymeleaf）；
- application.properties:Spring Boot应用配置文件；可以修改一些默认值；
二、spring-Boot配置文件
1、配置文件
SpringBoot使用一个全局的配置文件，配置名称是固定的；
- application.properties
- application.yml（.yaml）
配置文件的作用：修改SpringBoot自动配置的默认值；SpringBoot在底层都给我们自动配置好；
标记语言：
以前的配置文件，打多都是使用xxx.xml文件；
YAML：以 数据为中心，比json、xml更加适合做配置文件
YAML：配置例子
server:
port: 8081
XML:
<server>
<port>8081<port>
server>
2、YAML语法：
1️⃣ 基本语法
k:(空格)v ：表示一对键值对（空格必须有）；
以空格的缩减来控制层级关系;只要是左对齐的一列数据，都是同一个层级
server:
port: 8081
path: /hello
属性和值大小写敏感；
2️⃣ 值的写法
字面量：普通的值（数字，字符串，布尔）
name: "zhangsan \n lisi"
************************
name: 'zhangsan \n lisi'
k: v:字面直接写；
字符串默认不用上单引号或者双引号；
" ":双引号;不会转义字符串里面的特殊字符；特殊字符作为本身想表示的意思;输出：zhangsan 换行 lisi
’ ':单引号;会转义字符串里面的特殊字符；特殊字符最终只是一个普通的字符串数据；输出：zhangsan \n lisi
对象、Map（属性和值）（键值对）；
k: v 在下一行写对象的属性和值关系;注意缩进
friends:
lastName: zhangsan
age: 20
行内写法：
friends: {lastName: zhangsan,age: 18}
数组（List、Set）；
用- 值表示数组中的一个元素
pet:
- cat
- dog
- pig
行内写法
pet: [cat,dog,pig]
3、 配置文件值注入
1️⃣properties配置文件在idea中默认utf-8可能会乱码
2️⃣ @Value获取值和@ConfigurationProperties获取值比较
| @ConfigurationProperties | @Value | |
|---|---|---|
| 功能 | 批量注入配置文件中的属性 | 一个一个指定 |
| 松散绑定（松散语法） | 支持 | 不支持 |
| SpEL | 不支持 | 支持 |
| JSR303数据校验 | 支持 | 不支持 |
配置文件properties还是yaml他们都能获取到值；
如果说，我们只在业务逻辑中获取一下配置文件的某项值，使用@Value
* @Controller
* @ResponseBody (如果是对象转为json数据)
* 上面两个相加等同于 @RestController
*/
@RestController
//@Controller
public class HelloworldController {
@Value( "${person.last-name}" )
private String name;
@RequestMapping("/hello")
// @ResponseBody //@ResponseBody的作用其实是
// 将java对象转为json格式的数据。
public String hello(){
return "helloworld, "+name;
}
}
如果说，我们专门编写了一个javaBean来和配置文件进行映射，我们就可以直接使用@ConfigurationProperties
3️⃣ 配置文件注入数据校验
@Component
@ConfigurationProperties(prefix = "person")
@Data
@Validated
public class Person {
// 在@ConfigurationProperties下lastName必须是邮箱格式
@Email
private String lastName;
private Integer age;
private Boolean boss;
private Date birth;
private Map<String,Object> maps;
private List<Object> lists;
private Dog dog;
}
@Validated， @Email
4️⃣ @PropertySource&@ImportResource
@PropertySource: 加载指定的配置文件；
/**
* @author Created by huyh
* @create on 2020/6/19.
* 将配置文件中配置的每一个属性的值，映射到这个组件中
* @ConfigurationProperties 告诉SpringBoot将本类中的所有属性和配置文件中相关的属性进行配置绑定；
* prefix = "person" 配置文件中那个下面的所有属性进行一一映射
*
* 只有这个组件是容器中的组件（@Component），才能容器提供的@ConfigurationProperties功能；
* @ConfigurationProperties(prefix = "person")默认从全局配置文件周年获取值；
*
*
*/
@PropertySource( value = {"classpath:person.properties"})
@Component
@ConfigurationProperties(prefix = "person")
@Data
//@Validated
public class Person {
/**
*
*
*/
// 在@ConfigurationProperties下lastName必须是邮箱格式
// @Email
// @Value( "${person.last-name}" )
private String lastName;
// @Value( "#{1*2}" )
private Integer age;
// @Value( "true" )
private Boolean boss;
// @Value( "2020/6/19" )
private Date birth;
private Map<String,Object> maps;
private List<Object> lists;
private Dog dog;
}
@ImportResource：导入Spring的配置文件，让配置文件里面的内容生效；
Spring Boot里面没有Spring的配置文件，我们自己编写的配置文件，不会自动识别；想让Spring配置文件生效，加载进来；@ImportResource标注在一个配置类上
@ImportResource(locations = {"classpath:beans.xml"})
导入Spring的配置文件让其生效
不来编写Spring的配置文件
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="helloService" class="com.example.demo.service.HelloService">bean>
beans>
SpringBoot推荐给容器中添加组件的方式，推荐使用全注解方式；
1、配置类====Spring配置文件
2、使用@Bean给容器中添加组件
/**
* @author Created by huyh
* @create on 2020/6/19.
*
* @Configuration 指明当前类是一个配置类；就是来替代之前的spring配置文件
*
* 在配置文件中用4、配置文件占位符
1、随机数
${random.value}、${random.int}、${random.long}
${random.int(10)}、${random.int[1024,66665]}
2、占位符获取之前配置的值，如果没有可以是用：指定默认值
person.last-name=张三${random.uuid}
#person.age=19
person.age=${random.int}
person.birth=2020/6/19
person.boss=false
person.dog.name=${person.hello:hello}_小狗
person.dog.age=2
5、Profile
1️⃣ 多Profile文件
我们在主配置文件编写的时候，文件名可以是application-{proifile}.properties/yml
默认使用application.properties的配置；
2️⃣ yml支持多文档块方式
server:
port: 8081
#spring:
# profiles:
# active: dev
---
server:
port: 8082
spring:
profiles: dev
---
server:
port: 8083
spring:
profiles: prod #指定配置那个环境
---
3️⃣ 激活指定profile
1、在配置文件中指定 spring.profiles.active=dev
2、命令行：
java -jar spring-demo-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev
可以直接在测试的时候，配合传入命令行参数
3、虚拟机参数；
-Dspring.profiles.active=dev
6、配置文件加载位置
springboot启动会扫描以下位置的application.properties或application.yml文件作为Spring Boot的默认配置文件
-file:./config/
-file:./
-classpath:/config/
-classpath:/
优先级由高到底，高优先级的配置会覆盖低优先级的配置；
SpringBoot会从这四个位置全部加载主配置文件；互不配置
我们还可以通过spring.config.location来改变默认的配置文件位置
项目打包以后，我们可以使用命令参数的形式，启动项目的时候来指定配置文件的新位置；指定配置文件和默认加载的这些配置文件共同起作用形成互补配置；
java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=D:/application.properties --server.servlet.context-path=/abc
7、外部配置加载顺序
SpringBoot也可以从以下位置加载顺序；优先级从高到低；高优先级的配置覆盖低优先级的配置，所有的配置会形成互补配置
1.命令行参数
java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --server.port=8087 --server.servlet.context-path=/abc
多个配置用空格分开；–配置项=值
2.来自java:comp/env的JNDI属性
3.Java系统属性（System.getProperties()）
4.操作系统环境变量
5.RandomValuePropertySource配置的random.*属性值
由jar包外向jar包内进行寻找；
优先加载带profile
6.jar包外部的application-{profile}.properties或application.yml{带spring.profile}配置文件
7.jar包内部的application-{profile}.properties或application.yml{带spring.profile}配置文件
再来加载不带profile
8.jar包外部的application.properties或application.yml{不带spring.profile}
9.jar内外部的application.properties或application.yml{不带spring.profile}
10.@Configuration注解上的@PropertySource
11.通过SpringApplication.setDefaultProperties指定的默认属性
所有支持的配置加载来源；
参考官方文档
8、自动配置原理
配置文件到底能写什么？怎么写？自动配置原理；
配置文件能配置的属性参照
1️⃣ 自动配置原理：
1）、SpringBoot启动的时候加载主配置类，开启自动配置功能==@EnableAutoConfiguration==
2）、@EnableAutoConfiguration作用
- 利用AutoConfigurationImportSelector给容器中导入一些组件？
- 可以利用selectImports()方法的内容；
- List configurations = getCandidateConfigurations(annotationMetadata, attributes);获取候选的配置
SpringFactoriesLoader.loadFactoryNames();
扫描所有jar包类路径下，META-INF/spring.factories
把扫描的这些文件的内容包装成properties
从properties中获取到EnableAutoConfiguration.class类(类名)对应的值，然后把他们加入到容器中
EnableAutoConfiguration.class
将类路径下META-INF/spring.factories里面配置的所有EnableAutoConfiguration的值加入到容器中；
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcTransactionManagerAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.ElasticsearchRestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration,\
org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration,\
org.springframework.boot.autoconfigure.influx.InfluxDbAutoConfiguration,\
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration,\
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
org.springframework.boot.autoconfigure.availability.ApplicationAvailabilityAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration,\
org.springframework.boot.autoconfigure.r2dbc.R2dbcAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketRequesterAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketServerAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketStrategiesAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration,\
org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration,\
org.springframework.boot.autoconfigure.security.rsocket.RSocketSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.saml2.Saml2RelyingPartyAutoConfiguration,\
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.servlet.OAuth2ClientAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.reactive.ReactiveOAuth2ClientAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.resource.servlet.OAuth2ResourceServerAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.resource.reactive.ReactiveOAuth2ResourceServerAutoConfiguration,\
org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration,\
org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration,\
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,\
org.springframework.boot.autoconfigure.websocket.reactive.WebSocketReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.client.WebServiceTemplateAutoConfiguration
每个这样的xxxAutoConfiguration类都是容器中的一个组件，都加入到容器中；用他们来做自动配置；
3）、每个一个自动配置类进行自动配置功能；
4）、以HttpEncodingAutoConfiguration为例解释自动配置原理；
@Configuration(proxyBeanMethods = false)//表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件
@EnableConfigurationProperties(ServerProperties.class)//启动指定的类@ConfigurationProperties功能；将配置文件中对应的值和ServerProperties绑定起来；并把ServerProperties加入到Ioc容器中
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)//Spring底层@Conditional注解(Spring注解版)，根据不同的条件，如果满足指定的条件，整个配置类里面就会生效；判断当前应用是否是web应用，如果是，当前配置类生效
@ConditionalOnClass(CharacterEncodingFilter.class)//判断当前项目有没有这个类 CharacterEncodingFilter；SpringMVC中解决乱码的过滤器；
@ConditionalOnProperty(prefix = "server.servlet.encoding", value = "enabled", matchIfMissing = true)
//判断配置文件中是否存在某个配置 server.servlet.encoding.enabled;如果不存在，判断也是成立的；
//即使我们配置文件中不配置server.servlet.encoding.enabled=true，也是默认生效的；
public class HttpEncodingAutoConfiguration {
//他已经和Springboot的配置文件映射了
private final Encoding properties;
//只有一个有参构造器的情况下，参数的值会从容器中拿
public HttpEncodingAutoConfiguration(ServerProperties properties) {
this.properties = properties.getServlet().getEncoding();
}
@Bean //给容器中添加一个组件，这个组件的某些值需要从properties中获取
@ConditionalOnMissingBean //判断容器中没有这个组件
public CharacterEncodingFilter characterEncodingFilter() {
CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
filter.setEncoding(this.properties.getCharset().name());
filter.setForceRequestEncoding(this.properties.shouldForce(Encoding.Type.REQUEST));
filter.setForceResponseEncoding(this.properties.shouldForce(Encoding.Type.RESPONSE));
return filter;
}
根据当前不同的条件判断，决定这个配置类是否生效？
一旦这个配置类生效；这个配置类就会给容器中添加各种组件；这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的；
5）、所有在配置文件中能配置的属性都是xxxProperties类中封闭着；配置文件能配置什么就可以参照某个功能对应的这个属性类
@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)//从配置文件中获取指定的值和bean的属性进行绑定
public class ServerProperties {
精髓：
1）、SpringBoot启动会加载大量的自动配置类
2）、我们看我们需要的功能有没有SpringBoot默认写好的自动配置类；
3）、我们再来看这个自动配置类中到底配置了那些组件；（只要我们要用的组件有，我们就不需要再来配置了）
4）、给容器自动配置类添加组件的时候，会从properties类中获取某些属性，我们就可以在配置文件中指定这些属性的值；
xxxxAutoConfiguration:自动配置类；
给容器添加组件
xxxxProperties:封装配置文件中相关属性；
2️⃣ 细节
1、@Conditional派生注解（Spring注解版原生的@Conditional作用）
作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置配置里面的所有内容才生效；
| @Conditional扩展注解 | 作用（判断是否满足当前指定条件） |
|---|---|
| @ConditionalOnJava | 系统的java版本是否符合要求 |
| @ConditionalOnBean | 容器中存在指定Bean |
| @ConditionalOnMissingBean | 容器中不存在指定Bean |
| @ConditionalOnMissingBean | 容器中不存在指定Bean； |
| @ConditionalOnExpression | 满足SpEL表达式指定 |
| @ConditionalOnClass | 系统中有指定的类 |
| @ConditionalOnMissingClass | 系统中没有指定的类 |
| @ConditionalOnSingleCandidate | 容器中只有一个指定的Bean，或者这个Bean是首选Bean |
| @ConditionalOnProperty | 系统中指定的属性是否有指定的值 |
| @ConditionalOnResource | 类路径下是否存在指定资源文件 |
| @ConditionalOnWebApplication | 当前是web环境 |
| @ConditionalOnNotWebApplication | 当前不是web环境 |
| @ConditionalOnJndi | JNDI存在指定项 |
自动配置类必须在一定的条件下才能生效；
我们怎么知道那些配置类生效；
我们可以通过启用debug=true属性；来让控制台打印自动配置报告；这样我们就可以很方便的知道那些自动配置类生效；
============================
CONDITIONS EVALUATION REPORT
============================
Positive matches:（自动配置类启动的）
-----------------
AopAutoConfiguration matched:
- @ConditionalOnProperty (spring.aop.auto=true) matched (OnPropertyCondition)
AopAutoConfiguration.ClassProxyingConfiguration matched:
- @ConditionalOnMissingClass did not find unwanted class 'org.aspectj.weaver.Advice' (OnClassCondition)
- @ConditionalOnProperty (spring.aop.proxy-target-class=true) matched (OnPropertyCondition)
DispatcherServletAutoConfiguration matched:
- @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet' (OnClassCondition)
- found 'session' scope (OnWebApplicationCondition)
Negative matches:（没有启动的，没有匹配成功的自动配置类）
-----------------
ActiveMQAutoConfiguration:
Did not match:
- @ConditionalOnClass did not find required class 'javax.jms.ConnectionFactory' (OnClassCondition)
AopAutoConfiguration.AspectJAutoProxyingConfiguration:
Did not match:
- @ConditionalOnClass did not find required class 'org.aspectj.weaver.Advice' (OnClassCondition)
ArtemisAutoConfiguration:
Did not match:
- @ConditionalOnClass did not find required class 'javax.jms.ConnectionFactory' (OnClassCondition)
三、日志
1、日志框架
小张；开发一个大型系统；
1、System.out.println("");将关键数据打印在控制台；去掉？写在一个文件？
2、框架来记录系统的一些运行时信息；日志框架；zhanglogging.jar;
3、高大上的几个功能？异步模式？自动归档？xxxx?zhanglogging-good.jar;
4、将以前框架卸下来？换上新的框架，重新修改之前的API；zhanglogging-prefect.jar
5、JDBC ---- 数据库驱动；
写了一个的接口层；日志门面（日志的一个抽象层）；logging-abstract.jar;给项目中导入具体的日志实现就行了；我们之前的日志框架都是实现的抽象层；
市面上的日志框架；
JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j…
| 日志门面（日志的抽象层） | 日志实现 |
|---|---|
SLF4j（Simple Logging Facade for Java） |
Log4j JUL(java.util.logging) Log4j2 Logback |
左边选一个门面（抽象层）、右边来选择一个实现；
日志门面：SLF4j
日志实现：Logback;
SpringBoot:底层是Spring框架，Spring框架默认是用JCL；
SpringBoot选用:SLF4j和Logback；
2、SLF4j使用
1、如何在系统中使用SLF4j
以后开发的时候，日志记录方法的调用，不应该来直接调用日志的实现类，而是调用日志抽象层里面的方法；给系统里面导入slf4j的jar和logback的实现jar
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class HelloWorld {
public static void main(String[] args) {
Logger logger = LoggerFactory.getLogger(HelloWorld.class);
logger.info("Hello World");
}
}
图示：
每一个日志的实现框架都有自己的配置文件。使用slf4j以后，*配置文件还是做成日志实现框架自己本身的配置文件；
2、遗留问题
如何让系统中所有的日志都统一到slf4j;
1、将系统中其他日志先排除出去；
2、用中间包来替换原有的日志框架；
3、我们导入slf4j其他的实现；
3、SpringBoot日志关系
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starterartifactId>
dependency>
SpringBoot使用它来做日志功能；
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-loggingartifactId>
dependency>
底层依赖关系
总结：
1）、SpringBoot底层也是使用slf4j+logback的方式进行日志记录
2）、SpringBoot也把其他的日志都替换成了slf4j；
3）、中间替换包？
在这里插入代码片
4）、如果我们要引入其他框架？一定要把这个框架的默认日志依赖移除掉？
Spring框架用的是commons-logging；
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-coreartifactId>
<exclusions>
<exclusion>
<groupId>commons-logginggroupId>
<artifactId>commons-loggingartifactId>
exclusion>
exclusions>
dependency>
SpringBoot能自动适配所有的日志，而且底层使用slf4j+logback的方式记录日志，引入其他框架的时候，只需要把这个框架依赖的日志框架排除掉；
4、日志使用
1、默认配置
Logger logger=LoggerFactory.getLogger(getClass());
//日志的级别；
//由低到高 trace
//可以调整输出的日志级别;日志就只会在这个级别及以后的高级别生效
@Test
public void contextLoads() {
logger.trace("这个是teace日志");
logger.debug("这个是debug日志");
// SpringBoot默认给我们使用的是Info级别的,没有指定级别的就用SpringBoot默认规定的级别；root级别
logger.info("这个是info日志");
logger.warn("这个是warn日志");
logger.error("这个是error日志");
}
日志输出格式：
%d表示日期时间，
%thread表示线程名
%-5level：级别从左显示5个字符宽度
%logger{50} 表示logger名字最长50个字符，否则按照句点分割。
%msg ：日志消息，
%n是换行符
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} -%msg%n
SpringBoot修改日志的默认配置
#SpringBootdebug模式
#debug=true
logging.level.com.example=trace
#logging.file.path=
#不指定路径在当前项目下生成springboot.log日志
#可以指定完整的路径；
#logging.file.name=H:/springboot.log
#logging.file.name=springboot.log
logging.file.path=/spring/log
#在控制台输出的日志的格式
logging.pattern.console=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} -%msg%n
logging.pattern.file=%d{yyyy-MM-dd} === [%thread] %-5level === %logger{50} -%msg%n
logback.xml
| logging.file.name | logging.file.path | Example | Description |
|---|---|---|---|
| (none) | (none) | 只在控制台输出 | |
| 指定文件名 | （none） | my.log | 输出日志到my.log文件 |
| （none） | 指定目录 | /var/log | 输出到指定目录的spring.log文件中 |
2、指定配置
给类路径下放上每个日志框架自己的配置文件即可；SpringBoot就不使用他默认配置的了
Depending on your logging system, the following files are loaded:
| Logging System | Customization |
|---|---|
| Logback | logback-spring.xml, logback-spring.groovy, logback.xml, or logback.groovy |
| Log4j2 | log4j2-spring.xml or log4j2.xml |
| JDK (Java Util Logging) | logging.properties |
如果可能，我们建议您使用-spring日志配置的变体(例如，logback-spring.xml而不是logback.xml)。如果使用标准配置位置，Spring无法完全控制日志初始化
logback.xml：直接就被日志框架识别了；
logback-spring.xml：日志框架就不直接加载日志的配置项，由SpringBoot解析日志配置，可以使用SpringBoot的高级Profile功能
<springProfile name="staging">
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] %-5level %logger{50} - %msg%npattern>
springProfile>
否则
no applicable action for [springProfile]
<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<springProfile name="!dev">
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} +=+ [%thread] %-5level %logger{50} - %msg%npattern>
springProfile>
<springProfile name="dev">
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] %-5level %logger{50} - %msg%npattern>
springProfile>
<charset>UTF-8charset>
encoder>
appender>
5、切换日志框架
可以按照slf4j的日志适配图，进行相关的切换；
slf4j+log4j的方式；
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
<exclusions>
<exclusion>
<artifactId>logback-classicartifactId>
<groupId>ch.qos.logbackgroupId>
exclusion>
exclusions>
dependency>
<dependency>
<groupId>org.slf4jgroupId>
<artifactId>slf4j-log4j12artifactId>
dependency>
切换为log4j2
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
<exclusions>
<exclusion>
<artifactId>spring-boot-starter-loggingartifactId>
<groupId>org.springframework.bootgroupId>
exclusion>
exclusions>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-log4j2artifactId>
dependency>
四、Web开发
1、简介
使用SpringBoot；
1）、创建SpringBoot应用，选中我们需要的模块；
2）、SpringBoot已经默认将这些场景配置好了，只需要在配置文件中指定少量配置就可以运行起来
3）、自己编写业务代码；’
自动配置原理？
这个场景SpringBoot帮我们配置了什么？都不能修改？能修改哪些配置？能不能扩展？xxx
XXXXAutoConfigruation:帮我们给容器自动配置组件;
xxxxProperties:配置类来封装配置文件的内容；
2、SpringBoot对静态资源的映射规则；
*/
@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties {
private static final String[] CLASSPATH_RESOURCE_LOCATIONS = { "classpath:/META-INF/resources/",
"classpath:/resources/", "classpath:/static/", "classpath:/public/" };
//可以设置和静态资源有关的参数，缓存时间等
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
if (!this.resourceProperties.isAddMappings()) {
logger.debug("Default resource handling disabled");
return;
}
Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
if (!registry.hasMappingForPattern("/webjars/**")) {
customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**")
.addResourceLocations("classpath:/META-INF/resources/webjars/")
.setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
}
String staticPathPattern = this.mvcProperties.getStaticPathPattern();
if (!registry.hasMappingForPattern(staticPathPattern)) {
customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern)
.addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
.setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
}
}
//配置欢迎页映射
@Bean
public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext,
FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(
new TemplateAvailabilityProviders(applicationContext), applicationContext, getWelcomePage(),
this.mvcProperties.getStaticPathPattern());
welcomePageHandlerMapping.setInterceptors(getInterceptors(mvcConversionService, mvcResourceUrlProvider));
welcomePageHandlerMapping.setCorsConfigurations(getCorsConfigurations());
return welcomePageHandlerMapping;
}
1）、所有/webjars/**,都会去classpath:/META-INF/resources/webjars/找资源
添加链接描述
localhost:8080/webjars/jquery/3.5.1/jquery.js
2）、“/**” 访问当前项目路径的任何资源，（静态资源文件夹）
"classpath:/META-INF/resources/"
"classpath:/resources/"
"classpath:/static/"
"classpath:/public/"
"/":当前项目的根路径
localhost:8080/abc 去静态资源文件夹下里面找abc
3）、欢迎页；静态资源文件夹·下面的所有index.html页面；被"/**"映射；
localhost:8080
private Optional<Resource> getWelcomePage() {
String[] locations = getResourceLocations(this.resourceProperties.getStaticLocations());
return Arrays.stream(locations).map(this::getIndexHtml).filter(this::isReadable).findFirst();
}
4）、所有的**/favicon.ico都是在静态文件下找；
3、模板引擎
JSP、Velocity、FreeMaker、Thymeleaf；
SpringBoot推荐的Thymeleaf;
语法更简单，功能更强大；
1、引入Thymeleaf
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-thymeleafartifactId> dependency>
2、Thymeleaf使用&语法
@ConfigurationProperties(prefix = "spring.thymeleaf")
public class ThymeleafProperties {
private static final Charset DEFAULT_ENCODING = StandardCharsets.UTF_8;
public static final String DEFAULT_PREFIX = "classpath:/templates/";
public static final String DEFAULT_SUFFIX = ".html";
//只要我们吧Html页面放在classpath:/templates/，thymeleaf就能自动渲染;
只要我们把HTML页面放在classpath:/templates/,thymeleaf就能自动渲染；
使用：
1、导入thymeleaf命名空间
<html xmlns:th="http://www.thymeleaf.org">
2、使用thymeleaf语法，
<html lang="en" xmlns:th="http://www.thymeleaf.org" >
<head>
<meta charset="UTF-8">
<title>Titletitle>
head>
<body>
success
<h1>成功！h1>
<h1>[[${hello}]]h1>
<div th:text="${hello}">这里显示欢迎信息div>
body>
html>
3、语法规则
1）、th:text;改变当前元素里面的文本内容；
th:任意html属性；
2）、表达式
Simple expressions:(表达式语法)
Variable Expressions: ${...} :获取变量值；OGNL；
1）、获取对象的属性
2）、使用内置的基本对象
#ctx : the context object. #vars: the context variables. #locale : the context locale.
#request : (only in Web Contexts) the HttpServletRequest object.
#response : (only in Web Contexts) the HttpServletResponse object.
#session : (only in Web Contexts) the HttpSession object. #servletContext : (only in Web Contexts) the ServletContext object.
Selection Variable Expressions: *{...} :选择表达式；和${}在功能上是一样；补充配合 :object="${session.user}">
Name
: :text="*{firstName}">Sebastian>.>
Surname
: :text="*{lastName}">Pepper>.>
Nationality
: :text="*{nationality}">Saturn>.>
>
Message Expressions: #{...} 获取国际化内容
Link URL Expressions: @{...} 定义URL;
Fragment Expressions: ~{...} 判断引入表达式
${session.foo}
3）、内置的一些工具对象
Literals（字面量）
Text literals: 'one text' , 'Another one!' ,…
Number literals: 0 , 34 , 3.0 , 12.3 ,…
Boolean literals: true , false
Null literal: null
Literal tokens: one , sometext , main ,…
Text operations: （文本操作）
String concatenation: +
Literal substitutions: |The name is ${name}|
Arithmetic operations: (数学运算)
Binary operators: + , - , * , / , %
Minus sign (unary operator): -
Boolean operations:（布尔运算）
Binary operators: and , or
Boolean negation (unary operator): ! , not
Comparisons and equality:（比较运算）
Comparators: > , < , >= , <= ( gt , lt , ge , le )
Equality operators: == , != ( eq , ne )
Conditional operators: （条件运算）
If-then: (if) ? (then)
If-then-else: (if) ? (then) : (else)
Default: (value) ?: (defaultvalue)
Special tokens:（特殊操作）
No-Operation: _
<a href="details.html" th:href="@{/order/details(orderId=${o.id})}">viewa>
<div th:insert="~{commons :: main}">...div>
4、SpringMVC自动配置
spring自动配置
7.1.1. Spring MVC Auto-configuration
1）、SpringMVC auto Configruation
Spring Boot 自动配置好了SpringMVC
以下是SpringBoot对SpringMVC的默认配置；
- Inclusion of
ContentNegotiatingViewResolver and BeanNameViewResolver beans.
- 自动配置 了ViewResolver(视图解析器：根据方法的返回值得到视图对象（View）视图对象决定如何渲染（转发？重定向？）)
- ContentNegotiatingViewResolver：组合所有的视图解析器；
- 如何定制：我们可以自己给容器中添加一个视图解析器；自动的将其组合进来
- Support for serving static resources, including support for WebJars (covered later in this document)).(静态属性)
- Automatic registration of
Converter, GenericConverter, and Formatter beans.
- Converter：转换器；public String hello(User user);类型转换使用
- Formatter：格式化器；2020-06-28===Date；
@Bean
@Override
public FormattingConversionService mvcConversionService() {
Format format = this.mvcProperties.getFormat();
WebConversionService conversionService = new WebConversionService(new DateTimeFormatters()
.dateFormat(format.getDate()).timeFormat(format.getTime()).dateTimeFormat(format.getDateTime()));
addFormatters(conversionService);
return conversionService;
}
自己添加的格式化转换器，我们只需要放在容器中即可
`
- Support for
HttpMessageConverters (covered later in this document).
- HttpMessageConverters:SpringMVC用来转换Http请求和响应的；User—json;
- HttpMessageConverters:是从容器中确定;获取所有的HttpMessageConverters；
自己给容器中添加HttpMessageConverter，只需要将自己的组件注册容器中（@Bean，@Component）
- Automatic registration of
MessageCodesResolver (covered later in this document).定义错误代码生成规则
- Static
index.html support.
- Custom
Favicon support (covered later in this document).
- Automatic use of a
ConfigurableWebBindingInitializer bean (covered later in this document).
我们可以配置一个ConfigurableWebBindingInitializer来替换默认的；（添加到容器）
初始化WebDataBinder;
请求数据=====JavaBean；
org.springframework.boot.test.autoconfigure.web：web的所有自动场景
If you want to keep those Spring Boot MVC customizations and make more MVC customizations (interceptors, formatters, view controllers, and other features), you can add your own @Configurationclass of type WebMvcConfigurer but without @EnableWebMvc.
If you want to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter, or ExceptionHandlerExceptionResolver, and still keep the Spring Boot MVC customizations, you can declare a bean of type WebMvcRegistrations and use it to provide custom instances of those components.
If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc, or alternatively add your own @Configuration-annotated DelegatingWebMvcConfiguration as described in the Javadoc of @EnableWebMvc.
2）、扩展SpringMVC
<mvc:view-controller path="/hello" view-name="success"/>
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/hello"/>
<bean>bean>
mvc:interceptor>
mvc:interceptors>
编写一个配置类（@Configruation），是WebMvcConfigurer类型，不能标注@EnableWebMvc；
//使用WebMvcConfigurer可以来扩展SpringMVC的功能
//WebMvcConfigurerAdapter因为1.8接口的默认方法特性被弃用
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
@Override
public void addViewControllers(ViewControllerRegistry registry) {
// super.addViewControllers(registry);
registry.addViewController( "/atguigu" ).setViewName( "success" );
}
}
原理：
1）、WebMvcAutoConfiguration是SpringMVC的自动配置类
2）、在做其他自动配置时会导入；@Import（EnableWebMvcConfiguration.class）
/**
* Configuration equivalent to {@code @EnableWebMvc}.
*/
@Configuration(proxyBeanMethods = false)
public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration implements ResourceLoaderAware {
@Configuration(proxyBeanMethods = false)
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
public DelegatingWebMvcConfiguration() {
}
@Autowired(required = false)
public void setConfigurers(List<WebMvcConfigurer> configurers) {
if (!CollectionUtils.isEmpty(configurers)) {
this.configurers.addWebMvcConfigurers(configurers);
}
//一个参考实现；将所有的WebMvcConfigurer相关配置都来一起调用;
// public void addWebMvcConfigurers(List configurers) {
// if (!CollectionUtils.isEmpty(configurers)) {
// this.delegates.addAll(configurers);
// }
// }
}
3）、容器中所有的WebMvcConfigurer都来一起起做用;
4）、我们的配置类也会被调用；
效果：SpringMVC的自动配置和我们的扩展配置都会起作用；所有的SpringMVC的自动配置都失效；
我们需要在配置类中添加@EnableWebMvc即可；
//使用WebMvcConfigurer可以来扩展SpringMVC的功能
//WebMvcConfigurerAdapter过期因为1.8接口的特性默认方法特性被弃用
@Configuration
@EnableWebMvc
public class MyMvcConfig implements WebMvcConfigurer {
@Override
public void addViewControllers(ViewControllerRegistry registry) {
// super.addViewControllers(registry);
registry.addViewController( "/atguigu" ).setViewName( "success" );
}
}
原理：
为什么@EnableWebMvc自动配置就失效了；
1）、@EnableWebMvc的核心
@Import({DelegatingWebMvcConfiguration.class})
public @interface EnableWebMvc {
}
2）、
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
3）、
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
//容器中没有这个组件的时候,这个自动配置类才生效
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {
4）、@EnableWebMvc将WebMvcConfigurationSupport组件导入进来；
5）、导入的WebMvcConfigurationSupport只是SpringMVC最基本的功能；
5、如何修改SpringBoot的默认配置
模式：
1）、SpringBoot在自动配置很多组件的时候，先看容器中有没有用户自己配置的（@Bean、@Component）如果有就用用户配置的，如果没有，才自动配置；如果有些组件可以多个（ViewResolver）将用户配置的和自己的默认的组合起来；
2）、在SpringBoot中会有非常多的xxxxConfigurer帮助我们配置；