SpringBoot文档

一、Spring Boot 入门

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}")
   @Email
   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}")
   @Email
   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也可以从以下位置加载配置:按照优先级从高到低;高优先级的配置覆盖低优先级的配置,所有配置会形成互补配置

  1. 命令行参数

    • 所有的配置都可以在命令行上进行指定;

    • 多个配置用空格分开; –配置项=值

    java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar 
    --server.port=8087 --server.context-path=/abc
    1234

    2.来自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)、以HttpEncodingAutoConfigurationHttp编码自动配置)为例解释自动配置原理;

@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} %p%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 SYSTEMCUSTOMIZATION
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包的方式引入静态资源;

https://www.webjars.org/

 

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页面;被“/**”映射;==

localhost:8080/找index页面

//配置欢迎页映射
@Bean
public WelcomePageHandlerMapping welcomePageHandlerMapping(
     ApplicationContext applicationContext) {
  return new WelcomePageHandlerMapping(
        new TemplateAvailabilityProviders(applicationContext),
        applicationContext, getWelcomePage(),
        this.mvcProperties.getStaticPathPattern());
}

==4)、所有的**/favicon.ico都是在静态资源文件下找==

//配置我们喜欢的图标
@Configuration
  @ConditionalOnProperty(value = "spring.mvc.favicon.enabled", matchIfMissing = true)
  public static class FaviconConfiguration implements ResourceLoaderAware {

     private final ResourceProperties resourceProperties;

     private ResourceLoader resourceLoader;

     public FaviconConfiguration(ResourceProperties resourceProperties) {
        this.resourceProperties = resourceProperties;
    }

     @Override
     public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

     @Bean
     public SimpleUrlHandlerMapping faviconHandlerMapping() {
        SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();
        mapping.setOrder(Ordered.HIGHEST_PRECEDENCE + 1);
//所有 **/favicon.ico         mapping.setUrlMap(Collections.singletonMap("**/favicon.ico",
              faviconRequestHandler()));
        return mapping;
    }

     @Bean
     public ResourceHttpRequestHandler faviconRequestHandler() {
        ResourceHttpRequestHandler requestHandler = new ResourceHttpRequestHandler();
        requestHandler.setLocations(resolveFaviconLocations());
        return requestHandler;
    }

     private List<Resource> resolveFaviconLocations() {
        String[] staticLocations = getResourceLocations(
              this.resourceProperties.getStaticLocations());
        List<Resource> locations = new ArrayList<>(staticLocations.length + 1);
        Arrays.stream(staticLocations).map(this.resourceLoader::getResource)
              .forEach(locations::add);
        locations.add(new ClassPathResource("/"));
        return Collections.unmodifiableList(locations);
    }

  }

}

3、模板引擎

JSP、Velocity、Freemarker、Thymeleaf;

 

 

SpringBoot推荐的Thymeleaf;

语法更简单、功能更强大;

1、引入thymeleaf;

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

 

2、Thymeleaf使用&语法

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就能自动渲染;

使用:

1、导入thymeleaf的名称空间

<html lang="en" xmlns:th="http://www.thymeleaf.org">

2、使用thymeleaf的语法

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
   <meta charset="UTF-8">
   <title>成功</title>
</head>
<body>
   <h1>成功</h1>
   <!--th:text将div里面的文本内容设置为-->
   <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.
      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
Page 20 of 106
#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}"
  <div th:object="${session.user}">
<p>Name: <span th:text="*{firstName}">Sebastian</span>.</p>
<p>Surname: <span th:text="*{lastName}">Pepper</span>.</p>
<p>Nationality: <span th:text="*{nationality}">Saturn</span>.</p>

</div>
  Message Expressions: #{...}获取国际化功能的
   
  Link URL Expressions: @{...}定义URL
  @{/order/process(execId=${execId},execType='FAST')}
   
  Fragment Expressions: ~{...}片段引用的表达式
  <div th:insert="~{commons :: main}">...</div>
   
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 106
  No-Operation: _

4、SpringMVC自动配置

https://docs.spring.io/spring-boot/docs/2.0.5.RELEASE/reference/htmlsingle/#boot-features-developing-web-applications

1、 Spring MVC Auto-configuration

SpringBoot自动配置好了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)).静态资源文件夹路径webjars

  • Static index.html support.静态首页访问

  • Custom Favicon support (covered later in this document).

  • 自动注册了 of Converter, GenericConverter, and Formatter beans.

    • Converter:转换器;public String hello(User user);类型转换使用Converter

    • Formatter:格式化器;2018.10.7====date

      @Bean
     @ConditionalOnMissingBean
     @ConditionalOnProperty(prefix = "spring.mvc", name = "locale")
     public LocaleResolver localeResolver() {
        if (this.mvcProperties
              .getLocaleResolver() == WebMvcProperties.LocaleResolver.FIXED) {
           return new FixedLocaleResolver(this.mvcProperties.getLocale());
        }
        AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
        localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
        return localeResolver;
    }

    ==自己添加的格式化转化器,我们只需要放在容器中即可==

  • 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).

    定义错误代码生成规则

  • 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 @Configurationannotated with @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>

==编写一个配置类(@Configuration),是WebMvcConfiguerAdapter类型;不能标注@EnableWebMvc==

==WebMvcConfigurerAdapter过期,使用新的WebMvcConfigurationSupport==

既保留了所有的自动配置,也能用我们的扩展配置;

//使用WebMvcConfigurationSupport可以扩展SpringMVC的功能
@Configuration
public class MyMvcConfig extends WebMvcConfigurationSupport {

   protected void addViewControllers(ViewControllerRegistry registry) {
       //浏览器发送/wl请求来到success
       registry.addViewController("/wl").setViewName("success");

  }

}

原理:

1)、WebMvcAutoConfiguration是SpringMVC自动配置类

2)、在做其他自动配置时会导入;@import(EnableWebMvcConfiguration.class)

@Configuration
public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {


//从容器中获取所有的WebMvcConfiguration
@Autowired(required = false)
public void setConfigurers(List<WebMvcConfigurer> configurers) {
if (!CollectionUtils.isEmpty(configurers)) {
this.configurers.addWebMvcConfigurers(configurers);
}//一个参考实现;将所有的WebMvcConfigurer相关配置都一起调用
}

3)、容器中所有的WebMvcConfiguration 都会一起起作用

4)、我们的配置类也会被调用;

效果:SpringMvc 的自动配置和我们的扩展配置都会起作用;

3 、全面接管SpringMVC

springBoot对springmvc的自动配置不需要了,所有都是我们自己配;所有的SpringMvc的自动配置都失效;我们需要在配置类中添加@EnableWebMvc即可

 

 

 

 

5、如何修改SpringBoot的默认配置

模式:

1)、SpringBoot再自动配置很多组件的时候,先看容器 中有没有用户自己配置的(@Bean、@Component)如果有就用用户配置的,如果没有,才自动配置;如果有些组件可以有多个(ViewResolver)将用户配置的和他自己默认的组合起来;

2)、在SpringBoot中会有非常多的xxxConfigurer帮助我们进行扩展配置;

 

 

 

 

posted @ 2018-12-04 15:09  rockpile  阅读(1060)  评论(1编辑  收藏  举报