SpringBoot文档
1、hello world探究
1、pom文件
1、父项目
<parent>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-parent</artifactid>
<version>2.0.5.release</version>
<relativepath /> <!-- lookup parent from repository -->
</parent>
他的父项目是
<parent>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-dependencies</artifactid>
<version>2.0.5.release</version>
<relativepath>../../spring-boot-dependencies</relativepath>
</parent>
他来真正管理spring boot 应用里面的所有依赖版本：
spring boot 版本仲裁中心：
以后我们导入依赖默认是不需要写版本：（没有在dependencies里面管理的依赖自然需要写版本号）
2、启动器
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-web</artifactid>
</dependency>
spring-boot-starter-web: spring boot 场景启动器帮我们导入了web模块正常运行所依赖的组件；
spring boot 将所有相关场景都抽取出来，做成一个个的starters(启动器)，只需要在项目里面引入这些starters相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器
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应用；
@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 @interface springbootapplication {
@springbootconfiguration:spring boot 的配置类；
标注在某个类上，表示这是一个spring boot 的配置类；
@configuration：配置类上来标注这个注解；
配置类-------配置文件：配置类也是容器中的一个组件；@component
@enableautoconfiguration：开启自动配置功能；
以前我们需要配置的东西，spring boot 帮我们自动配置；@enableautoconfiguration
告诉spring boot 开启自动配置功能；这样自动配置才能生效；
@autoconfigurationpackage
@import(autoconfigurationimportselector.class)
public @interface enableautoconfiguration {
@autoconfigurationpackage：自动配置包
@import(autoconfigurationpackages.registrar.class)；
spring的底层注解@import,给容器中导入一个组件；导入的组件由
autoconfigurationpackages.registrar.class
==将主配置类（@springbootapplication标注的类）的所在包及下面所有子包里面的所有组件扫描到spring容器；==
@import(autoconfigurationimportselector.class)
给容器中导入组件？
autoconfigurationimportselector:导入哪些组件的选择器；
将所有需要导入的组件以全类名的方式返回；这些组件就会被添加到容器中；
会给容器中导入非常多的自动配置类（xxxautoconfiguration）;就是给容器中导入这个场景所需要的所有组件，并配置好这些组件
有了自动配置类，免去了我们手动编写配置注入功能组件等的工作；
springfactoriesloader.loadfactorynames(enableautoconfiguration.class,classloader);
==springboot再启动的时候从类路径下的meta-inf/spring.factories中获取enableautoconfiguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作；==；以前我们需要自己配置的东西，自动配置类都帮我们；
j2ee的整体整合解决方案和自动配置都在spring-boot-autoconfigure-2.0.5.release.jar；
2、使用spring initializer快速创建springboot项目
ide都支持使用spring的项目创建向导快速创建一个spring boot项目；
选择我们需要的模块；向导会联网创建spring boot 项目；
默认生成的spring boot项目；
-
主程序已经生成好了，我们只需要我们自己的逻辑
-
resources文件夹中目录结构
-
static:保存所有的静态资源；js css images ;
-
templates:保存所有的模板页面；（spring boot 默认jar包使用嵌入式的tomcat,默认不支持jsp页面）；可以使用引擎模板（freemarker、thymeleaf）;
-
application.properties:spring boot 应用的配置文件；可以修改一些默认配置；
-
二、 配置文件
1、配置文件
spring boot 使用一个全局的配置文件，配置文件名是固定的；
-
application.properties
-
application.yml
配置文件的作用：修改springboot自动配置的默认值；springboot再底层都给我们自动配置好；
yaml(yaml ain't markup language)
yaml a markup language ;是一个标记语言；
yaml isn't markup language; 不是一个标记语言 ；
标记语言：
以前的配置文件；大多使用的都是xxx.xml文件；
yaml:以数据为中心，比json、xml等更适合做配置文件；
yaml:配置例子
server:
port: 8090
xml:
<server>
<port>8081</port>
</server>
2、yaml语法
1、基本语法
k:(空格)v:表示一对键值对（空格必须有）；
以空格缩进来控制层级关系：只要是左对齐的一列数据，都是一个层级的
server:
port: 8090
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
-pig
行内写法
pets：{cat，dog，pig}
3、配置文件值注入
配置文件
person:
lastname: zhangsan
age: 18
boss: false
birth: 2018/10/4
maps: {k1: v1, k2: 12}
lists:
-lisi
-zhaoliu
dog:
name: 小狗
age: 2
javabean:
/*
*将配置文件中配置的每一个属性的值，映射到这个组件中
*@configurationproperties：告诉springboot将本类中的所有属性和配置文件中相关配置进行绑定；
* prefix = "person"配置文件中哪个下面的所有属性进行一一映射
* 只有这个组件是容器中的组件，才能使用容器提供的@configurationproperties功能；
*/
@component
@configurationproperties(prefix = "person")
public class person {
private string lastname;
private integer age;
private boolean boss;
private date birth;
private map<string,object> maps;
private list<object> lists;
private dog dog;
我们可以导入配置文件处理器，以后编写配置文件就有提示了
<!--导入配置文件处理器，配置文件进行绑定就会有提示 -->
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-configuration-processor</artifactid>
<optional>true</optional>
</dependency>
1、properties配置文件在idea中默认utf-8可能会乱码
2、@value获取值和@configurationproperties获取值比较
| @configurationproperties | @value | |
|---|---|---|
| 功能 | 批量注入配置文件中的属性 | 一个一个指定 |
| 松散绑定（松散语法） | 支持 | 不支持 |
| spel（表达式计算） | 不支持 | 支持 |
| jsr303数据校验 | 支持 | 不支持 |
| 复杂类型封装 | 支持 | 不支持 |
配置文件yml还是properties他们都能获取到值；
如果说，我们只是在某和业务逻辑中需要获取一下配置文件的某项值，使用@value
如果说我们专门编写了一个javabean来和配置文件进行映射,我们就直接使用@configurationproperties；
3、配置文件注入值数据校验
@component
@configurationproperties(prefix = "person")
@validated
public class person {
/*
* <bean class="persion">
* <property name ="lastname" value="字面量/${key}从环境变量，配置文件中获取值/#{spel}"</property>
* </bean>
* */
// @value("${person.last-name}")
private string lastname;
// @value("#{11*2}")
private integer age;
//@value("true")
private boolean boss;
private date birth;
private map<string,object> maps;
private list<object> lists;
private dog dog;
4、@propertysource&@importresource
@propertysoure:加载指定的配置文件
/*
*将配置文件中配置的每一个属性的值，映射到这个组件中
*@configurationproperties：告诉springboot将本类中的所有属性和配置文件中相关配置进行绑定；
* prefix = "person"配置文件中哪个下面的所有属性进行一一映射
* 默认从全局配置文件中获取值；
* 只有这个组件是容器中的组件，才能使用容器提供的@configurationproperties功能；
*/
@component
@configurationproperties(prefix = "person")
@propertysource(value = {"classpath:person.properties"})
//@validated
public class person {
/*
* <bean class="persion">
* <property name ="lastname" value="字面量/${key}从环境变量，配置文件中获取值/#{spel}"</property>
* </bean>
* */
// @value("${person.last-name}")
private string lastname;
// @value("#{11*2}")
private integer age;
//@value("true")
private boolean boss;
@importresource:导入spring的配置文件，让配置文件里面的内容生效；
spring boot 里面没有spring的配置文件，我们自己编写的配置文件，也不能自动识别；想让spring的配置文件生效，加载进来;@importresource 标注在一个配置类上
@importresource( locations = {"classpath:beans.xml"})
导入spring的配置文件让其生效
不来编写配置spring配置文件
<?xml version="1.0" encoding="utf-8"?>
<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="org.wl.springboot.service.helloservice"></bean>
</beans>
springboot 推荐给容器中添加组件的方式；
1、配置类=========spring配置文件
2、使用@bean给容器中添加组件
/*
* @configuration:指明当前类是一个配置文件；就是来替代之前的spring配置文件
*在配置文件中用<bean></bean>标签添加组件
*
* */
@configuration
public class myappconfig {
//将方法的返回值添加到容器中；容器中这个组件默认的id就是方法名
@bean
public helloservice helloservice(){
system.out.println("配置类@bean给容器中添加组价了。。。");
return new helloservice();
}
}
4、配置文件占位符
1、随机数
${random.uuid} ${random.int} ${random.long}
${random.int(10)} ${random.int[1024,65536]
2、占位符获取之前配置的值，如果没有可以是用：指定默认值
person:
lastname: zhangsan ${random.uuid}
age: ${random.int}
boss: false
birth: 2018/10/4
maps: {k1: v1, k2: 12}
lists:
-lisi
-zhaoliu
dog:
name: ${person.hello:hello}_dog
age: 2
5、profile
1、多profile文件
我们在主配置文件编写的时候，文件名可以是application-{profile}.properties/yml
默认使用application.properties的配置;
2、yml支持多文档块方式
server:
port: 8090
spring:
profiles:
active: dev
---
server:
port: 8003
spring:
profiles: dev
---
server:
port: 8004
spring:
profiles: prod
---
3、激活指定profile
1、在配置文件中指定spring.properties.active =dev
2、命令行：
java -jar spring-boot-02-config-0.0.1-snapshot.jar --spring.profiles.active=dev
可以直接在测试的时候，配置传入命令行参数
3、 虚拟机参数：
-dspring.profile.active=dev
6、配置文件加载位置
springboot 启动会扫描一下位置的application.properties或者application.yml文件作为spring boot 的默认配置
文件
-file:/config/
-file:/
-classpath:/config/
-classpath:/
优先级由高到低，高优先级的配置会覆盖低优先级的配置；
springboot会从这四个位置全部加载主配置文件；互补配置
==spring-boot配置文件中server.context-path=/xxxxxxx不起作用：==
==原因是更新后写法变成了`server.servlet.context-path=/xxxxxx，这样写即可==
==我们还可以通过spring.config.location来改变默认的配置文件位置==
项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；指定配置文件和默认加载的这些配置文件共同起作用形成互补配置
java -jar spring-boot-02-config-02-0.0.1-snapshot.jar --spring.config.location=c:\users\80481\desktop\application.properties
7、外部配置加载顺序
springboot也可以从以下位置加载配置：按照优先级从高到低；高优先级的配置覆盖低优先级的配置，所有配置会形成互补配置
-
命令行参数
-
所有的配置都可以在命令行上进行指定；
-
多个配置用空格分开； –配置项=值
java -jar spring-boot-02-config-02-0.0.1-snapshot.jar
--server.port=8087 --server.context-path=/abc
12342.来自java:comp/env的jndi属性 3.java系统属性（system.getproperties()） 4.操作系统环境变量 5.randomvaluepropertysource配置的random.*属性值
6.jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件 7.jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件 8.jar包外部的application.properties或application.yml(不带spring.profile)配置文件 9.jar包内部的application.properties或application.yml(不带spring.profile)配置文件
由jar包外向jar包内进行寻找，优先加载待profile的，再加载不带profile的。1
10.@configuration注解类上的@propertysource 11.通过springapplication.setdefaultproperties指定的默认属性
所有的配置加载来源；
-
8、自动配置原理
配置文件到底能写什么？怎么写？自动配置原理；
1、自动配置原理
1）、springboot启动的时候加载主配置类，开启了自动配置功能==@enableautoconfiguration==
2）、@enableautoconfiguration作用：
-
利用autoconfigurationimportselector给容器中导入了一些组件？
-
-
可以查看selectimports（）方法的内容；
-
-
list<string> configurations = 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.securityrequestmatcherproviderautoconfiguration,\
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
# failure analyzers
org.springframework.boot.diagnostics.failureanalyzer=\
org.springframework.boot.autoconfigure.diagnostics.analyzer.nosuchbeandefinitionfailureanalyzer,\
org.springframework.boot.autoconfigure.jdbc.datasourcebeancreationfailureanalyzer,\
org.springframework.boot.autoconfigure.jdbc.hikaridriverconfigurationfailureanalyzer,\
org.springframework.boot.autoconfigure.session.nonuniquesessionrepositoryfailureanalyzer
# template availability providers
org.springframework.boot.autoconfigure.template.templateavailabilityprovider=\
org.springframework.boot.autoconfigure.freemarker.freemarkertemplateavailabilityprovider,\
org.springframework.boot.autoconfigure.mustache.mustachetemplateavailabilityprovider,\
org.springframework.boot.autoconfigure.groovy.template.groovytemplateavailabilityprovider,\
org.springframework.boot.autoconfigure.thymeleaf.thymeleaftemplateavailabilityprovider,\
org.springframework.boot.autoconfigure.web.servlet.jsptemplateavailabilityprovider
每一个这样的 xxxxautoconfiguration类都是容器中的一个组件，都加入到容器中；用他们来做自动配置；
3）、每一个自动配置类进行自动配置功能；
4）、以httpencodingautoconfiguration（http编码自动配置）为例解释自动配置原理；
@configuration//表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件
@enableconfigurationproperties(httpencodingproperties.class)//启用configurationproperties功能；将配置文件中对应的值和httpencidingproperties绑定起来；并把httpencodingproperties加入到ioc容器中
@conditionalonwebapplication(type = conditionalonwebapplication.type.servlet)//spring底层@conditional注解，根据不同的条件，如果满足指定条件，整个配置文件里面的配置就会生效；判断当前应用是否是web应用,如果是，当前配置类生效
@conditionalonclass(characterencodingfilter.class)//判断当前项目有没有这个类
//characterencodingfilter；springmvc中进行乱码解决的过滤器
@conditionalonproperty(prefix = "spring.http.encoding", value = "enabled", matchifmissing = true)//判断配置文件中是否存在某个配置spring.http.encoding.enabled;如果不存在，判断也是成立的
//即使我们配置文件中不配置spring.http.encoding.enabled=true,也是默认生效的；
public class httpencodingautoconfiguration {
//他已经和springboot的配置文件映射了
private final httpencodingproperties properties;
//只有一个有参构造器的情况下，参数的值就会从容器中拿
public httpencodingautoconfiguration(httpencodingproperties properties){
this.properties = properties;
}
@bean//给容器中添加一个组件，这个组件中的某些值需要从properties中获取
@conditionalonmissingbean//判断容器中没有这个组件？
public characterencodingfilter characterencodingfilter() {
characterencodingfilter filter = new orderedcharacterencodingfilter();
filter.setencoding(this.properties.getcharset().name());
filter.setforcerequestencoding(this.properties.shouldforce(type.request));
filter.setforceresponseencoding(this.properties.shouldforce(type.response));
return filter;
}
根据当前不同的条件判断，决定这个配置类是否生效？
一旦这个配置类生效；这个配置类就会给容器添加各种组件；这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的；
5）、所有在配置文件中能配置的属性都是在xxxxproperties类中封装着；配置文件能配置什么就可以参照某个功能对应的这个属性类
@configurationproperties(prefix = "spring.http.encoding")//从配置文件中获取指定的值和bean的属性进行绑定
public class httpencodingproperties {
public static final charset default_charset = standardcharsets.utf_8;
精髓
1）、springboot启动会加载大量的自动配置类
2）、我们看我们需要的功能有没有springboot默认写好的自动配置类；
3）、我们再来看这个自动配置类中到底配置了哪些组件；（只要我们要用的组件有，我们就不需要来配置了
4）、给容器中自动配置类添加组件的时候，会从properties类中获取某些属性，我们就可以在配置文件中指定这些属性的值；
xxxxautoconfigurartion:自动配置类；
给容器中添加组件
xxxxproperties:封装配置文件中的相关属性；
2、细节
1、@conditional派生注解（spring注解版原生的@conditional作用）
作用：必须是@conditional指定的条件成立，才给容器中添加组件，配置文件里面的配置内容才会生效；
自动配置类必须在一定的条件下才能生效；
我们怎么知道哪些自动配置类生效了？
我们可以通过启用debug=true属性；来让控制台打印自动配置报告，这样我们就知道哪些自动配置类生效；
============================
conditions evaluation report
============================
positive matches:（自动配置类启用的）
-----------------
codecsautoconfiguration matched:
- @conditionalonclass found required class 'org.springframework.http.codec.codecconfigurer'; @conditionalonmissingclass did not find unwanted class (onclasscondition)
codecsautoconfiguration.jacksoncodecconfiguration matched:
- @conditionalonclass found required class 'com.fasterxml.jackson.databind.objectmapper'; @conditionalonmissingclass did not find unwanted class (onclasscondition)
negative matches:（没有启动，没有匹配成功的自动配置类）
-----------------
activemqautoconfiguration:
did not match:
- @conditionalonclass did not find required classes 'javax.jms.connectionfactory', 'org.apache.activemq.activemqconnectionfactory' (onclasscondition)
aopautoconfiguration:
did not match:
- @conditionalonclass did not find required classes 'org.aspectj.lang.annotation.aspect', 'org.aspectj.lang.reflect.advice', 'org.aspectj.weaver.annotatedelement' (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;
日志实现：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、遗留问题
a(slf4j+logback):spring(commons-logging)、hibernate(jboss-logging)、mybatis、xxxx
统一日志记录，即使是别的框架和我们一起统一使用slf4j进行输出？
如何让系统中所有的日志都统一到slf4j;
==1、将系统中其他日志框架先排除出去；==
==2、用中间包来替换原有的日志框架；==
==3、我们导入slf4其他的实现==
3、springboot日志关系
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter</artifactid>
</dependency>
springboot使用它来做日志功能：
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-logging</artifactid>
<version>2.0.5.release</version>
<scope>compile</scope>
</dependency>
springboot底层依赖关系
总结：
1）、springboot底层也是使用slf4j+logback的方式进行日志记录
2）、springboot也把其他的日志都替换了成了slf4j;
3）、中间替换包？
public final class loggerfactory {
static final string codes_prefix = "http://www.slf4j.org/codes.html";
static final string no_staticloggerbinder_url = codes_prefix + "#staticloggerbinder";
4）、如果我们引入其他框架?一定要把这个框架的默认日志依赖移除掉？
spring框架用的是commons-logging;
springboot能自动适配所有的日志，而且底层使用slf4j+logback的记录方式记录日志，引入其他框架的时候，只需要把这个框架依赖的日志框架排除掉即可；
4、日志使用
1、默认配置
springboot默认帮我们配置好了日志；
@test
public void contextloads() {
//日志记录器
logger logger = loggerfactory.getlogger(getclass());
//日志的级别
//由低到高 trace<debug<info<warn<error
//可以调整输出的日志级别，日志就只会在这个级别及以后的高级别生效
logger.trace("这是trace日志...");
logger.debug("这是dubug日志...");
//springboot默认给我们使用的是info级别的，没有指定级别就用springboot默认规定的级别：root级别
logger.info("这是info日志。。。");
logger.warn("这是warn日志。。。");
logger.error("这是error日志。。。");
}
<pattern>%d{yyyy-mm-dd hh:mm:ss} %m-> %m%n</pattern>
以上格式说明如下：
| %m | 输出代码中指定的消息 |
|---|---|
| %p | 输出优先级，即debug，info，warn，error，fatal |
| %r | 输出自应用启动到输出该log信息耗费的毫秒数 |
| %c | 输出所属的类目，通常就是所在类的全名 |
| %t | 输出产生该日志事件的线程名 |
| %n | 输出一个回车换行符，windows平台为“\r\n”，unix平台为“\n” |
| %d | 输出日志时间点的日期或时间，默认格式为iso8601，也可以在其后指定格式，比如：%d{yyy mmm dd hh:mm:ss,sss}， 输出类似：2002年10月18日 22：10：28，921 |
| %l | 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：testlog4.main(testlog4.java:10) |
springboot 修改日志的默认配置
logging.level.org.wl= trace
#logging.file=d:springboot.log
#当前磁盘的根路径下创建spring文件夹和里面的log文件夹；使用spring.log作为默认文件
#logging.path=/spring/log
#指定文件中日志的输出格式
logging.pattern.console=
==logback依賴==
<dependency>
<groupid>ch.qos.logback</groupid>
<artifactid>logback-core</artifactid> <version>1.2.3</version>
</dependency>
<dependency>
<groupid>ch.qos.logback</groupid>
<artifactid>logback-access</artifactid>
<version>1.2.3</version>
</dependency>
<dependency>
<groupid>ch.qos.logback</groupid>
<artifactid>logback-classic</artifactid>
<version>1.2.3</version>
</dependency>
2、指定配置
给路径下放在每一个日志框架自己的配置文件即可；springboot 就不使用其他默认配置了
| logging system | customization |
|---|---|
| logback | logback-spring.xml, logback-spring.groovy, logback.xml, or logback.groovy |
| log4j2 | log4j2-spring.xml or log4j2.xml |
logback.xml:直接就被日志框架识别了；
logback-spring.xml:日志框架就不直接加载日志的配置项，由springboot解析日志配置，可以使用springboot的高级profile功能
<springprofile name="staging">
<!-- configuration to be enabled when the "staging" profile is active -->
</springprofile>
可以指定某段配置只在某个环境下生效
否则
no applicable active for [springprofile]
<appender name="stdout" class="ch.qos.logback.core.consoleappender">
<!--encoder 默认配置为patternlayoutencoder-->
<encoder>
<springprofile name="dev">
<pattern>===>>>>%d{yyyy-mm-dd hh:mm:ss.sss} %-5level %logger line:%-3l - %msg%n</pattern>
<charset>utf-8</charset>
</springprofile>
<springprofile name="!dev">
<pattern>===>%d{yyyy-mm-dd hh:mm:ss.sss} %-5level %logger line:%-3l - %msg%n</pattern>
<charset>utf-8</charset>
</springprofile>
</encoder>
<!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
<filter class="ch.qos.logback.classic.filter.thresholdfilter">
<level>debug</level>
</filter>
</appender>
5、切换日志框架
可以按照slf4j日志适配图，进行相关的切换；
slf4+log4的方式
切换成为log4j2
四、web开发
1、简介
使用springboot;
1)、创建springboot应用，选中我们需要的模块；
2）、springboot已经默认将这些场景配置好了？只需要在配置文件中指定少量配置就可以运行起来；
3）、自己编写业务代码；
自动配置原理？
这个场景springboot帮我们配置好了什么？能不能修改？能修改哪些配置？能不能扩展？xxx
xxxx.autoconfiguration:帮我们给容器中自动配置组件
xxxx.properties:配置类来封装配置文件的内容
2、springboot对静态资源的映射规则；
@configurationproperties(prefix = "spring.resources", ignoreunknownfields = false)
public class resourceproperties {
//可以设置和静态资源有关的参数，缓存时间等
@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));
}
}
private integer getseconds(duration cacheperiod) {
return (cacheperiod != null) ? (int) cacheperiod.getseconds() : null;
}
==1）、所有/webjars/**,都去classpath:/meta-inf/resources/webjars/找资源；==
webjars:以jar包的方式引入静态资源；
localhost:8081/webjars/jquery/3.3.1-1\jquery.js
<!-- 引入jquery-webjars-->在访问的时候只需要写webjars下面的内容即可
<dependency>
<groupid>org.webjars</groupid>
<artifactid>jquery</artifactid>
<version>3.3.1-1</version>
</dependency>
==2 、**"访问当前项目的任何资源，（静态资源的文件夹==）
"classpath:/meta-inf/resources/",
"classpath:/resources/",
"classpath:/static/",
"classpath:/public/"
"/"当前项目的根路径
localhost:8081/abc === 去静态资源文件夹里面找abc
==3) 、迎页：静态资源文件夹下的所有index.html
上一篇： 使用纯php代码实现页面伪静态的方法
下一篇： 使用图灵api创建微信聊天机器人