SpringMVC原理分析
Spring Boot学习
5、Hello World探究
1、POM文件
1、父项目
org.springframework.boot
spring-boot-starter-parent
2.0.2.RELEASE
他的父项目是：
org.springframework.boot
spring-boot-dependencies
2.0.2.RELEASE
../../spring-boot-dependencies
他才真正的管理springboot应用的所有依赖版本。
Spring Boot的版本仲裁中心：
以后我们导入依赖，默认不需要写版本（没有在dependencies里面的依赖需要我们手动写上版本）；
2、启动器
org.springframework.boot
spring-boot-starter-web
spring-boot-starter-web
spring-boot-starter:spring-boot场景启动器；帮我们导入了web模块正常运行所依赖的组件；
Spring Boot将所有的功能场景都抽取出来，做成一个个starters（启动器），只要在项目里面引入这些starter相关场景的所有依赖都会导入进来。要用什么功能，就导入什么场景的启动器。
2、主程序类，主入口类
/**
* @author Alan
* @date 2018/5/12 16:11
* @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
*/
@SpringBootApplication
publicclassHelloWorldApplication{
publicstaticvoidmain(String[]args) {
//spring应用启动起来
SpringApplication.run(HelloWorldApplication.class,args);
}
}
@SpringBootApplication： Spring Boot应用标注在某个类上说明这个类是Spring Boot的主配置类，Spring Boot就应该运行这个类的main方法来启动Spring Boot应用。
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
excludeFilters={@Filter(
type=FilterType.CUSTOM,
classes={TypeExcludeFilter.class}
),@Filter(
type=FilterType.CUSTOM,
classes={AutoConfigurationExcludeFilter.class}
)}
)
public@interfaceSpringBootApplication{
@SpringBootConfiguration：Spring Boot的配置类
标注在某个类上，表示 这是一个Spring Boot的配置类；
@Configuration：配置类上来标注这个注解；
配置类----配置文件；配置类也是一个组件：@Component
@EnableAutoConfiguration：开启自动配置功能；
以前我们需要配置的东西，Spring Boot帮我们自动配置；@EnableAutoConfiguration告诉Spring开启自动配置功能，这样自动配置才能生效；
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public@interfaceEnableAutoConfiguration{
@AutoConfigurationPackage：自动配置包；
@Import({Registrar.class})：
Spring底层注释@Import，给容器中导入一个组件；导入的组件由AutoConfigurationImportSelector.class指定。
将主配置类（@SpringBootApplication标注的类）的所在包及下面的所有组件扫描到Spring容器；
@Import({Registrar.class})：
给容器中导入组件？
AutoConfigurationImportSelector.class：导入哪些组件的选择器
将所有需要的组件以全类名的方式返回；这些组件就会被添加到容器中；
会给容器中导入非常多的自动配置类（xxxAutoConfiguration）；就是给容器中导入这个场景需要的所有组件，并配置好这些组件；
有了自动配置类，免去了我们手动编写配置注入功能组件等工作；
SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class,class Loader)
Spring Boot在启动的时候，从类路径 META-INFO/spring.facotries中获取EnableAutoConfiguration指定的值；将这些值作为自动配置类导入到容器中，自动配置类就生效了，帮我们自动配置工作；
我们点一个webmvc进去，如下：
以前我们需要配置的东西都帮我们自动配置了，J2EE的整体整合解决方案和自动配置都在：
C:\Users\Alan.m2\repository\org\springframework\boot\spring-boot-autoconfigure\2.0.2.RELEASE\spring-boot-autoconfigure-2.0.2.RELEASE.jar
6、使用Spring Initializer快速创建Spring Boot项目
IDE都 支持使用Spring的创建向导快速创建一个Spring Boot项目；
选择我们需要的模块，向导会联网创建Spring Boot项目；
默认生成的Spring Boot项目：
主程序已经生成好了
resources文件夹目录结构
static： 保存所有的静态资源；js、css、images；
templates：保存所有的模板页面：（Spring Boot默认jar包使用嵌入式的Tomcat，默认不支持JSP页面）；可以使用模板引擎（thymeleaf、freemarker）；
applications.properties：Spring Boot应用的配置文件；可以修改一些默认配置；
二、配置文件
1、配置文件
Spring Boot使用一个全局的配置文件，配置文件名是固定的：
application.properties
application.yml
配置文件的作用：修改Spring Boot自动配置的默认值；
Spring Boot在底层都给我们自动配置好了；
YAML(YAML Ain't Markup Language)
YAML A Markup Language：是一个标记语言；
YAML isn't Markup Language：不是一个标记语言；
标记语言：
以前的配置文件，大多是xxx.xml文件；
YAML：以数据为中心，比json、xml更适合做配置文件；
YAML配置例子：
server:
port: 8080
XML配置例子：
8080
2、YAML语法
1、基本语法
k:（空格）v ：表示一对键值对（空格必须有）
以空格的缩进来控制层级关系；只要是左对齐的一列数据，都表示同一层级；
server:
port: 8080
path: /hello
属性和值也是大小写敏感的；
2、值的写法
字面量：普通的值（数字、字符串、布尔）
k: v :字面直接来写；
字符串默认不用加上双引号和单引号；
“”：双引号，不会转义字符串里面的特殊字符，特殊字符会作为本身想表示的意思
name: "zhangsan \n lisi"：输出zhangsan 换行 lisi
’‘：单引号：会转义特殊字符，特殊字符最终只是一个普通字符串数据
name: 'zhangsan \n lisi'：输出zhangsan \n lisi
对象、Map（属性和值）（键值对）：
k: v:在下一行写对象的属性和值的关系，注意缩进；
对象还是k: v格式
friends:
lastName: zhangsan
age: 20
行内写法：
friends: {lastName: zhangsan,age: 20}
数组（List、Set）：
用- 值表示数组中的一个元素
pets:
- cat
- dog
- monkey
行内写法：
pets: [cat,dog,monkey]
3、配置文件值注入
配置文件：
person:
lastName: zhangsan
age: 18
boss: false
birthday: 2017/12/12
maps: {k1: v1,k2: v2}
lists:
- lisi
- zhaoliu
dog:
name: 小狗
age: 2
JavaBean：
/**
* @author Alan
* @date 2018/5/12 21:01
* 将配置文件中的每一个属性值，映射到这个组件中
* @ConfigurationProperties：告诉SpringBoot将本类的所有属性和配置文件中相关的配置绑定
* prefix = "person" 配置文件中的哪个属性进行一一映射
* 只有这个组件是容器中的组件，才能使用容器提供的@ConfigurationProperties功能
*/
@Component
@ConfigurationProperties(prefix="person")
publicclassPerson{
privateStringlastName;
privateIntegerage;
privateBooleanboss;
privateDatebirthday;
privateMapmaps;
privateListlists;
privateDogdog;
我们可以导入导入配置文件处理器，以后编写配置就有提示了：
org.springframework.boot
spring-boot-configuration-processor
true
单元测试例子：
packagecom.example.demo;
importcom.example.demo.bean.Person;
importorg.junit.Test;
importorg.junit.runner.RunWith;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.boot.test.context.SpringBootTest;
importorg.springframework.test.context.junit4.SpringRunner;
/**
* SpringBoot单元测试
* 可以在测试期间很方便的类似编码一样进行自动注入
*/
@RunWith(SpringRunner.class)
@SpringBootTest
publicclassDemoApplicationTests{
@Autowired
Personperson;
@Test
publicvoidcontextLoads() {
System.out.println(person);
}
}
1、properties文件在idea中默认utf-8可能会乱码
结果发现中文乱码，需要进行设置：勾选Transparent native-to-ascii conversion，转出ascii码
这样就不会乱码了：
2、@Value与@ConfigurationProperties获取值比较
@ConfigurationProperties@Value
功能批量注入配置文件中的属性一个一个指定
松散绑定(松散语法)支持不支持
SpEL不支持支持
JSR303数据校验支持不支持
复杂类型封装支持不支持
配置文件yml还是properties他们都能获取到值；
如果说，我们只是在业务逻辑中要获取一下配置文件中的某项值，使用@Value；
如果说，我们编写了一个JavaBean和配置文件进行映射，我们就直接使用@ConfigurationProperties;
3、配置文件注入值数据校验
@Component
@ConfigurationProperties(prefix="person")
@Validated
publicclassPerson{
//lastName必须是邮箱格式,default message [不是一个合法的电子邮件地址]
//@Value("${person.last-name}")
privateStringlastName;
privateIntegerage;
4、@PropertySource与@ImportResource
@PropertySource：加载指定的配置文件
/**
* @author Alan
* @date 2018/5/12 21:01
* 将配置文件中的每一个属性值，映射到这个组件中
* @ConfigurationProperties：告诉SpringBoot将本类的所有属性和配置文件中相关的配置绑定
* prefix = "person" 配置文件中的哪个属性进行一一映射
* 只有这个组件是容器中的组件，才能使用容器提供的@ConfigurationProperties功能
* @ConfigurationProperties(prefix = "person")默认从全局配置文件中获取值
*/
@PropertySource(value="classpath:person.properties")
@Component
@ConfigurationProperties(prefix="person")
//@Validated
publicclassPerson{
//lastName必须是邮箱格式,default message [不是一个合法的电子邮件地址]
//@Value("${person.last-name}")
privateStringlastName;
privateIntegerage;
privateBooleanboss;
privateDatebirthday;
privateMapmaps;
privateListlists;
privateDogdog;
@ImportResource：导入Spring的配置文件，让配置文件里面的内容生效
Spring Boot里面没有Spring的配置文件，我们自己编写的配置文件，也不能自动识别；
想让Spring的配置文件生效，加载进来，@ImportResource标注在一个配置类上；
beans.xml:
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">
SpringBootApplication类：
//导入Spring的配置文件，使其生效
@ImportResource(locations={"classpath:beans.xml"})
@SpringBootApplication
publicclassDemoApplication{
publicstaticvoidmain(String[]args) {
SpringApplication.run(DemoApplication.class,args);
}
}
test类：
@RunWith(SpringRunner.class)
@SpringBootTest
publicclassDemoApplicationTests{
@Autowired
Personperson;
@Autowired
ApplicationContextioc;
@Test
publicvoidhelloservice(){
Booleanb=ioc.containsBean("helloservice");
System.out.println(b);
}
单元测试结果：
不来编写Spring的配置文件：
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">
Spring Boot推荐的给容器中添加组件的方式：推荐使用全注解的方式
1、配置类======Spring配置文件
2、使用@Bean给容器中添加组件
/**
* @author Alan
* @date 2018/5/12 22:30
* @Configuration：指明当前类是一个配置文件，就是来替代之前的Spring配置文件
* 配置文件使用标签添加组件
*/
@Configuration
publicclassMyAppConfig{
//将方法的返回值添加到容器中，容器中这个组件默认的id就是方法名
@Bean
publicHelloServicehelloService(){
System.out.println("@Bean给容器添加组件了...");
returnnewHelloService();
}
}
4、配置文件占位符
1、随机数
${random.value}、${random.int}、${random.long}
${random.int(10)}、${random.int[1024,65536]}
2、占位符获取之前配置的值，如果没有可以使用:指定默认值
person.last-name=张三${random.uuid}
person.age=${random.int}
person.boss=true
person.birthday=2019/02/03
person.maps.k1=v1
person.maps.k2=v2
person.lists=a,b,c
person.dog.name=${person.hello:hello}小狗
person.dog.age=2
5、Profile
1、多profile文件
我们在主配置文件编写的时候，文件名可以是application-{profile}.properties/yml
默认使用application.properties
2、yml支持多文档块方式
server:
port: 8080
spring:
profiles:
active: prod
---
server:
port: 8083
spring:
profiles: dev
---
server:
port: 8084
spring:
profiles: prod#指定属于哪个环境
3、激活指定profile
1、在配置文件中指定spring.profiles.active=dev
2、命令行：
java -jar demo-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev
可以直接在测试的时候，配置传入命令行参数
利用idea的maven插件进行打包（双击package)
之后target目录下会生成jar文件，target右键-show in explorer，然后地址栏输入cmd，这样就进入了target目录，然后输入如下命令：java -jar demo-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev
端口就启动了dev下的端口号，而不是默认配置文件里面的prod端口号（8084）
3、虚拟机参数
-Dspring.profiles.active=dev
6、配置文件的加载位置
Spring Boot启动会扫描以下位置的application.properties或者application.yml文件作为Spring Boot的默认配置文件
-file:./config/
-file:./
-classpath:/config
-classpath:/
优先级，由高到低，高优先级的配置会覆盖低优先级的配置；
Spring Boot从4个位置全局加载主配置文件；互补配置
我们还可以通过spring.config.location来改变默认的配置文件位置
项目打包好后，我们可以使用命令行参数的形式，启动项目的时候指定配置文件的新位置；指定配置文件和默认加载的这些配置文件共同起作用，形成互补配置。解释：主要是针对运维，比如项目打包好后是8084，但是需要改变端口号，我们只要命令行运行时加上--spring.config.location=G:/application.properties，这样项目就可以通过8085访问了，不需要重新打包jar包，通过加载外部配置文件即可办到，比较方便。
比如在D盘新建一个配置文件，更改端口为8085：
IDEA-terminal：
cd target
D:\idea project\SpringBoot-02-helloworld\target>java -jar demo-0.0.1-SNAPSHOT.jar --spring.config.location=D:/application.properties
项目启动时的端口就是8085了:
7、外部配置加载顺序
1.命行参数
java -jar demo-0.0.1-SNAPSHOT.jar --server.port=8087 --server.context-path=/abc
多个配置用空格分开，--配置项=值
2.来自 java: comp/env的ND属性3.Java系统属性( System getproperties0)4.操作系统环境变量
Random Value Property Source配置的 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注解类上的@ PropertySource11.通过 SpringApplication. setDefaultproperties指定的默认属性
8、自动配置原理
配置文件能写什么？怎么写？自动配置原理，参见：
https://docs.spring.io/spring-boot/docs/2.0.2.RELEASE/reference/htmlsingle/#appendix
1、自动配置原理：
1）Spring Boot启动的时候，加载主配置类，开启了自动配置功能@EnableAutoConfiguration
2）@EnableAutoConfiguration的作用：
利用AutoConfigurationImportSelector给容器中导入一些组件；
可以查看selectImports()方法的内容：
List configurations = this.getCandidateConfigurations(annotationMetadata, attributes);获取候选的配置
SpringFactoriesLoader.loadFactoryNames
扫描所有jar包路径下的META-INF/spring.factories
把这些扫描到的这些文件的内容包装成properties对象
从properties获取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.cloud.CloudAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
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.ElasticsearchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapDataAutoConfiguration,\
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.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.jest.JestAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
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.groovy.template.GroovyTemplateAutoConfiguration,\
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.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.reactor.core.ReactorCoreAutoConfiguration,\
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.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.OAuth2ClientAutoConfiguration,\
org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
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.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
每一个这样的xxxAutoConfiguration类都是容器中的一个组件，到加入到容器中；用他们来做自动配置；
3）每一个自动配置类进行自动配置功能；
4）以HttpEncodingAutoConfiguration(Http编码自动配置)为例解释自动配置原理；
@Configuration//表示这是一个配置类，以前的配置文件一样，也可以给容器中添加组件
@EnableConfigurationProperties({HttpEncodingProperties.class})//启用指定类的ConfigurationProperties功能，将配置文件中对应的值和HttpEncodingProperties绑定起来；并把HttpEncodingProperties加入到ioc容器中
@ConditionalOnWebApplication(//sping底层@Conditional注解，根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效：判断当前应用是否为web应用，如果是，当前配置类生效
type=Type.SERVLET
)
@ConditionalOnClass({CharacterEncodingFilter.class})//判断当前项目有没CharacterEncodingFilte类：SpringMVC中进行乱码解决的过滤器；
//判断文件是否存在某个配置：spring.http.encoding.enabled，如果不存在，判断也是成立的，即使配置文件中不配置spring.http.encoding.enabled=true，也是默认生效的；
@ConditionalOnProperty(
prefix="spring.http.encoding",
value={"enabled"},
matchIfMissing=true
)
publicclassHttpEncodingAutoConfiguration{
//他已经和SpringBoot的配置文件映射了
privatefinalHttpEncodingPropertiesproperties;
//只有一个有参构造器的情况下，参数的值就会从容器中拿
publicHttpEncodingAutoConfiguration(HttpEncodingPropertiesproperties) {
this.properties=properties;
}
@Bean//给容器中添加一个组件，这个组件的某些值需要从properties中获取
@ConditionalOnMissingBean
publicCharacterEncodingFiltercharacterEncodingFilter() {
CharacterEncodingFilterfilter=newOrderedCharacterEncodingFilter();
filter.setEncoding(this.properties.getCharset().name());
filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpEncodingProperties.Type.REQUEST));
filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpEncodingProperties.Type.RESPONSE));
returnfilter;
}
根据当前不同的条件判断，决定这个配置类是否生效；
一旦这个配置类生效，这个配置类就会给容器中添加各种组件，这些组件的属性是从对应的properties类中获取的，这些类里的每一个属性又是和配置文件绑定的；
5）所有在配置文件中能配置的属性都是在xxxProperties类中封装着；配置文件能配置什么就可以参照某个功能 对应的属性类；
@ConfigurationProperties(//从配置文件中获取指定的值和bean的属性进行绑定
prefix="spring.http.encoding"
)
publicclassHttpEncodingProperties{
publicstaticfinalCharsetDEFAULT_CHARSET;
精髓：
1）、Spring Boot启动会加载大量的自动配置类；
2）、我们看我们需要的功能有没有Spring Boot默认写好的自动配置类；
3）、我们再来看这个自动配置中到底配置了哪些组件；（只要我们要用的组件有，我们就不需要再来配置了）；
4）、给容器中自动配置类添加组件的时候，会从properties类中获取某些属性，我们就可以在配置文件中指定这些属性的值；
xxxAutoConfiguration：自动配置类；
会给容器中添加组件；
xxxProperties：封装配置文件中的相关属性；
举thymeleaf例子：ctrl+n：
@Configuration
@EnableConfigurationProperties({ThymeleafProperties.class})
@ConditionalOnClass({TemplateMode.class})
@AutoConfigureAfter({WebMvcAutoConfiguration.class,WebFluxAutoConfiguration.class})
publicclassThymeleafAutoConfiguration{
ThymeleafProperties.class：
@ConfigurationProperties(
prefix="spring.thymeleaf"
)
publicclassThymeleafProperties{
privatestaticfinalCharsetDEFAULT_ENCODING;
publicstaticfinalStringDEFAULT_PREFIX="classpath:/templates/";
publicstaticfinalStringDEFAULT_SUFFIX=".html";
privatebooleancheckTemplate=true;
privatebooleancheckTemplateLocation=true;
privateStringprefix="classpath:/templates/";
privateStringsuffix=".html";
privateStringmode="HTML";
privateCharsetencoding;
privatebooleancache;
privateIntegertemplateResolverOrder;
privateString[]viewNames;
privateString[]excludedViewNames;
privatebooleanenableSpringElCompiler;
privatebooleanenabled;
privatefinalThymeleafProperties.Servletservlet;
privatefinalThymeleafProperties.Reactivereactive;
这样application.properties文件中可以加的配置可以有：
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffi=.html
spring.thymeleaf.checkTemplate=true
2、细节
1、@Conditional派生注解（Spring注解版@Conditional作用）
作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置里面的内容才能生效；
自动配置类在一定条件下才能生效；
我们可以在配置文件中启动debug=true属性来让控制台打印自动配置报告；这样我们就可以方便知道哪些自动配置类生效；
============================
CONDITIONSEVALUATIONREPORT
============================
Positivematches:（自动配置类启用的）
-----------------
CodecsAutoConfigurationmatched:
-@ConditionalOnClassfoundrequiredclass'org.springframework.http.codec.CodecConfigurer';@ConditionalOnMissingClassdidnotfindunwantedclass(OnClassCondition)
Negativematches:（没用启用，没有匹配成功的自动配置类）
-----------------
ActiveMQAutoConfiguration:
Didnotmatch:
-@ConditionalOnClassdidnotfindrequiredclasses'javax.jms.ConnectionFactory','org.apache.activemq.ActiveMQConnectionFactory'(OnClassCondition)
4、Web开发
2、Spring Boot对静态资源的映射规则
@ConfigurationProperties(
prefix="spring.resources",
ignoreUnknownFields=false
)
publicclassResourcePropertiesimplementsResourceLoaderAware,InitializingBean{
//可以设置和静态资源有关的参数、缓存时间等
publicvoidaddResourceHandlers(ResourceHandlerRegistryregistry) {
if(!this.resourceProperties.isAddMappings()) {
logger.debug("Default resource handling disabled");
}else{
IntegercachePeriod=this.resourceProperties.getCachePeriod();
if(!registry.hasMappingForPattern("/webjars/**")) {
this.customizeResourceHandlerRegistration(registry.addResourceHandler(newString[]{"/webjars/**"}).addResourceLocations(newString[]{"classpath:/META-INF/resources/webjars/"}).setCachePeriod(cachePeriod));
}
StringstaticPathPattern=this.mvcProperties.getStaticPathPattern();
if(!registry.hasMappingForPattern(staticPathPattern)) {
this.customizeResourceHandlerRegistration(registry.addResourceHandler(newString[]{staticPathPattern}).addResourceLocations(this.resourceProperties.getStaticLocations()).setCachePeriod(cachePeriod));
}
}
}
//配置欢迎页
@Bean
publicWelcomePageHandlerMappingwelcomePageHandlerMapping(
ResourcePropertiesresourceProperties) {
returnnewWelcomePageHandlerMapping(resourceProperties.getWelcomePage(),
this.mvcProperties.getStaticPathPattern());
}
//配置喜欢的图标
@Configuration
@ConditionalOnProperty(value="spring.mvc.favicon.enabled",matchIfMissing=true)
publicstaticclassFaviconConfiguration{
privatefinalResourcePropertiesresourceProperties;
publicFaviconConfiguration(ResourcePropertiesresourceProperties) {
this.resourceProperties=resourceProperties;
}
@Bean
publicSimpleUrlHandlerMappingfaviconHandlerMapping() {
SimpleUrlHandlerMappingmapping=newSimpleUrlHandlerMapping();
mapping.setOrder(Ordered.HIGHEST_PRECEDENCE+1);
//所有**/favicon.ico
mapping.setUrlMap(Collections.singletonMap("**/favicon.ico",
faviconRequestHandler()));
returnmapping;
}
@Bean
publicResourceHttpRequestHandlerfaviconRequestHandler() {
ResourceHttpRequestHandlerrequestHandler=newResourceHttpRequestHandler();
requestHandler
.setLocations(this.resourceProperties.getFaviconLocations());
returnrequestHandler;
}
}
}
1)、所有webjars/*都去classpath:/META-INF/resources/webjars/找资源；
webjars：以jar包的形式引入静态资源；
比如引入jquery3.3.1:
org.webjars
jquery
3.3.1-1
http://localhost:8080/webjars/jquery/3.3.1-1/jquery.js 访问时只要写webjars下资源的名称即可：
2）“/”访问当前项目的任何资源：（静态资源的文件夹）**
"/"：当前项目的根目录
"classpath:/META-INF/resources/",
"classpath:/resources/",
"classpath:/static/",
"classpath:/public/
localhost:8080/abc-->默认从静态资源文件夹里找abc资源；
3）、欢迎页：静态资源文件下的index.html页面，被"/"映射；**
localhost:8080/ 找index.html
比如在public文件夹下放index.html：
4）、所有的/favicon.ico都是在静态资源文件下找；**
比如在resource文件夹下放一个自定义图标：
3、模板引擎
JSP、Velocity、Freemarker、Thymeleaf；
SpringBoot推荐的Thymeleaf：
语法更简单、功能更强大；
1、引入Thymeleaf
切换thymeleaf版本
3.0.9.RELEASE
2.3.0
具体参见：
thymeleaf发布：https://github.com/thymeleaf/thymeleaf/releases
thymeleaf layout dialect:https://github.com/ultraq/thymeleaf-layout-dialect/releases
org.springframework.boot
spring-boot-starter-thymeleaf
Layout 2.0.0的版本开始视频thymeleaf3
2、Thymeleaf使用&语法
@ConfigurationProperties(prefix="spring.thymeleaf")
publicclassThymeleafProperties{
privatestaticfinalCharsetDEFAULT_ENCODING=Charset.forName("UTF-8");
privatestaticfinalMimeTypeDEFAULT_CONTENT_TYPE=MimeType.valueOf("text/html");
publicstaticfinalStringDEFAULT_PREFIX="classpath:/templates/";
publicstaticfinalStringDEFAULT_SUFFIX=".html";
//只要我们把html页面放到classpath:/templates/路径下，thymeleaf就能自动渲染
只要我们把html页面放到classpath:/templates/路径下，thymeleaf就能自动渲染
使用：
1、导入Thymeleaf的名称空间
2、使用Thymeleaf的使用
Title
success
这是欢迎信息
3、语法规则
1）、th:text：改变当前元素里面的文本内容；
th:任意html属性：来替换原生属性的值；参考官方pdf文档第10章（Attribute Precedence：属性优先级）
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.
${session.foo}
3）、内置的一些工具对象
#execInfo : information about the template being processed.
#messages : methods for obtaining externalized messages inside variables expressions, in the same way as they would be obtained using #{…} syntax.
#uris : methods for escaping parts of URLs/URIs
#conversions : methods for executing the configured conversion service (if any).
#dates : methods for java.util.Date objects: formatting, component extraction, etc.
#calendars : analogous to #dates , but for java.util.Calendar objects.
#numbers : methods for formatting numeric objects.
#strings : methods for String objects: contains, startsWith, prepending/appending, etc.
#objects : methods for objects in general.
#bools : methods for boolean evaluation.
#arrays : methods for arrays.
#lists : methods for lists.
#sets : methods for sets.
#maps : methods for maps.
#aggregates : methods for creating aggregates on arrays or collections.
#ids : methods for dealing with id attributes that might be repeated (for example, as a result of an iteration).
Selection Variable Expressions: *{...} ：选择表达式，和${}功能上是一样的
补充：配合th:object=${session.user};
Name: Sebastian.
Surname: Pepper.
Nationality: Saturn.
等价于：
Name: Sebastian.
Surname: Pepper.
Nationality: Saturn.
Message Expressions: #{...}:获取国际化内容
Link URL Expressions: @{...}：获取URL:
@{/order/process(execId=${execId},execType='FAST')}
Fragment Expressions: ~{...}：片段引用的表达式
...
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:
Page 17 of 104No-Operation:
4、SpringMVC自动配置
27.1.1 Spring MVC Auto-configuration
SpringBoot自动配置好了SpringMVC
以下是SpringBoot对SpringMVC的默认配置：
Spring Boot provides auto-configuration for Spring MVC that works well with most applications.
The auto-configuration adds the following features on top of Spring’s defaults:
Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.
自动配置了ViewResolver（视图解析器：根据返回值得到视图对象（View），视图对象决定如何渲染 （转发？重定向？））
ContentNegotiatingViewResolver ：组合所有的视图解析器；
如何定制：我们可以自己给容器中添加一个视图解析器；自动将其组合进来；
@Bean
publicViewResolvermyViewResolver(){
returnnewmyViewResolver();
}
privatestaticclassmyViewResolverimplementsViewResolver{
@Override
publicViewresolveViewName(StringviewName,Localelocale)throwsException{
returnnull;
}
}
在DispatcherServlet的doDispatch方法打断点，调试：
随便访问一个地址：http://localhost:8080/success
通过控制台的variable可以看到我们自己写的视图解析器添加到viewResolver了：
Support for serving static resources, including support for WebJars (covered later in this document)).
静态资源文件夹路径、webjars
Automatic registration of Converter, GenericConverter, and Formatter beans.
Converter：转换器： public String sayHello(User user)：类型转换使用；
Formatter：格式化器：2017-12-01===Date；
@Bean
@ConditionalOnProperty(prefix="spring.mvc",name="date-format")//在文件中配置日期格式化规则
publicFormatterdateFormatter() {
returnnewDateFormatter(this.mvcProperties.getDateFormat());//日期格式化组件
}
自己添加的格式化器转换器：我们只要放入容器中即可；
Support for HttpMessageConverters (covered later in this document).
HttpMessageConverters：SpringMVC用来转换Http请求和响应的；User---json；
HttpMessageConverters：是从容器中确定的；获取所有的HttpMessageConverters；自己给容器中添加HttpMessageConverters，只需要注册到容器中即可（@Bean，@Componet）；
importorg.springframework.boot.autoconfigure.web.HttpMessageConverters;
importorg.springframework.context.annotation.*;
importorg.springframework.http.converter.*;
@Configuration
publicclassMyConfiguration{
@Bean
publicHttpMessageConverterscustomConverters() {
HttpMessageConverteradditional=...
HttpMessageConverteranother=...
returnnewHttpMessageConverters(additional,another);
}
}
Automatic registration of MessageCodesResolver (covered later in this document).定义错误代码生成规则
Static index.html support.静态首页访问
Custom Favicon support (covered later in this document). favicon.ico标签图标
Automatic use of a ConfigurableWebBindingInitializer bean (covered later in this document).
我们可以配置ConfigurableWebBindingInitializer来替换默认的；（要添加到容器中）
初始化WebDataBinder
请求数据绑定到javabean中
org.springframework.boot.autoconfigure.web：web所有的自动配置场景；
If you want to keep Spring Boot MVC features and you want to add additional MVC configuration (interceptors, formatters, view controllers, and other features), you can add your own @Configuration class of type WebMvcConfigurer but without @EnableWebMvc. If you wish to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter, or ExceptionHandlerExceptionResolver, you can declare a WebMvcRegistrationsAdapter instance to provide such components.
If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc.
5、如何修改Spring Boot的默认配置
模式：
1）SpringBoot在配置很多组件的时候，先看容器中有无用户配置的组件（@Bean、@Component），如果有就用用户配置的，如果没有，才自动配置；如果有些组件可以有多个（ViewResolver）将用户配置的和自己默认的组合起来；
2）、扩展SpringMVC
编写一个配置类（@Configuration），是WebMvcConfigurer 类型的，不能标注EnableWebMvc注解。
网友评论