平凡的路。

springboot学习

SpringBoot入门

1,SpringBoot简介

简化spring应用的开发约定大于配置

优点:1,快速创建独立运行的spring项目

2,使用嵌入式的servlet容器,无需打包成war包

3,starter自定依赖和版本控制

4,大量的自动配置,简化开发

5,无需XML配置,无代码生成

6,生成环境的运行时监控

7,与云计算天然集成

缺点:入门简单,深入难

是整个spring技术栈的一个大整合

JAVA EE的一站式解决方案

2,微服务

微服务:架构风格

3,环境准备

Maven设置

IDEA设置

idea集成maven

4,springboot helloworld

1,用maven构建一个工程(jar)

2,导入springboot相关依赖

    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>1.5.9.RELEASEversion>
    parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
    dependencies>

3,编写一个主程序,启动spring boot

package com.controller;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class HelloworldStarter {

    public static void main(String[] args) {

        SpringApplication.run(HelloworldStarter.class,args);
    }
}

4,编写controller

package com.controller;


import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HomeController {
    
    @ResponseBody
    @RequestMapping("/hello")
    public String hello(){
        
        return "helloworld";
    }
}

5,运行主程序,进行测试

com.controller.HelloworldStarter

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.5.9.RELEASE)

2020-02-23 16:29:08.485  INFO 16920 --- [           main] com.controller.HelloworldStarter         : Starting HelloworldStarter on guojingwei with PID 16920 (C:\Users\Administrator\Desktop\springboothelloworld\target\classes started by 郭经伟 in C:\Users\Administrator\Desktop\springboothelloworld)
2020-02-23 16:29:08.535  INFO 16920 --- [           main] com.controller.HelloworldStarter         : No active profile set, falling back to default profiles: default
2020-02-23 16:29:08.800  INFO 16920 --- [           main] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@3d3fcdb0: startup date [Sun Feb 23 16:29:08 CST 2020]; root of context hierarchy
2020-02-23 16:29:10.791  INFO 16920 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat initialized with port(s): 8080 (http)
2020-02-23 16:29:10.819  INFO 16920 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2020-02-23 16:29:10.821  INFO 16920 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/8.5.23
2020-02-23 16:29:11.022  INFO 16920 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2020-02-23 16:29:11.022  INFO 16920 --- [ost-startStop-1] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 2238 ms
2020-02-23 16:29:11.215  INFO 16920 --- [ost-startStop-1] o.s.b.w.servlet.ServletRegistrationBean  : Mapping servlet: 'dispatcherServlet' to [/]
2020-02-23 16:29:11.221  INFO 16920 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'characterEncodingFilter' to: [/*]
2020-02-23 16:29:11.222  INFO 16920 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
2020-02-23 16:29:11.222  INFO 16920 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'httpPutFormContentFilter' to: [/*]
2020-02-23 16:29:11.222  INFO 16920 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'requestContextFilter' to: [/*]
2020-02-23 16:29:11.622  INFO 16920 --- [           main] s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@3d3fcdb0: startup date [Sun Feb 23 16:29:08 CST 2020]; root of context hierarchy
2020-02-23 16:29:11.680  INFO 16920 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/hello]}" onto public java.lang.String com.controller.HomeController.hello()
2020-02-23 16:29:11.684  INFO 16920 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error]}" onto public org.springframework.http.ResponseEntity> org.springframework.boot.autoconfigure.web.BasicErrorController.error(javax.servlet.http.HttpServletRequest)
2020-02-23 16:29:11.684  INFO 16920 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error],produces=[text/html]}" onto public org.springframework.web.servlet.ModelAndView org.springframework.boot.autoconfigure.web.BasicErrorController.errorHtml(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)
2020-02-23 16:29:11.714  INFO 16920 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2020-02-23 16:29:11.714  INFO 16920 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2020-02-23 16:29:11.747  INFO 16920 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**/favicon.ico] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2020-02-23 16:29:11.985  INFO 16920 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
2020-02-23 16:29:12.056  INFO 16920 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
2020-02-23 16:29:12.060  INFO 16920 --- [           main] com.controller.HelloworldStarter         : Started HelloworldStarter in 4.126 seconds (JVM running for 9.16)

6,简化部署

pom.xml中添加一个插件

        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.bootgroupId>
                    <artifactId>spring-boot-maven-pluginartifactId>
                plugin>
            plugins>
        build>

通过 maven packing成jar

通过java -jar 运行 springboot

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XZPWZYvr-1584596734828)(https://t1.picb.cc/uploads/2020/02/28/kvtFKM.png)]

5，HelloWorld探究

1,pom文件

1,父项目

<parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>1.5.9.RELEASEversion>
 parent>

spring boot 导入依赖默认不用导入依赖,当导入spring-boot-starter-parent里不含的jar包时

就得重新导入

2,导入依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
    dependencies>

spring-boot-starter:场景启动器:可以根据不同的场景导入不同的依赖

如spring-boot-starter-web/aop…

2,程序的主入口

package com.controller;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class HelloworldStarter {

    public static void main(String[] args) {

        SpringApplication.run(HelloworldStarter.class,args);
    }
}

声明了@SpringBootApplication才说明是springboot的启动类

SpringApplication.run这个方法是启动springboot应用

@SpringBootApplication:主配置类

@Target(ElementType.TYPE) //描述注解作用的位置 这里说明只作用于类上
@Retention(RetentionPolicy.RUNTIME)//被保留的位置 运行时才触发这个注解
@Documented //是否被抽取到api文档
@Inherited //是否被子类继承
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
		@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
    //默认这个@SpringBootApplication这个注解包括这几个注解

@SpringBootConfiguration

//标注在某个类上,说明是springboot 的配置类

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented 
@Configuration //配置类 类似于spring中的xml配置文件 spring容器配置类
public @interface SpringBootConfiguration {

}

@Configuration

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component //标明是一个组件类,配置类也是一个组件类
public @interface Configuration {

@EnableAutoConfiguration:开启自动配置功能:以前我们需要配置的东西

spring boot 帮我们配置

springboot 开启自动配置的类以前的ssm框架都是需要我们在xml中或者java类中配置

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage 
@Import(EnableAutoConfigurationImportSelector.class)//导入了这个类
public @interface EnableAutoConfiguration {

@AutoConfigurationPackage :自动配置包

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {

@Import(AutoConfigurationPackages.Registrar.class)

@Import是spring的底层注解:这个注解的作用是给spring的ioc容器导入一个组件类

AutoConfigurationPackages.Registrar.class

重点：将主配置文件(@SpringBootApplication) 定义的类的所在包以及子包里的所有组件扫描到容器中

@Import(EnableAutoConfigurationImportSelector.class)

这个代表导入哪些组件的选择器

将所有组件以全类名的方式返回,这些组件就会被扫描到容器中

会给容器导入非常多的自动配置类,就是给当前场景导入所需要的所有组件类，并帮我们配置组件类

有了自动配置类,就免去了手动配置组件功能类

SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, ClassLoader classLoader)

spring boot 在启动的时候自动加载类路径下的META-INF/spring.factories中获取EnableAutoConfiguration

指定的值,将这些值当做自动配置类导入容器,自动配置类生效,帮我们自动配置

java EE的自动配置都在spring-boot-autoconfig包里

6,使用spring initializr创建spring boot项目

二,配置文件

1,配置文件

spring的配置文件是全局配置文件,

配置文件的名字是固定的

application.properties 配置K=V

application.yml

配置文件的作用:就是修改springboot自动配置的默认值，springboot底层帮我们自动配置好了

YAML:是一个标记语言,又不是一个标记语言

标记语言:

以前的配置文件大多数用…xml

…yml是以数据为中心的配置文件

YAML:配置例子

server:
  port: 8081

XML:使用标签来配置

2,YAML语法

1,基本语法

K:(空格)V:表示一对键值对(空格必须有)

以空格的缩进来控制层级关系:只要左对齐的一列数据,都是同一层级的

server:
	port:8081
	path:/hello

属性和值也是大小敏感

2,值的写法

字面量:普通的值(数字,字符串,布尔)

k: v 字符串默认不加双引号和单引号

“”:双引号;会转义字符串里面的特殊字符:

""单引号:不会转义特殊字符

对象,Map(属性和值)(键值对)

k: v在下一行写对象的属性和值

friends:
		lastName: zhangsan
		age: 20

行内写法

frients: {lastName: zs,age: 18}

数组(List Set)

用-值表示数组中的一个元素

pets:
 - cat
 - dog
 - pig

行内写法

pets: [cat,dog,pig]

3,配置文件值注入

配置文件设置值:YAML

server:
  port: 8081
person:
  name: 小明
  age: 18
  boss: false
  map: {a: b,c: x}
  list:
    - dog
    - cat
  date: 2020/2/23
  dog:
    name: kiki
    age:  12

配置文件设置值:properties

person.name=张三
person.age=17
person.date=2020/2/23
person.boss=true
person.dog.name=小狗
person.dog.age=3
person.list=a,b,c
person.map.k1=v1
person.map.k2=v2

组件类和配置文件中的属性值进行绑定

获取配置文件的值

/**
 * FileName: Person
 * Author:   郭经伟
 * Date:     2020/2/23 21:13
 * Description:
 * History:
 *                               
 * 作者姓名           修改时间           版本号              描述
 */
package com.gjw.springbootinitializr.entity;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * 将配置文件中每一个属性的值都映射到这个组件中
 * @ConfigurationProperties(prefix = "person") 将配置文件中以person为前缀的属性值和这个组件绑定
 * 只有当前类为容器中的组件才能生效
 */
@Component
@ConfigurationProperties(prefix = "person")
public class Person {

    private String name;

    private Integer age;

    private Boolean boss;

    private Map<String,Object> map;

    private List<String> list;

    private Date date;

    private Dog dog; 
}

@value获取值和@configurationProperties获取值比较

	@value	@configurationProperties
功能	一个一个指定	批量注入配置文件中的值
松散绑定	不支持	支持
SpEL	支持	不支持
JSR303数据校验	不支持	支持
复杂类型的注入	不支持	支持

properties和yml都可以获取属性值

数据校验

@Component
@ConfigurationProperties(prefix = "person")
@Validated
public class Person {

    @Value("${person.name}")
    private String name;
    @Value("#{10*10}")
    private Integer age;
    @NotNull
    private Boolean boss;
    @Email
    private Map<String,Object> map;

    private List<String> list;

    private Date date;

    private Dog dog;

4,@propertySource和@ImportResource的区别

@propertySource:加载指定配置文件

@PropertySource("classpath:person.properties")
@Component
@Validated
public class Person {

    @Value("${person.name}")
    private String name;
    @Value("#{10*10}")
    private Integer age;
//    @NotNull
    private Boolean boss;
//    @Email
    private Map<String,Object> map;

    private List<String> list;

    private Date date;

    private Dog dog;

@ImportResource:导入spring的配置文件使其生效

需要定义在配置类上

默认spring的配置文件,不导入里面的组件不生效

@ImportResource("classpath:bean.xml")
@SpringBootApplication
public class SpringbootInitializrApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootInitializrApplication.class, args);
    }

}

spring boot 不推荐使用配置文件添加组件的方式

spring boot 推荐全注解的方式

配置文件(xml)===配置类

@Configuration
public class MyAppConfig {

    @Bean
    public HelloService helloService2(){

        return new HelloService();
    }
}

单元测试

@RunWith(SpringRunner.class)
@org.springframework.boot.test.context.SpringBootTest
public class SpringBootTest {

    @Autowired
    private Person person;
    @Autowired
    private ApplicationContext applicationContext;
    @Autowired
    private HelloService helloService;
    @Test
    public void test1(){

        System.out.println(person);
    }

    @Test
    public void test2(){

        System.out.println(applicationContext.containsBean("helloService2"));
    }
}

5,配置文件占位符

1,随机数

${random.uuid}${random.value}${random.int} ${random.long}

2,占位符获取之前配置的值,如果没有可以用:指定默认值

person.name=张三${random.uuid}
person.age=17
person.date=2020/2/23
person.boss=true
person.dog.name=小狗${person.hello:hello}
person.dog.age=3
person.list=a,b,c
person.map.k1=v1
person.map.k2=v2

6,Profile文件

profile文件是Spring对不同环境(开发,发布,测试)提供不同配置功能的支持

1,多profile文件形式

格式:application-{profile}.properties

如:application-dev.properties application-prod.properties

2,yml支持多文档块的方式

server:
  port: 8081
spring:
  profiles:
    active: dev

---

server:
  port: 8084
spring:
  profiles: dev
---
server:
  port: 8085
spring:
  profiles: prod

3,激活指定profile

配置文件激活profile

spring.profiles.active=dev

命令行激活profile

java -jar xxx.jar --spring.profiles.active=prod

虚拟机激活profile

Dspring.profiles.active=dev

7,配置文件加载的位置

spring boot 会加载以下位置的application.properties或者application.yml作为默认配置文件

-…/file/config

-…/file/

-classpath:/config/

-classpath:/

上面的优先级是按照高到低的方式,高的优先覆盖低的配置内容 ,互补配置

我们也可以通过配置spring.config.location来配置

8,外部加载配置文件顺序

SpringBoot也可以从以下位置加载配置；优先级从高到低；高优先级的配置覆盖低优先级的配置，所有的配置会形成互补配置

命令行参数

所有的配置都可以在命令行上进行指定
```
java -jar xxx.jar --server.port=8087  --server.context-path=/abc
```
1. 多个配置用空格分开； --配置项=值
2. 来自java:comp/env的JNDI属性
3. Java系统属性（System.getProperties()）
4. 操作系统环境变量
5. RandomValuePropertySource配置的random.*属性值
由jar包外向jar包内进行寻找；

再来加载不带profile
1. jar包外部的application.properties或application.yml(不带spring.profile)配置文件
2. **jar包内部的application.properties或application.yml(不带spring.profile)配置文件
优先加载带profile
1. **jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
2. **jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
3. @Configuration注解类上的@PropertySource
4. 通过SpringApplication.setDefaultProperties指定的默认属性
所有支持的配置加载来源：

参考官方文档

三,自动配置原理

配置文件到底能写什么？怎么写？自动配置原理；

配置文件能配置的属性参照

SpringBoot启动的时候加载主配置类,开启自动配置的功能

@SpringBootApplication
    @EnableAutoConfiguration

@EnableAutoConfiguration的作用

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

利用AutoConfigurationImportSelector.class给容器导入一些组件

getAutoConfigurationEntry方法中

protected AutoConfigurationEntry getAutoConfigurationEntry(
			AutoConfigurationMetadata autoConfigurationMetadata,
			AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
		List<String> configurations = getCandidateConfigurations(annotationMetadata,
				attributes);//获取候选的配置类(通过全类名返回)

getCandidateConfigurations方法(获取候选配置类)

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
			AnnotationAttributes attributes) {
		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
				getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());//这个方法获取候选配置类
		Assert.notEmpty(configurations,
				"No auto configuration classes found in META-INF/spring.factories. If you "
						+ "are using a custom packaging, make sure that file is correct.");
		return configurations;
	}

SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class,ClassLoader classLoader)

扫描所有jar包类路径下 META-INF/spring.factories，把扫描到的这些文件的内容包装成properties对象，从properties中获取到EnableAutoConfiguration.class（类名）对应的值，然后把它们添加在容器中

# 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.CloudServiceConnectorsAutoConfiguration,\
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,\

每一个这样的 xxxAutoConfiguration类都是容器中的一个组件，都加入到容器中；用他们来做自动配置；
每一个自动配置类进行自动配置功能；

以HttpEncodingAutoConfiguration(http编码自动配置为案例)解释自动配置案例

package org.springframework.boot.autoconfigure.web.servlet;

......

//表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件
@Configuration(
    proxyBeanMethods = false
)

/**
 * 启动指定类的ConfigurationProperties功能；
 * 将配置文件中对应的值和HttpProperties绑定起来；
 * 并把HttpProperties加入到ioc容器中
 */
@EnableConfigurationProperties({HttpProperties.class})

/**
 * Spring底层@Conditional注解
 * 根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效；
 * 判断当前应用是否是web应用，如果是，当前配置类生效
 */
@ConditionalOnWebApplication(
    type = Type.SERVLET
)

//判断当前项目有没有这个类
@ConditionalOnClass({CharacterEncodingFilter.class})

/**
 * 判断配置文件中是否存在某个配置  spring.http.encoding.enabled；如果不存在，判断也是成立的
 * 即使我们配置文件中不配置spring.http.encoding.enabled=true，也是默认生效的；
 */
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {

    //它已经和SpringBoot的配置文件映射了
    private final Encoding properties;

    //只有一个有参构造器的情况下，参数的值就会从容器中拿
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }

    @Bean     //给容器中添加一个组件，这个组件的某些值需要从properties中获取
    @ConditionalOnMissingBean    //判断容器有没有这个组件？（容器中没有才会添加这个组件）
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
        return filter;
    }

    ......

根据当前不同的条件判断，决定这个配置类是否生效
一但这个配置类生效；这个配置类就会给容器中添加各种组件；这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的；

所有在配置文件中能配置的属性都是在xxxxProperties类中封装着；配置文件能配置什么就可以参照某个功能对应的这个属性类

@ConfigurationProperties(
    prefix = "spring.http"
)
public class HttpProperties {
    private boolean logRequestDetails;
    private final HttpProperties.Encoding encoding = new HttpProperties.Encoding();

[总结]

SpringBoot启动会加载大量的自动配置类
我们看我们需要的功能有没有SpringBoot默认写好的自动配置类
再来看这个自动配置类中到底配置了哪些组件；（只要我们要用的组件有，我们就不需要再来配置了）
给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们就可以在配置文件中指定这些属性的值

xxxxAutoConfigurartion：自动配置类；

xxxxProperties:封装配置文件中相关属性；

[@Conditional派生注解]

作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置配里面的所有内容才生效；

@Conditional扩展注解	作用（判断是否满足当前指定条件）
@ConditionalOnJava	系统的java版本是否符合要求
@ConditionalOnBean	容器中存在指定Bean；
@ConditionalOnMissingBean	容器中不存在指定Bean；
@ConditionalOnExpression	满足SpEL表达式指定
@ConditionalOnClass	系统中有指定的类
@ConditionalOnMissingClass	系统中没有指定的类
@ConditionalOnSingleCandidate	容器中只有一个指定的Bean，或者这个Bean是首选Bean
@ConditionalOnProperty	系统中指定的属性是否有指定的值
@ConditionalOnResource	类路径下是否存在指定资源文件
@ConditionalOnWebApplication	当前是web环境
@ConditionalOnNotWebApplication	当前不是web环境
@ConditionalOnJndi	JNDI存在指定项

[查看那些自动配置类生效了]

自动配置类必须在一定的条件下才能生效；

我们怎么知道哪些自动配置类生效了；

我们可以通过配置文件启用 debug=true属性；来让控制台打印自动配置报告，这样我们就可以很方便的知道哪些自动配置类生效；

Positive matches ：（自动配置类启用的）

Negative matches`：（没有启动，没有匹配成功的自动配置类）

四,springboot日志配置

JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j…

日志门面（日志的抽象层）	日志实现（日志的实现层）
JCL（Jakarta Commons Logging SLF4j（Simple Logging Facade for Java） jboss-loggi	JUL（java.util.logging） Log4j Log4j2 Logback

左边选一个门面（抽象层）、右边来选一个实现；

例：SLF4j–>Logback

SpringBoot选用 SLF4j和logback

SLF4j使用

如何在系统中使用SLF4j ：https://www.slf4j.org

以后开发的时候，日志记录方法的调用，不应该来直接调用日志的实现类，而是调用日志抽象层里面的方法；

给系统里面导入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以后，配置文件还是做成日志实现框架自己本身的配置文件；

遗留问题

项目中依赖的框架可能使用不同的日志：

Spring（commons-logging）、Hibernate（jboss-logging）、MyBatis、xxxx

当项目是使用多种日志API时，可以统一适配到SLF4J，中间使用SLF4J或者第三方提供的日志适配器适配到SLF4J，SLF4J在底层用开发者想用的一个日志框架来进行日志系统的实现，从而达到了多种日志的统一实现。

如何让系统中所有的日志都统一到slf4j

将系统中其他日志框架先排除出去；
用中间包来替换原有的日志框架（适配器的类名和包名与替换的被日志框架一致）；
我们导入slf4j其他的实现

SpringBoot日志关系

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starterartifactId>
        dependency>

SpringBoot使用它来做日志功能；

    <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-loggingartifactId>
        dependency>

底层依赖关系

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cWzs0U4l-1584596734833)(https://t1.picb.cc/uploads/2020/02/28/kvtxhF.png)]

总结：

SpringBoot底层也是使用slf4j+logback的方式进行日志记录
SpringBoot也把其他的日志都替换成了slf4j；
中间替换包？

@SuppressWarnings("rawtypes")
public abstract class LogFactory {

    static String UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J = "http://www.slf4j.org/codes.html#unsupported_operation_in_jcl_over_slf4j";

    static LogFactory logFactory = new SLF4JLogFactory();Copy to clipboardErrorCopied

如果我们要引入其他框架？一定要把这个框架的默认日志依赖移除掉？

Spring框架用的是commons-logging；

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-coreartifactId>
            <exclusions>
                <exclusion>
                    <groupId>commons-logginggroupId>
                    <artifactId>commons-loggingartifactId>
                exclusion>
            exclusions>
        dependency>

SpringBoot能自动适配所有的日志，而且底层使用slf4j+logback的方式记录日志，引入其他框架的时候，只需要把这个框架依赖的日志框架排除掉即可；

日志使用

默认配置

SpringBoot默认帮我们配置好了日志；

    //记录器
    Logger logger = LoggerFactory.getLogger(getClass());
    @Test
    public void contextLoads() {
        //System.out.println();

        //日志的级别；
        //由低到高   trace
        //可以调整输出的日志级别；日志就只会在这个级别以以后的高级别生效
        logger.trace("这是trace日志...");
        logger.debug("这是debug日志...");
        //SpringBoot默认给我们使用的是info级别的，没有指定级别的就用SpringBoot默认规定的级别；root级别
        logger.info("这是info日志...");
        logger.warn("这是warn日志...");
        logger.error("这是error日志...");


    }
    日志输出格式：
        %d表示日期时间，
        %thread表示线程名，
        %-5level：级别从左显示5个字符宽度
        %logger{50} 表示logger名字最长50个字符，否则按照句点分割。 
        %msg：日志消息，
        %n是换行符
    -->
    %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n

SpringBoot修改日志的默认配置

# 也可以指定一个包路径 logging.level.com.xxx=error
logging.level.root=error


#logging.path=
# 不指定路径在当前项目下生成springboot.log日志
# 可以指定完整的路径；
#logging.file=G:/springboot.log

# 在当前磁盘的根路径下创建spring文件夹和里面的log文件夹；使用 spring.log 作为默认文件
logging.path=/spring/log

#  在控制台输出的日志的格式
logging.pattern.console=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n
# 指定文件中日志输出的格式
logging.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-5level === %logger{50} ==== %msg%n

logging.file	logging.path	Example	Description
(none)	(none)		只在控制台输出
指定文件名	(none)	my.log	输出日志到my.log文件
(none)	指定目录	/var/log	输出到指定目录的 spring.log 文件中

指定配置

给类路径下放上每个日志框架自己的配置文件即可；SpringBoot就不使用他默认配置的了

Logging System	Customization
Logback	`logback-spring.xml`, `logback-spring.groovy`, `logback.xml` or `logback.groovy`
Log4j2	`log4j2-spring.xml` or `log4j2.xml`
JDK (Java Util Logging)	`logging.properties`

logback.xml：直接就被日志框架识别了；

logback-spring.xml：日志框架就不直接加载日志的配置项，由SpringBoot解析日志配置，可以使用SpringBoot的高级Profile功能

<springProfile name="staging">
    
      可以指定某段配置只在某个环境下生效
springProfile>

如：

<appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        
        <layout class="ch.qos.logback.classic.PatternLayout">
            <springProfile name="dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%npattern>
            springProfile>
            <springProfile name="!dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%npattern>
            springProfile>
        layout>
    appender>

如果使用logback.xml作为日志配置文件，还要使用profile功能，会有以下错误

no applicable action for [springProfile]

切换日志框架

可以按照slf4j的日志适配图，进行相关的切换；

slf4j+log4j的方式；

<dependency>
  <groupId>org.springframework.bootgroupId>
  <artifactId>spring-boot-starter-webartifactId>
  <exclusions>
    <exclusion>
      <artifactId>logback-classicartifactId>
      <groupId>ch.qos.logbackgroupId>
    exclusion>
    <exclusion>
      <artifactId>log4j-over-slf4jartifactId>
      <groupId>org.slf4jgroupId>
    exclusion>
  exclusions>
dependency>

<dependency>
  <groupId>org.slf4jgroupId>
  <artifactId>slf4j-log4j12artifactId>
dependency>

切换为log4j2

   <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
            <exclusions>
                <exclusion>
                    <artifactId>spring-boot-starter-loggingartifactId>
                    <groupId>org.springframework.bootgroupId>
                exclusion>
            exclusions>
        dependency>

<dependency>
  <groupId>org.springframework.bootgroupId>
  <artifactId>spring-boot-starter-log4j2artifactId>
dependency>

五,Spring Boot Web开发

1,创建springboot应用,选择我们需要导入的模块,如:redis,JPA…

2,springboot已经帮我们把这些场景配置好了,我们只需要在配置文件中配置少量的配置web就能跑起来了

3,就可以编写业务代码了

web自动配置规则

WebMvcAutoConfiguration
WebMvcProperties
ViewResolver自动配置
静态资源自动映射
Formatter与Converter自动配置
HttpMessageConverter自动配置
静态首页
favicon
错误处理

SpringBoot对静态资源的映射规则

WebMvcAutoConfiguration类的addResourceHandlers方法：（添加资源映射）

        public void addResourceHandlers(ResourceHandlerRegistry registry) {
            if (!this.resourceProperties.isAddMappings()) {
                logger.debug("Default resource handling disabled");
            } else {
                Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
                CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
                if (!registry.hasMappingForPattern("/webjars/**")) {
                    this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{"/webjars/**"}).addResourceLocations(new String[]{"classpath:/META-INF/resources/webjars/"}).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
                }

                String staticPathPattern = this.mvcProperties.getStaticPathPattern();
                if (!registry.hasMappingForPattern(staticPathPattern)) {
                    this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{staticPathPattern}).addResourceLocations(WebMvcAutoConfiguration.getResourceLocations(this.resourceProperties.getStaticLocations())).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
                }

            }
        }

所有 /webjars/** ，都去 classpath:/META-INF/resources/webjars/ 找资源

webjars：以jar包的方式引入静态资源；

WebJars官网

例如:添加jquery的maven依赖

    <dependency>
            <groupId>org.webjarsgroupId>
            <artifactId>jqueryartifactId>
            <version>3.4.1version>
        dependency>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rpgE9Lvs-1584596734836)(https://t1.picb.cc/uploads/2020/02/28/kvtLfJ.png)]

访问地址对应就是：http://localhost:8080/webjars/jquery/3.4.1/jquery.js

非WebJars，自己的web资源怎么访问

资源配置类

@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties {

	private static final String[] CLASSPATH_RESOURCE_LOCATIONS = {
			"classpath:/META-INF/resources/", "classpath:/resources/",
			"classpath:/static/", "classpath:/public/" };

	/**
	 * Locations of static resources. Defaults to classpath:[/META-INF/resources/,
	 * /resources/, /static/, /public/].
	 */
	private String[] staticLocations = CLASSPATH_RESOURCE_LOCATIONS;

	/**
	 * Whether to enable default resource handling.
	 */
	private boolean addMappings = true;

	private final Chain chain = new Chain();

	private final Cache cache = new Cache();

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y7UEA7Ba-1584596734837)(https://t1.picb.cc/uploads/2020/02/28/kvtUA0.png)]

上图中添加的映射访问路径staticPathPattern值是/**，对应的资源文件夹就是上面配置类ResourceProperties中的CLASSPATH_RESOURCE_LOCATIONS数组中的文件夹：

数组中的值	在项目中的位置
classpath:/META-INF/resources/	src/main/resources/META-INF/resources/
classpath:/resources/	src/main/resources/resources/
classpath:/static/	src/main/resources/static/
classpath:/public/	src/main/resources/public/

localhost:8080/abc —> 去静态资源文件夹里面找abc

欢迎页映射

private Resource getIndexHtml(String location) {
			return this.resourceLoader.getResource(location + "index.html");
		}

		private boolean isReadable(Resource resource) {
			try {
				return resource.exists() && (resource.getURL() != null);
			}
			catch (Exception ex) {
				return false;
			}
		}

location就是静态资源路径，所以欢迎页的页面就是上面静态资源下的index.html，被/**映射，因此直接访问项目就是访问欢迎页!!!

网站图标映射

所有的 favicon.ico 都是在静态资源文件下找；

六,模板引擎

常见的模板引擎有JSP、Velocity、Freemarker、Thymeleaf

SpringBoot推荐使用Thymeleaf；

Thymeleaf

<dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-thymeleafartifactId>
 dependency>

**如需切换thymeleaf版本：**springboot2.0以上直接导入上面的就是thymeleaf3.0版本了

<properties>

        <thymeleaf.version>X.X.X.RELEASEthymeleaf.version>

        
        
        <thymeleaf-layout-dialect.version>2.2.2thymeleaf-layout-dialect.version>

  properties>

Thymeleaf使用

package org.springframework.boot.autoconfigure.thymeleaf;

......

@ConfigurationProperties(
    prefix = "spring.thymeleaf"
)
public class ThymeleafProperties {
    private static final Charset DEFAULT_ENCODING;
    public static final String DEFAULT_PREFIX = "classpath:/templates/";
    public static final String DEFAULT_SUFFIX = ".html";
    private boolean checkTemplate = true;
    private boolean checkTemplateLocation = true;
    private String prefix = "classpath:/templates/";
    private String suffix = ".html";
    private String mode = "HTML";

默认只要我们把HTML页面放在classpath:/templates/，thymeleaf就能自动渲染；

创建模板文件t1.html，并导入thymeleaf的名称空间
```
<html lang="en" xmlns:th="http://www.thymeleaf.org">
```


<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>

body>
html>

2.使用模板


<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>[[${title}]]title>
head>
<body>
<h1 th:text="${title}">h1>
<div th:text="${info}">这里的文本之后将会被覆盖div>
body>
html>

3.在controller中准备数据

@Controller
public class HelloT {

    @RequestMapping("/ht")
    public String ht(Model model) {
        model.addAttribute("title","hello Thymeleaf")
             .addAttribute("info","this is first thymeleaf test");
        return "t1";
    }
}

语法规则

th:text --> 改变当前元素里面的文本内容；

th：任意html属性 --> 来替换原生属性的值

标准表达式功能:

变量表达式：$ {…}

选择变量表达式：* {…}

消息表达式：＃{…}

链接⽹址表达式：@ {…}

⽚段表达式：〜{…}

Thymeleaf语法

在自己使用Thymeleaf语法时,我非常希望有一篇很全的Thymeleaf语法的总结,但很可惜没有找到,总是零零散散。贴上官方链接(比较长):Thymeleaf官方说明文档。现全面总结如下:

\1. 基本表达式

(1) 变量的表达式:${…}
用于访问容器上下文环境中的变量,例:

<span th:text="${information}"> servlet9大域对象

(2) 选择变量表达式:*{…}
选择表达式计算的是选定的对象 (th:object对象属性绑定的对象)

<div th:object="${session. user}" >
Name: <span th: text=" *{firstName}" >Sebastian.

Surname: <span th: text=" *{lastName}" >Pepper.

Nationality: <span th: text=" *{nationality}" >Saturn.

div>

(3) 信息表达式:#{…}
一般用于显示页面静态文本。将可能需要根据需求而整体变动的静态文本放在properties文件中,方便维护。通常与th:text属性一起使用。例如:
新建/WEB-INF/templates/home.html,段落:

<p th: text=" #{home. welcome}" >This text will not be show!

更多配置参考官方文档：https://www.thymeleaf.org/documentation.html

中文参考书册：https://www.lanzous.com/i7dzr2j

七,SpringMVC自动配置

Spring Boot为Spring MVC提供了自动配置，可与大多数应用程序完美配合。

以下是SpringBoot对SpringMVC的默认配置

org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration

自动配置在Spring的默认值之上添加了以下功能：

包含ContentNegotiatingViewResolver和BeanNameViewResolver。–> 视图解析器
支持服务静态资源，包括对WebJars的支持（官方文档中有介绍）。–> 静态资源文件夹路径
自动注册Converter，GenericConverter和Formatterbeans。–> 转换器，格式化器
支持HttpMessageConverters（官方文档中有介绍）。–> SpringMVC用来转换Http请求和响应的；User—Json；
自动注册MessageCodesResolver（官方文档中有介绍）。–> 定义错误代码生成规则
静态index.html支持。–> 静态首页访问
定制Favicon支持（官方文档中有介绍）。–> 网站图标
自动使用ConfigurableWebBindingInitializerbean（官方文档中有介绍）。

如果您想保留 Spring Boot MVC 的功能，并且需要添加其他 MVC 配置（拦截器，格式化程序和视图控制器等），可以添加自己的 WebMvcConfigurer 类型的 @Configuration 类，但不能带 @EnableWebMvc 注解。如果您想自定义 RequestMappingHandlerMapping、RequestMappingHandlerAdapter 或者 ExceptionHandlerExceptionResolver 实例，可以声明一个 WebMvcRegistrationsAdapter 实例来提供这些组件。

如果您想完全掌控 Spring MVC，可以添加自定义注解了 @EnableWebMvc 的 @Configuration 配置类。

视图解析器

视图解析器：根据方法的返回值得到视图对象（View），视图对象决定如何渲染（转发？重定向？）

自动配置了ViewResolver
ContentNegotiatingViewResolver：组合所有的视图解析器的；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aYgIC3mC-1584596734838)(https://t1.picb.cc/uploads/2020/03/02/kvhCVK.png)]

视图解析器从哪里来的？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VNngJ7Wt-1584596734838)(https://t1.picb.cc/uploads/2020/03/02/kvheMj.png)]

所以我们可以自己给容器中添加一个视图解析器；自动的将其组合进来

@Component
public class MyViewResolver implements ViewResolver {

    @Override
    public View resolveViewName(String s, Locale locale) throws Exception {
        return null;
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lzLoFjge-1584596734839)(https://t1.picb.cc/uploads/2020/03/02/kvhlPc.png)]

转换器、格式化器

Converter：转换器； public String hello(User user)：类型转换使用Converter（表单数据转为user）
Formatter 格式化器； 2017.12.17===Date；

        @Bean
        //在配置文件中配置日期格式化的规则
        @ConditionalOnProperty(prefix = "spring.mvc", name = "date-format")
        public Formatter<Date> dateFormatter() {
            return new DateFormatter(this.mvcProperties.getDateFormat());//日期格式化组件
        }

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

HttpMessageConverters

HttpMessageConverter：SpringMVC用来转换Http请求和响应的；User—Json；
HttpMessageConverters 是从容器中确定；获取所有的HttpMessageConverter；

自己给容器中添加HttpMessageConverter，只需要将自己的组件注册容器中（@Bean,@Component）

MessageCodesResolver

我们可以配置一个ConfigurableWebBindingInitializer来替换默认的；（添加到容器）

扩展SpringMVC

以前的配置文件中的配置

<mvc:view-controller path="/hello" view-name="success"/>

现在，编写一个配置类（@Configuration），是WebMvcConfigurer类型；不能标注@EnableWebMvc

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/hi").setViewName("success");
    }
}

访问：http://localhost:8080/hi

原理：

我们知道WebMvcAutoConfiguration是SpringMVC的自动配置类

下面这个类是WebMvcAutoConfiguration中的一个内部类

看一下@Import({WebMvcAutoConfiguration.EnableWebMvcConfiguration.class})中的这个类，

这个类依旧是WebMvcAutoConfiguration中的一个内部类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vpLvn8O7-1584596734841)(https://t1.picb.cc/uploads/2020/03/02/kvhIUG.png)]

重点看一下这个类继承的父类DelegatingWebMvcConfiguration

public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
    private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();

    public DelegatingWebMvcConfiguration() {
    }

    //自动注入，从容器中获取所有的WebMvcConfigurer
    @Autowired(
        required = false
    )
    public void setConfigurers(List<WebMvcConfigurer> configurers) {
        if (!CollectionUtils.isEmpty(configurers)) {
            this.configurers.addWebMvcConfigurers(configurers);
        }

    }

    ......

    /**
     * 查看其中一个方法
      * this.configurers：也是WebMvcConfigurer接口的一个实现类
      * 看一下调用的configureViewResolvers方法 ↓
      */
    protected void configureViewResolvers(ViewResolverRegistry registry) {
        this.configurers.configureViewResolvers(registry);
    }Copy to clipboardErrorCopied
    public void configureViewResolvers(ViewResolverRegistry registry) {
        Iterator var2 = this.delegates.iterator();

        while(var2.hasNext()) {
            WebMvcConfigurer delegate = (WebMvcConfigurer)var2.next();
            //将所有的WebMvcConfigurer相关配置都来一起调用；  
            delegate.configureViewResolvers(registry);
        }

    }

容器中所有的WebMvcConfigurer都会一起起作用；

我们的配置类也会被调用；

效果：SpringMVC的自动配置和我们的扩展配置都会起作用；

全面接管SpringMVC

SpringBoot对SpringMVC的自动配置不需要了，所有都是由我们自己来配置；所有的SpringMVC的自动配置都失效了

我们只需要在配置类中添加@EnableWebMvc即可；

@Configuration
@EnableWebMvc
public class MyMvcConfig implements WebMvcConfigurer

原理：

为什么@EnableWebMvc自动配置就失效了；

我们看一下EnableWebMvc注解类

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({DelegatingWebMvcConfiguration.class})
public @interface EnableWebMvc {
}

重点在于@Import({DelegatingWebMvcConfiguration.class})

DelegatingWebMvcConfiguration是WebMvcConfigurationSupport的子类

我们再来看一下springmvc的自动配置类WebMvcAutoConfiguration

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class})

//重点是这个注解，只有当容器中没有这个类型组件的时候该配置类才会生效
@ConditionalOnMissingBean({WebMvcConfigurationSupport.class})

@AutoConfigureOrder(-2147483638)
@AutoConfigureAfter({DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class, ValidationAutoConfiguration.class})
public class WebMvcAutoConfiguration

@EnableWebMvc将WebMvcConfigurationSupport组件导入进来；
导入的WebMvcConfigurationSupport只是SpringMVC最基本的功能；

如何修改SpringBoot的默认配置

SpringBoot在自动配置很多组件的时候，先看容器中有没有用户自己配置的（@Bean、@Component）如果有就用用户配置的，如果没有，才自动配置；如果有些组件可以有多个（ViewResolver）将用户配置的和自己默认的组合起来；

在SpringBoot中会有非常多的xxxConfigurer帮助我们进行扩展配置
在SpringBoot中会有很多的xxxCustomizer帮助我们进行定制配置

八,RestfulCRUD

默认访问index.html(需要配置模板引擎如thymeleaf)

//template文件夹下的文件默认是不能直接访问的,所有需要添加视图映射

//spring boot 2.0thymeleaf默认3.0

//扩展springmvc
//springboot2.0只需要实现WebMvcConfigurer这个接口的默认方法
//因为这个接口的方法都是default方法,所有直接覆盖想实现的方法就行了
@Configuration
public class WebMvcConfiger implements WebMvcConfigurer {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {

        registry.addViewController("/").setViewName("login");
        registry.addViewController("/index").setViewName("login");
        registry.addViewController("/index.html").setViewName("login");
    }
    
}

i18n国际化

编写国际化配置文件,抽取页面需要显示的国际化数据

SpringBoot已经帮我们写好了管理国际化资源文件的组件

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnMissingBean(
    name = {"messageSource"},
    search = SearchStrategy.CURRENT
)
@AutoConfigureOrder(-2147483648)
@Conditional({MessageSourceAutoConfiguration.ResourceBundleCondition.class})
@EnableConfigurationProperties
public class MessageSourceAutoConfiguration {
    private static final Resource[] NO_RESOURCES = new Resource[0];

    public MessageSourceAutoConfiguration() {
    }

    @Bean
    @ConfigurationProperties(
        prefix = "spring.messages"
    )
    public MessageSourceProperties messageSourceProperties() {
        return new MessageSourceProperties();
    }

    @Bean
    public MessageSource messageSource(MessageSourceProperties properties) {
        ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
        if (StringUtils.hasText(properties.getBasename())) {
            messageSource.setBasenames(StringUtils.commaDelimitedListToStringArray(StringUtils.trimAllWhitespace(properties.getBasename())));
        }

        if (properties.getEncoding() != null) {
            messageSource.setDefaultEncoding(properties.getEncoding().name());
        }

        messageSource.setFallbackToSystemLocale(properties.isFallbackToSystemLocale());
        Duration cacheDuration = properties.getCacheDuration();
        if (cacheDuration != null) {
            messageSource.setCacheMillis(cacheDuration.toMillis());
        }

        messageSource.setAlwaysUseMessageFormat(properties.isAlwaysUseMessageFormat());
        messageSource.setUseCodeAsDefaultMessage(properties.isUseCodeAsDefaultMessage());
        return messageSource;
    }

创建i18n文件夹存放配置文件，文件名格式为基础名(login)+语言代码(zh)+国家代码(CN)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KKysBj3G-1584596734844)(https://t1.picb.cc/uploads/2020/02/28/kvtDJd.png)]

在配置文件中添加国际化文件的位置和基础名

spring.messages.basename=i18n.login

如果配置文件中没有配置基础名，就在类路径下找基础名为message的配置文件

将页面文字改为获取国际化配置，格式#{key}

<form class="form-signin" action="dashboard.html">
			<img class="mb-4" src="asserts/img/bootstrap-solid.svg" alt="" width="72" height="72">
			<h1 class="h3 mb-3 font-weight-normal" th:text="#{tip}">Please sign inh1>
			<label class="sr-only">Usernamelabel>
			<input type="text" class="form-control" placeholder="Username" th:placeholder="#{username}" required="" autofocus="">
			<label class="sr-only">Passwordlabel>
			<input type="password" class="form-control" placeholder="Password" th:placeholder="#{password}" required="">
			<div class="checkbox mb-3">
				<label>
          <input type="checkbox" value="remember-me">[[#{remember}]]
        label>
			div>
			<button class="btn btn-lg btn-primary btn-block" type="submit" th:text="#{btn}">Sign inbutton>
			<p class="mt-5 mb-3 text-muted">© 2017-2018p>
			<a class="btn btn-sm">中文a>
			<a class="btn btn-sm">Englisha>
		form>

原理

国际化Locale（区域信息对象）；

LocaleResolver（获取区域信息对象的组件）；

在springmvc配置类WebMvcAutoConfiguration中注册了该组件

  @Bean
        /**
          *前提是容器中不存在这个组件，
　　　　　　*所以使用自己的对象就要配置@Bean让这个条件不成立（实现LocaleResolver 即可）
　　　　　　*/
        @ConditionalOnMissingBean

        /**
          * 如果在application.properties中有配置国际化就用配置文件的
          * 没有配置就用AcceptHeaderLocaleResolver 默认request中获取
          */
        @ConditionalOnProperty(
            prefix = "spring.mvc",
            name = {"locale"}
        )
        public LocaleResolver localeResolver() {
            if (this.mvcProperties.getLocaleResolver() == org.springframework.boot.autoconfigure.web.servlet.WebMvcProperties.LocaleResolver.FIXED) {
                return new FixedLocaleResolver(this.mvcProperties.getLocale());
            } else {
                AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
                localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
                return localeResolver;
            }
        }

默认的就是根据请求头带来的区域信息获取Locale进行国际化

  public Locale resolveLocale(HttpServletRequest request) {
        Locale defaultLocale = this.getDefaultLocale();
        if (defaultLocale != null && request.getHeader("Accept-Language") == null) {
            return defaultLocale;
        } else {
            Locale requestLocale = request.getLocale();
            List<Locale> supportedLocales = this.getSupportedLocales();
            if (!supportedLocales.isEmpty() && !supportedLocales.contains(requestLocale)) {
                Locale supportedLocale = this.findSupportedLocale(request, supportedLocales);
                if (supportedLocale != null) {
                    return supportedLocale;
                } else {
                    return defaultLocale != null ? defaultLocale : requestLocale;
                }
            } else {
                return requestLocale;
            }
        }
    }

点击切换语言

实现点击连接切换语言，而不是更改浏览器

修改页面，点击连接携带语言参数

            <a class="btn btn-sm" href="?l=zh_CN">中文a>
            <a class="btn btn-sm" href="?l=en_US">Englisha>

自己实现区域信息解析器

public class MyLocaleResolver implements LocaleResolver {

    @Override
    public Locale resolveLocale(HttpServletRequest httpServletRequest) {
        //获取请求参数中的语言
        String language = httpServletRequest.getParameter("l");
        //没带区域信息参数就用系统默认的
        Locale locale = Locale.getDefault();
        if (!StringUtils.isEmpty(language)) {
            //提交的参数是zh_CN （语言代码_国家代码）
            String[] s = language.split("_");

            locale = new Locale(s[0], s[1]);

        }

        return locale;
    }

    @Override
    public void setLocale(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Locale locale) {

    }
}

在配置类中将其注册到容器中

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("login");
        registry.addViewController("/index").setViewName("login");
        registry.addViewController("/index.html").setViewName("login");
    }

    @Bean
    public LocaleResolver localeResolver() {
        return new MyLocaleResolver();
    }

}

如果没有生效，请检查@Bean的那个方法的名称是否为localeResolver

实现登录功能

提供登录的controller

@Controller
public class UserController {

    @PostMapping("/user/login")
    public String login(@RequestParam String username, @RequestParam String password, HttpSession session, Model model) {
        if (!StringUtils.isEmpty(username) && "123456".equals(password)) {

            //登录成功，把用户信息方法哦session中，防止表单重复提交，重定向到后台页面
            session.setAttribute("loginUser", username);
            return "redirect:/main.html";
        }
        //登录失败,返回到登录页面
        model.addAttribute("msg", "用户名或密码错误！");
        return "login";
    }
}

修改表单提交地址，输入框添加name值与参数名称对应

        <form class="form-signin" action="dashboard.html" th:action="@{/user/login}" method="post">
            <img class="mb-4" src="asserts/img/bootstrap-solid.svg" alt="" width="72" height="72">
            <h1 class="h3 mb-3 font-weight-normal" th:text="#{login.tip}">Please sign inh1>
            <label class="sr-only">Usernamelabel>
            <input type="text" name="username" class="form-control" th:placeholder="#{login.username}" placeholder="Username" autofocus="">
            <label class="sr-only">Passwordlabel>
            <input type="password" name="password" class="form-control" th:placeholder="#{login.password}" placeholder="Password" required="">
            <div class="checkbox mb-3">
                <label>
          <input type="checkbox" value="remember-me"> [[#{login.remember}]]
        label>
            div>
            <button class="btn btn-lg btn-primary btn-block" type="submit" th:text="#{login.btn}">Sign inbutton>
            <p class="mt-5 mb-3 text-muted">© 2017-2018p>
            <a class="btn btn-sm" href="?l=zh_CN">中文a>
            <a class="btn btn-sm" href="?l=en_US">Englisha>
        form>

由于登录失败是转发，所以页面的静态资源请求路径会不正确，使用模板引擎语法替换

<link  href="asserts/css/bootstrap.min.css" th:href="@{/asserts/css/bootstrap.min.css}" rel="stylesheet">
<!-- Custom styles for this template -->
<link href="asserts/css/signin.css" th:href="@{/asserts/css/signin.css}" rel="stylesheet">

添加登录失败页面显示

<h1 class="h3 mb-3 font-weight-normal" th:text="#{login.tip}">Please sign inh1>

<p th:text="${msg}" th:if="${not #strings.isEmpty(msg)}" style="color: red">p>

修改页面立即生效

# 禁用缓存
spring.thymeleaf.cache=false
在页面修改完成以后按快捷键ctrl+f9，重新编译；

拦截器实现登录检查

实现拦截器

package cn.clboy.hellospringbootweb.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @Author cloudlandboy
 * @Date 2019/11/17 上午11:44
 * @Since 1.0.0
 */

public class LoginHandlerInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        Object loginUser = request.getSession().getAttribute("loginUser");
        if (loginUser == null) {
            //未登录，拦截，并转发到登录页面
            request.setAttribute("msg", "您还没有登录，请先登录！");
            request.getRequestDispatcher("/index").forward(request, response);
            return false;
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

注册拦截器

package cn.clboy.hellospringbootweb.config;

import cn.clboy.hellospringbootweb.interceptor.LoginHandlerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @Author cloudlandboy
 * @Date 2019/11/16 下午3:32
 * @Since 1.0.0
 */

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
    //定义不拦截路径
    private static final String[] excludePaths = {"/", "/index", "/index.html", "/user/login", "/asserts/**"};

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("login");
        registry.addViewController("/index").setViewName("login");
        registry.addViewController("/index.html").setViewName("login");
        registry.addViewController("/main.html").setViewName("dashboard");
    }

    @Bean
    public LocaleResolver localeResolver() {
        return new MyLocaleResolver();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //添加不拦截的路径，SpringBoot已经做好了静态资源映射，所以我们不用管
        registry.addInterceptor(new LoginHandlerInterceptor())
                .excludePathPatterns(excludePaths);
    }
}

在spring2.0+的版本中，只要用户自定义了拦截器，则静态资源会被拦截。但是在spring1.0+的版本中，是不会拦截静态资源的。

因此，在使用spring2.0+时，配置拦截器之后，我们要把静态资源的路径加入到不拦截的路径之中。

CRUD-员工列表

基于restful风格

实验功能	请求URI	请求方式
查询所有员工	emps	GET
查询某个员工(来到修改页面)	emp/1	GET
来到添加页面	emp	GET
添加员工	emp	POST
来到修改页面（查出员工进行信息回显）	emp/1	GET
修改员工	emp	PUT
删除员工	emp/1	DELETE

为了页面结构清晰，在template文件夹下新建emp文件夹，将list.html移动到emp文件夹下
将dao层和实体层java代码复制到项目中dao，entities

添加员工controller，实现查询员工列表的方法

@Controller
public class EmpController {

    @Autowired
    private EmployeeDao employeeDao;

    @GetMapping("/emps")
    public String emps(Model model) {
        Collection<Employee> empList = employeeDao.getAll();
        model.addAttribute("emps", empList);
        return "emp/list";
    }

}

修改后台页面，更改左侧侧边栏，将customer改为员工列表，并修改请求路径

<li class="nav-item">
    <a class="nav-link" th:href="@{/emps}">
        <svg .....>
            ......
        svg>
        员工列表
    a>
li>

同样emp/list页面的左边侧边栏是和后台页面一模一样的，每个都要修改很麻烦，接下来，抽取公共片段

thymeleaf公共页面抽取

语法

~{templatename::selector}：模板名::选择器

~{templatename::fragmentname}:模板名::片段名

/*公共代码片段*/
<footer th:fragment="copy">
    © 2011 The Good Thymes Virtual Grocery
footer>

/*引用代码片段*/
<div th:insert="~{footer :: copy}">div>

/*（〜{...}包围是完全可选的，所以上⾯的代码 将等价于：*/
<div th:insert="footer :: copy">div>

三种引入公共片段的th属性：

th:insert：将公共片段整个插入到声明引入的元素中
th:replace：将声明引入的元素替换为公共片段
th:include：将被引入的片段的内容包含进这个标签中

/*公共片段*/
<footer th:fragment="copy">
© 2011 The Good Thymes Virtual Grocery
footer>

/*引入方式*/
<div th:insert="footer :: copy">div>
<div th:replace="footer :: copy">div>
<div th:include="footer :: copy">div>


/*效果*/
<div>
    <footer>
    © 2011 The Good Thymes Virtual Grocery
    footer>
div>

<footer>
© 2011 The Good Thymes Virtual Grocery
footer>

<div>
© 2011 The Good Thymes Virtual Grocery
div>

后台页面抽取

将后台主页中的顶部导航栏作为片段，在list页面引入

dashboard.html：

        <nav th:fragment="topbar" class="navbar navbar-dark sticky-top bg-dark flex-md-nowrap p-0">
            <a class="navbar-brand col-sm-3 col-md-2 mr-0" href="http://getbootstrap.com/docs/4.0/examples/dashboard/#">Company namea>
            <input class="form-control form-control-dark w-100" type="text" placeholder="Search" aria-label="Search">
            <ul class="navbar-nav px-3">
                <li class="nav-item text-nowrap">
                    <a class="nav-link" href="http://getbootstrap.com/docs/4.0/examples/dashboard/#">Sign outa>
                li>
            ul>
nav>

list.html：

<body>

<div th:replace="dashboard::topbar">div>

......

使用选择器的方式抽取左侧边栏代码