Springboot (持续更新)

一 Springboot入门

博客的学习来源于雷神2018年1月份录制的视频

1.简介

Springboot来简化Spring应用开发,约定大于配置去繁从简,just run 就能创建一个独立的,产品级别的应用.
背景:
J2EE笨重的开发,繁多的配置,低下的开发效率,复杂的部署流程,第三方技术集成难度大.
解决:“Spring全家桶” 时代
Spring Boot ->J2ee一站式解决方案
Spring Cloud -> 分布式整体解决方案

2.优点:

• 快速创建独立运行的Spring项目以及主流框架集成
• 使用嵌入式的Servlet容器,应用无需打成WAR包.
• starters自动依赖与版本控制
• 大量的自动配置,简化开发,也可修改默认值.
• 无需配置xml,无代码生成,开箱即用.
• 准生产环境运行时应用监控
• 与云计算的天然集成.

3.微服务

微服务的图形

微服务:架构风格(服务微化)
一个应用是一组小型服务,可以通过Http的方式进行互通.
单体应用:All IN one
微服务:每一个功能元素最终都是一个可独立替换和独立升级的软件单元.

4.springboot hello world

一个功能:
浏览器发送hello请求,服务器接受请求并处理,响应Hello World 字符串;

1) 创建一个maven工程; (jar)

2) 导入springboot的依赖.

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

3) 编写一个主程序main类 ,启动springboot应用

4) 编写相关的Controller,service类.

6) 点击运行

7) 简化部署

<!-- 这个插件,可以将应用打包成为一个可执行的jar包.-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

将这个应用打成jar包,这样就可以直接java-jar执行运行了.
1, 直接 进入命令窗口下jar包所在文件夹下

执行java -jar jar包名

5 探究刚才的Hello World

1.pom文件

2. 父项目

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
</parent>

然后它的父项目是下面parent

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-dependencies</artifactId>
		<version>1.5.9.RELEASE</version>
		<relativePath>../../spring-boot-dependencies</relativePath>
</parent>

继续父项目是下面dependencies

下面有很多依赖

SpringBoot的版本仲裁中心;
以后我们导入依赖默认是不需要写版本,(没有在dependencies里面管理的依赖自然需要申明版本号)
导入的依赖 (即启动器)

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

spring-boot-starter-web: 这个依赖也没有写版本号,因为spring帮我们仲裁.
spring-boot-starter : 场景启动器.帮我们导入了web模块正常运行时所需要的组件.
Spring Boot将所有的功能场景都抽取出来,做成一个个starters(启动器),只需要在项目里面引入这些starter相关场景的所有依赖都会导入进来.要用什么功能就导入什么场景的启动器.

2 主程序类,主入口类

package com.jimmy;

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

@SpringBootApplication // 标注一个主程序的类,说明这是一个springboot的应用.
public class HelloWorldMainApplication {
    public static void main(String[] args) {
        //Spring应用启动起来
        SpringApplication.run(HelloWorldMainApplication.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的配置类; (springboot定义的)
标注在某个类上,表示这是一个spring boot的配置类;
@Configuration 也表示配置类—配置文件; 配置类也是容器中的一个组件.@Component (spring定义的)
@EnableAutoConfiguration:开启自动配置功能;
以前我们需要配置的东西,Spring Boot帮我们自动配置, @EnableAutoConfiguration告诉SpringBoot开启自动配置功能;这样自动配置才能生效;
我们看一下源码 点进去看看 @EnableAutoConfiguration的组成.

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

1. 里面有一个注解==@AutoConfigurationPackage==: 叫自动配置包.
   我们在点进去看看@AutoConfigurationPackage 这个里面的重要组成是 @Import(AutoConfigurationPackages.Registrar.class)
   @Import是spring的的底层注解,给容器中导入一个组件,导入的组件由AutoConfigurationPackages.Registrar.class
   @AutoConfigurationPackage作用是将主配置类(即@SpringBootApplication标注的类)所在的包以及下面子包的所有组件,扫描到spring容器中

2. 我们看到@AutoConfigurationPackage下面也有 一个@Import(EnableAutoConfigurationImportSelector.class)
   EnableAutoConfigurationImportSelector:导入哪些组件的选择器;
   将所有需要导入的组件以全类名的方式返回,这些组件就会被添加到容器中.
   会给容器中导入非常多的自动配置类(xxxAUTOConfiguration);就是给容器中导入需要的所有组件,并配置好这些组件;
   
   有了自动配置类,免去了我们手动编写配置注入功能组件的工作.
   List configurations = SpringFactoriesLoader.loadFactoryNames(
   EnableAutoConfiguration.class, classLoader);
   Spring boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAUTOConfiguration指定的值,将这些值作为自动配置类导入到容器中,自动配置类就生效,帮我们进行自动配置工作,以前我们需要自己配置的东西,自动配置类都帮我们做了.
   J2EE的整体解决方案和自动配置都在D:\JavaProjects\maven\repository\org\springframework\boot\spring-boot-starter\1.5.9.RELEASE\spring-boot-starter-1.5.9.RELEASE.jar!\META-INF\spring.provides

6 使用Springboot Initializr 快速创建springboot项目

IntelliJ IDEA和eclipse都支持使用spring的项目创建向导快速创建一个Spring Boot项目.




然后下一步就是工程名 和存放路径填好之后,就可以点击finish.

接下来它就会联网,帮我们生成文件.
然后 我们可以把生成的文件中,我们不需要的东西 删除.

点开pom.xml文件后,我们可以看到生成了很多依赖,和配置文件

导入了最新的版本了.
我们可以看到主程序也生成好了.

接下来,我们来写自己的controller

package com.jimmy.springboot.controller;

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


//@Controller
//@ResponseBody
// Controller 和ResponseBody 配合起来的的作用和RestController一样
@RestController
public class MyController {
    @RequestMapping("/hello")
    public String hello(){
        return "hello world springboot";
    }
}

测试结果

所以我们创建项目,选择我们需要的模块,向导会联网创建Springboot项目;
默认生成的springboot 项目; 就会如下结构

我们只需要做我们自己的逻辑代码.
resources文件夹中目录结果
- static:保存所有的静态资源;js css images
- templates;保存所有的模版页面;(spring boot 默认jar使用嵌入式的tomcat,默认不支持jsp页面);可以使用模版引擎(freemarker,thymeleaf);
- application.properties: spring boot 的应用配置文件.
- 比如我们来修改端口号.
修改后的测试;

如果还用以前的访问就会找不到

二 springboot 的配置

配置文件

• SpringBoot使用一个全局的配置文件,配置文件名application是固定的；
  application.properties
  application.yml
  application.yaml
  配置文件的作用：修改SpringBoot自动配置的默认值；SpringBoot在底层都给我们自动配置好；

YAML

YAML（YAML Ain’t Markup Language）

​ YAML A Markup Language：是一个标记语言

​ YAML isn’t Markup Language：不是一个标记语言；

标记语言：

​ 以前的配置文件；大多都使用的是 xxxx.xml文件；

​ YAML：以数据为中心，比json、xml等更适合做配置文件；

YAML语法：

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

次等级的前面是空格，不能使用制表符(tab)

冒号之后如果有值，那么冒号和值之间至少有一个空格，不能紧贴着

字面量：普通的值（数字，字符串，布尔）

K:(空格)v 注意空格一定不能省略
字符串默认不用加上单引号或者双引号；
“”：双引号；特殊字符会作为本身想表示的意思

name: "zhangsan \n lisi"：输出；zhangsan 换行 lisi

‘’：单引号；特殊字符最终只是一个普通的字符串数据

name: ‘zhangsan \n lisi’：输出；zhangsan \n lisi

对象,Map(属性和值)
k: v在下一行来写对象的属性和值的关系；注意缩进

person:
  name: 张三
  gender: 男
  age: 22

行内写法

person: {name: 张三,gender: 男,age: 22}

数组（List、Set）

fruits:
  - 苹果
  - 桃子
  - 香蕉

行内写法

fruits: [苹果,桃子,香蕉]

配置文件值注入

我们可以提取导入一个配置文件处理器,这样我们在配置属性的时候就会有提示信息.

 <!--导入配置文件处理器，配置文件进行绑定就会有提示-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

比如我们输入l就会出现提示.


last-name和lastName的效果是一样的.

测试
javaBean

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

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

/*  将配置文件中(yml) 的每一个属性配置值 映射到这个组件上.
@ConfigurationProperties 作用:告诉springboot本类中的所有属性和配置文件中相关的配置进行绑定
后面跟一个指定的前缀.配置文件中哪个下面所有的属性配置进行一一映射. prefix = "person"
只有这个组件是容器中的组件(@Component),才能使用容器提供的@ConfigurationProperties
* */
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String lastName;
    private Integer age;
    private Boolean boos;
    private Date birth;

    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
    下面的get和set就不拷贝粘贴了

import com.jimmy.springboot.bean.Person;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
/*
* SpringBoot单元测试
* 可以在测试期间很方便的类似编码一样进行自动注入容器的功能.
* */
@SpringBootTest
class Springboot01YmlApplicationTests {

	@Autowired
	Person person;
	@Test
	void contextLoads() {
		System.out.println(person);
	}

}

server:
  port: 8081

person:
    boos: false
    birth: 2020/11/02

    maps: {k1: v1,k2: v2}
    lists:
      - 老婆
      - 孩子
      - 家人
    dog:
      name: 小狗
      age: 3
    last-name: 张三

测试结果:
Bean{lastName=‘张三’, age=null, boos=false, birth=Mon Nov 02 00:00:00 CST 2020, maps={k1=v1, k2=v2}, lists=[老婆, 孩子, 家人], dog=Dog{name=‘小狗’, age=3}}

下面我们来测试application.properties

首先把yml文件里面配置注销掉
全选 Cral+/

然后打开application.properties 配置person值.
可以看到有提示

server.port=8081
#配置Person的值
person.last-name=李四
person.age=30
person.boos=false
person.birth=2020/10/25
person.maps.key1=牛1
person.maps.key2=熊2
person.dog.name=小狗
person.dog.age=3
person.lists=a,b,c

@configurationProperties是可以获取值的.

继续test测试

结果如下 有乱码.
Bean{lastName=‘����’, age=30, boos=false, birth=Sun Oct 25 00:00:00 CST 2020, maps={key1=Å£1, key2=��2}, lists=[a, b, c], dog=Dog{name=‘��’, age=3}}

中文乱码解决方法：

在设置里面搜索 File Encoding

点击确定后,properties画面如下.

把文件改好在测试.

运行结果
Bean{lastName=‘李四’, age=30, boos=false, birth=Sun Oct 25 00:00:00 CST 2020, maps={key1=光头强, key2=熊2}, lists=[a, b, c], dog=Dog{name=‘小狗’, age=3}}
说明一下 上面是Bean的名字开头,是因为Person里面的toString 起的就是Bean名字

这里还有一个@Value注解也可以注入值. 这个是spring底层的功能

测试看到也得到了注入的值.
Bean{lastName=‘李四’, age=22, boos=true, birth=null, maps=null, lists=null, dog=null}

配置文件值注入两种方式对比

松散绑定：例如Person中有lastName属性，在配置文件中可以写成

lastName或lastname或last-name或last_name等等
如果properties配置文件里面有spel表达式
persion.age=#{2019-1986+1}
#--------------------使用@ConfigurationProperties注解，会抛出异常--------------------
#--------------------使用@value注解 OK--------------------

JSR303数据校验

@Validated // 这个注解代表,这个javaBean的属性需要校验.

我们看到得到的结果报错了, 因为 表上了@Email 必须是邮箱格式.

如果换成@Value取值呢? 把@ConfigurationProperties(prefix = “person”)注释掉.

看到校验是无效的,还是正常取到值(李四)了.

配置yml和properties都能提供获取值.
所以如果要校验,必须要用@ConfigurationProperties

@Value不能获取复杂类型的值

运行 报错

什么情况用@Value和@ConfigurationProperties

如果说,我们只是在某个业务逻辑中获取配置文件中的某项值,就使用@Value
如果说,我们专门编写一个javaBean来和配置文件进行映射,我们就直接使用@ConfigurationProperties.

例子 ,下面是推荐使用@Value注解

有一个业务类

运行结果

@PropertySource&@ImportResource

@PropertySource:加载指定的配置文件.
比如类路径下新建一个person.properties

然后呢在类上加上这个注解@PropertySource

或者也可以加载多个,写成数组的形式 .

上面2个运行结果都是正常

@ImportResource: 导入spring 配置文件, 让配置文件里面的内容都生效(就是以前写的springmvc.xml、applicationContext.xml).
我自己编写了一个service类,然后写了spring的beans.xml文件 ,测试能不能被识别


结果是false

springboot 里面没有spring的配置文件,我们自己编写的配置文件,也不能自动识别.
想让spring的配置生效,加载进来, @ImportResource标注在一个配置类上.

然后我们在测试

@ImportResource(locations = {“classpath:beans.xml”}) 导入spring的配置文件

现在spring boot不推荐使用下面xml配置文件.

spring boot推荐给容器中添加组件的方式,推荐使用全注解方式.

1. 首先需要 写一个配置类, 类似 之前spring配置文件xxx.xml
2. 使用@Bean给容器中添加组件
   例

import com.jimmy.springboot.service.HelloService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/*第一步要成为配置类,必须要加的.告诉springboot 指明当前类是一根配置类.
就是替代之前spring配置文件.
之前 在配置文件中加入组件是 在bean标签里面 <bean></bean>*/

@Configuration
public class MyAppConfig {
    // 将方法的返回值添加到容器中,容器中这个组件默认的id就是方法名.
    @Bean
    public HelloService helloService02(){
        return new HelloService();
    }
}

结果

配置文件占位符

1 随机数

${random.value}
${random.uuid}
${random.int}
${random.long}
${random.int(10)}
${random.int[1024,65536]}

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

测试

运行结果
Bean{lastName=‘李四5718b199543950951f500d7c59809e78’, age=-1058652128, boos=false, birth=Sun Oct 25 00:00:00 CST 2020, maps={key1=光头强$, key2=熊2}, lists=[a, b, c], dog=Dog{name=‘李四2edb5a3687360ad348769df2f21799d1_小狗’, age=3}}

如果写一个没有的值为怎么样呢?


如果没有值,我们也可以指定默认值. (使用:指定默认值)

Profile

Profile是spring对不同环境不同配置功能的支持,可以通过激活,指定参数等方式快速切换环境.

1 多profile文件

我们在主配置文件编写的时候,文件名可以是 application-{profile}.properties/yml (配置文件加上-环境标识)
例 :我们新建一个开发环境,和一个生产环境.

默认使用的还是application.properties的配置.

2. 我们要想启用生产和开发环境 需要激活

第一种方法:
在默认配置文件里面激活 spring.profiles.active=dev

运行测试

3. 如果用yml的话,会更简单一些. yml支持多文档块方式

可以看到 激活成功.

4 .还可以使用命令行方式激活

虽然yml里面还是指定的dev模式

但是我们来看看实际运行.

然后我们还可以打成jar 包,然后命令形式.
清空
然后双击pacgage

找到存放的位置




我们可以看到此时 yml 默认是prod 但是还是以命令形式来激活选用哪个环境.

5 还可以使用虚拟机参数 -Dspring.profiles.active=dev

配置文件加载位置

spring boot 启动会扫描一下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件.

下面来演示他们的层级关系.
这里又新建了3个application.properties文件,一共4个一样的.
但是他们位置不一样. 请看下图.

然后运行 最后是得到了8084

springboot会从这四个位置全部加载主配置文件: 然后还会形成互补配置.

列子

在8081端口号所在的配置文件 下面配置一个项目名 即项目访问路径.

随便写一个Controller类

测试

可以看到我们在8081端口下的配置起作用了. 而同样的内容,又会选择高版本的8085端口.
说明它们是互补的

springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件

–file:./config/

–file:./

–classpath:/config/

–classpath:/

优先级由高到底，高优先级的配置会覆盖低优先级的配置；

SpringBoot会从这四个位置全部加载主配置文件；互补配置；

6 我们还可以通过spring.config.location来改变默认的配置文件位置

项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；指定配置文件和默认加载的这些配置文件共同起作用形成互补配置；

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=F:/application.properties

例子:

idea里面也可以直接敲命令

7 外部配置加载顺序

SpringBoot支持多种外部配置方式.
SpringBoot也可以从以下位置加载配置； 优先级从高到低；高优先级的配置覆盖低优先级的配置，所有的配置会形成互补配置

1.命令行参数
所有的配置都可以在命令行上进行指定
java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --server.port=8087



多个配置用空格分开； --配置项=值
–server.port=8087 --server.servlet.context-path=/abc
例


但是这样如果操作太多命令,也不太好操作.

2.来自java:comp/env的JNDI属性

3.Java系统属性（System.getProperties()）

4.操作系统环境变量

5.RandomValuePropertySource配置的random.*属性值

由jar包外向jar包内进行寻找；

优先加载带profile

6.jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件

7.jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件

再来加载不带profile

8.jar包外部的application.properties或application.yml(不带spring.profile)配置文件

例

9.jar包内部的application.properties或application.yml(不带spring.profile)配置文件

10.@Configuration注解类上的@PropertySource

11.通过SpringApplication.setDefaultProperties指定的默认属性

所有支持的配置加载来源；

参考官方文档

8、自动配置原理

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

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

自动配置原理: 注意

1. SpringBoot启动的时候加载主配置类,开启了自动配置功能@EnableAutoConfiguration
2. @EnableAutoConfiguration作用: 利用EnableAUTOConfigurationImportSelector给容器中导入一些组件,

• 可以查看selectImports()方法的内容；

• List configurations = getCandidateConfigurations(annotationMetadata, attributes);获取候选的配置

需要注意的是现在spring2.0以上,源码已经修改了,上面说的是spring1.0的基础.

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.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
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.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.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.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.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.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
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.mobile.DeviceResolverAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.DeviceDelegatingViewResolverAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.SitePreferenceAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.reactor.ReactorAutoConfiguration,\
org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.SecurityFilterAutoConfiguration,\
org.springframework.boot.autoconfigure.security.FallbackWebSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.OAuth2AutoConfiguration,\
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.social.SocialWebAutoConfiguration,\
org.springframework.boot.autoconfigure.social.FacebookAutoConfiguration,\
org.springframework.boot.autoconfigure.social.LinkedInAutoConfiguration,\
org.springframework.boot.autoconfigure.social.TwitterAutoConfiguration,\
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.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration,\
org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.web.WebClientAutoConfiguration,\
org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.WebSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration

3. 每一个这样的xxxAUTOConfiguration类都是容器中的一个组件,都加入到容器中,用来做自动配置.
4. 以HttpEncodingAutoConfiguration(http编码自动配置)为例解释自动配置原理.

@Configuration(proxyBeanMethods = false) // 表示这是一个配置类, 也可以给容器中添加组件

@EnableConfigurationProperties(ServerProperties.class) //启用指定类的EnableConfigurationProperties功能
//ConfigurationProperties 将配置文件中对应的值和HttpEncodingproperties绑定起来.并加入到ioc容器中

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


@ConditionalOnClass(CharacterEncodingFilter.class) // 判断当前项目有没有这个类
//CharacterEncodingFilter;springMVC中进行乱码解决的过滤器

@ConditionalOnProperty(prefix = "server.servlet.encoding", value = "enabled", matchIfMissing = true) //判断当前文件中是否存在某个位置 spring.http.encoding.enable;如果不存在,判断也是成立的. // 即使我们配置文件中不配置spring.http.encoding.enable= true,也是默认生效的.

public class HttpEncodingAutoConfiguration {

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

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

	@Bean  // 给容器中添加一个组件,这个组件的某些值,需要从properties中获取
	@ConditionalOnMissingBean
	public CharacterEncodingFilter characterEncodingFilter() {
		CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
		filter.setEncoding(this.properties.getCharset().name());
		filter.setForceRequestEncoding(this.properties.shouldForce(Encoding.Type.REQUEST));
		filter.setForceResponseEncoding(this.properties.shouldForce(Encoding.Type.RESPONSE));
		return filter;
	}

根据当前不同的条件判断,决定这个配置类是否生效?

一旦这个配置类生效,这个配置类就会给容器中添加各种组件;这些组件的属性都是从对应的properties类中获取的,这些类里面的每一个属性又都是和配置文件绑定的. ==>SpringBoot的精髓

****精髓 :

1. SpringBoot启动会加载大量的自动配置类
2. 我们看我们需要的功能更有没有在springboot默认写好的自动配置类
3. 我们在来看这个自动配置类中到底配置了哪些组件,(只要有我们需要用的组件,就不需要在配置了.)
4. 给容器中自动添加组件的时候,会从properties类中获取属性,我们就可以从配置文件中指定这些属性的值.****

我们点进去看ServerProperties

@ConfigurationProperties(prefix = “server”, ignoreUnknownFields = true) 作用是从配置文件获取指定的值和bean的属性进行绑定.
所有在配置文件中能配置的属性都是在xxxxproperties类中封装,配置文件能配置什么就可以参照某个功能对应的这个属性类.

xxxxAutoConfiguration:自动配置类
给容器中添加组件
xxxxProperties:封装配置文件中相关属性

2、细节

1、@Conditional派生注解（Spring注解版原生的@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属性；来让控制台打印自动配置报告，这样我们就可以很方便的知道哪些自动配置类生效；

知识点

打jar包,要知道它的范围,它只打包类路径下的目录,工程下的不打包,因为不符合maven结构

三 日志

小张；开发一个大型系统；

​ 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…

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

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

日志门面： SLF4J；

日志实现：Logback；

SpringBoot：底层是Spring框架，Spring框架默认是用JCL；‘

​ SpringBoot选用 SLF4j和logback；

1. SLF4J使用

如何在系统中使用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、我们导入slf4j其他的实现

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>
		</dependency>

底层依赖关系

总结：

​ 1）、SpringBoot底层也是使用slf4j+logback的方式进行日志记录

​ 2）、SpringBoot也把其他的日志都替换成了slf4j；

​ 3）、中间替换包？

@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();  // 可以看到这里是 new 的SLF4J

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

​ Spring框架用的是commons-logging

<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<exclusions>
				<exclusion>
					<groupId>commons-logging</groupId>
					<artifactId>commons-logging</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

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

1、默认配置

SpringBoot默认帮我们配置好了日志, 我们可以来测试一下.


发现只打印了info开始的.

2 说明

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

  日志输出格式：
		%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.atguigu=trace


#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

运行结果 和上面一个我的截图可以对比着看

注意:上面配置文件里面,配置路径信息,最新版本配置有一点改动.

2、指定配置

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

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

运行结果

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

<springProfile name="staging">
    <!-- configuration to be enabled when the "staging" profile is active -->
  	可以指定某段配置只在某个环境下生效
</springProfile>

如：

<appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <!--
        日志输出格式：
			%d表示日期时间，
			%thread表示线程名，
			%-5level：级别从左显示5个字符宽度
			%logger{50} 表示logger名字最长50个字符，否则按照句点分割。 
			%msg：日志消息，
			%n是换行符
        -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <springProfile name="dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%n</pattern>
            </springProfile>
            <springProfile name="!dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%n</pattern>
            </springProfile>
        </layout>
    </appender>

现在高版本的springboot功能改了,使用logback.xml或者logback-spring.xml作为日志配置文件，功能都一样了

5、切换日志框架

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

第一种方式 slf4j+log4j的方式；

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <exclusions>
    <exclusion>
      <artifactId>logback-classic</artifactId>
      <groupId>ch.qos.logback</groupId>
    </exclusion>
    <exclusion>
      <artifactId>log4j-over-slf4j</artifactId>
      <groupId>org.slf4j</groupId>
    </exclusion>
  </exclusions>
</dependency>

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
</dependency>

可以先把不用的日志框架包和转换包jar 删除掉

在放上log4j的配置

第二种方式 切换为log4j2

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>spring-boot-starter-logging</artifactId>
                    <groupId>org.springframework.boot</groupId>
                </exclusion>
            </exclusions>
        </dependency>

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

可以先把不用的日志框架包和转换包jar 删除掉

上面2种方式只是知道可以这么用,但是不推荐使用.因为springboot集成的日志就很不错了

四 Spring Boot与Web开发

使用SpringBoot;
1) 创建一个springboot应用,选择我们需要的模块.
2) SpringBoot已经默认将这些场景配置好了.只需要在配置文件中指定少量配置就可以运行起来了.
3) 自己编写业务代码;
自动配置原理?
这个场景SpringBoot帮我们配置了什么?能不能修改? 能修改哪些配置?能不能扩展?..

xxxxAutoConfiguration：帮我们给容器中自动配置组件；
xxxxProperties:配置类来封装配置文件的内容；

2、SpringBoot对静态资源的映射规则；

@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties implements ResourceLoaderAware {
  //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));
			}
		}

1. , 所有/webjars/**,都去classpath:/META-INF/resources/webjars/找资源;
   webjars:以jar包的方式引入静态资源;
   我们可以去这个网站看看webjars网站
   可以以maven的形式拿到jquery
   
   可以看到下载完成后是这样的.
   
   好了 测试一下 访问路径:
   localhost:8080/webjars/jquery/3.5.1/jquery.js
   可以看到我们访问了 js的文件代码.
   

<!-- 引入webjars包 https://www.webjars.org/ 在访问的时候只需要写webjars下面资源的名称即可-->
		<dependency>
			<groupId>org.webjars</groupId>
			<artifactId>jquery</artifactId>
			<version>3.5.1</version>
		</dependency>

2. 如果是我们自己的静态资源如何访问呢? (静态资源的文件夹)
   参考下面这个源码类
   

"classpath:/META-INF/resources/",
			"classpath:/resources/", 
			"classpath:/static/",
			 "classpath:/public/"
			 

“/” 代表当前项目的根路径.
比如 localhost:8080/abc=== 去静态资源文件夹里面去找abc
例子 如下:

注意地址: localhost:8080/后面不用写static. 然后后面文件名称最好是负责过来.

3）、欢迎页； 静态资源文件夹下的所有index.html页面；被"/**"映射；
参考下面这个类

配置欢迎也映射

 //配置欢迎页映射
		@Bean
		public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext,
				FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
			WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(
					new TemplateAvailabilityProviders(applicationContext), applicationContext, getWelcomePage(),
					this.mvcProperties.getStaticPathPattern());
			welcomePageHandlerMapping.setInterceptors(getInterceptors(mvcConversionService, mvcResourceUrlProvider));
			welcomePageHandlerMapping.setCorsConfigurations(getCorsConfigurations());
			return welcomePageHandlerMapping;
		}

上面的getWelcomePage()方法

localhost:8080/ 找index页面


注意 如果都有index这个页面,是选择优先的加载.


加载顺序是

4) 所有的 **/favicon.ico 都是在静态资源文件下找 注意高版本的已经把这个方法去掉了. 但是 功能照着弄还是可以出来的.

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

			private final ResourceProperties resourceProperties;

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

			@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(this.resourceProperties.getFaviconLocations());
				return requestHandler;
			}

		}

1. 先把一个喜欢的图标放到resources下
   
   然后启动,刷新, 不行按ctrl+f5 就能出现自定义的图标了. (它主要是靠地址和,图片名字(favicon)来匹配的)
   

3、模板引擎

JSP、Velocity、Freemarker、Thymeleaf

SpringBoot推荐的Thymeleaf；
Thymeleaf它的特点语法更简单,功能更强大
Thymeleaf是一款用于渲染XML/XHTML/HTML5内容的模板引擎。类似JSP，
Velocity，FreeMaker等，它也可以轻易的与Spring MVC等Web框架进行集成
作为Web应用的模板引擎。与其它模板引擎相比，Thymeleaf最大的特点是能够
直接在浏览器中打开并正确显示模板页面，而不需要启动整个Web应用
Spring Boot推荐使用Thymeleaf、Freemarker等后现代的模板引擎技术；一但导入相
关依赖，会自动配置ThymeleafAutoConfiguration、FreeMarkerAutoConfiguration

怎么使用它(Thymeleaf)

1、引入thymeleaf；

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

就会自动生成如下

以前的低版本(2.0以下的SpringBoot)自动导入的是thymeleaf 的2.0以下,还需要 把thymeleaf改到高版本才行.就像下面那样配置

现在不需要了.

4、Thymeleaf使用

它的使用可以参考下面的源码

@ConfigurationProperties(prefix = "spring.thymeleaf")
public class ThymeleafProperties {

	private static final Charset DEFAULT_ENCODING = StandardCharsets.UTF_8;

	public static final String DEFAULT_PREFIX = "classpath:/templates/";

	public static final String DEFAULT_SUFFIX = ".html";
	//只要我们把html页面放在classpath:/templates/, thymleaf就能自动渲染

下面就来演示一下
Controller类下编写 一个方法

templates

运行

继续演示 thymeleaf的使用
1、导入thymeleaf的名称空间

  

其实我们如果不经过模版解析器直接打开它,它就是是直接显示div里面的信息,这就是模版解析器的作用.

5.语法规则

1) th:text;改变当前元素里面的文本内容;

th:任意html属性;来替换原生属性的值.
例如 继续细化上面的例子 可以th: 可以替换任意

然后再次运行:可以打开网页看源码 id和Class的值已经改变.得到我们想要的


上面说的转义和不转义特殊字符:可能 理解有点相反
意思就是 用th:text 就是输出字符串文本. 用th:text输出的是有语法格式的.

2）、表达式？

Simple expressions:（表达式语法）
重点是下面5种表达式.
    1 Variable Expressions: ${...}：获取变量值；OGNL；
    		1）、获取对象的属性、调用方法
    		2）、使用内置的基本对象：
    			#ctx : the context object.
    			#vars: the context variables.
                #locale : the context locale.
                #request : (only in Web Contexts) the HttpServletRequest object.
                #response : (only in Web Contexts) the HttpServletResponse object.
                #session : (only in Web Contexts) the HttpSession object.
                #servletContext : (only in Web Contexts) the ServletContext object.
              
                ${session.foo}
            3）、内置的一些工具对象：
				#execInfo : information about the template being processed.
				#messages : methods for obtaining externalized messages inside variables expressions, in the same way as they would be obtained using #{…} syntax.
				#uris : methods for escaping parts of URLs/URIs
				#conversions : methods for executing the configured conversion service (if any).
				#dates : methods for java.util.Date objects: formatting, component extraction, etc.
				#calendars : analogous to #dates , but for java.util.Calendar objects.
				#numbers : methods for formatting numeric objects.
				#strings : methods for String objects: contains, startsWith, prepending/appending, etc.
				#objects : methods for objects in general.
				#bools : methods for boolean evaluation.
				#arrays : methods for arrays.
				#lists : methods for lists.
				#sets : methods for sets.
				#maps : methods for maps.
				#aggregates : methods for creating aggregates on arrays or collections.
				#ids : methods for dealing with id attributes that might be repeated (for example, as a result of an iteration).

  2  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>
    
3    Message Expressions: #{...}：获取国际化内容
4    Link URL Expressions: @{...}：定义URL链接；
    		@{/order/process(execId=${execId},execType='FAST')}
5    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:
    No-Operation: _ 

表达式例子

小提示, div标签会独占一行,span标签不会.
我们可以看一下网页代码

6 SpringMVC自动配置 ( 这2节的源码分析 有点盟 比较是拷贝过来的)

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

1. Spring MVC auto-configuration

Spring Boot 自动配置好了SpringMVC
Spring Boot 自动配置好了SpringMVC

以下是SpringBoot对SpringMVC的默认配置:（WebMvcAutoConfiguration）

• Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.

  • 自动配置了ViewResolver（视图解析器：根据方法的返回值得到视图对象（View），视图对象决定如何渲染（转发？重定向？））
  • ContentNegotiatingViewResolver：组合所有的视图解析器的；
  • 如何定制：我们可以自己给容器中添加一个视图解析器；自动的将其组合进来；

• Support for serving static resources, including support for WebJars (see below).静态资源文件夹路径,webjars

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

• Custom Favicon support (see below). favicon.ico

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

  • Converter：转换器； public String hello(User user)：类型转换使用Converter
  • Formatter 格式化器； 2017.12.17===Date；

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

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

• Support for HttpMessageConverters (see below).

  • HttpMessageConverter：SpringMVC用来转换Http请求和响应的；User—Json；

  • HttpMessageConverters 是从容器中确定；获取所有的HttpMessageConverter；

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

• Automatic registration of MessageCodesResolver (see below).定义错误代码生成规则

• Automatic use of a ConfigurableWebBindingInitializer bean (see below).

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

初始化WebDataBinder；
请求数据=====JavaBean；

org.springframework.boot.autoconfigure.web：web的所有自动场景；

If you want to keep Spring Boot MVC features, and you just want to add additional MVC configuration (interceptors, formatters, view controllers etc.) you can add your own @Configuration class of type WebMvcConfigurerAdapter, but without @EnableWebMvc. If you wish to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter or ExceptionHandlerExceptionResolver you can declare a WebMvcRegistrationsAdapter instance providing such components.

If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc.

2、扩展SpringMVC

//这是之前配置springmvc的一些操作
 <mvc:view-controller path="/hello" view-name="success"/>
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/hello"/>
            <bean></bean>
        </mvc:interceptor>
    </mvc:interceptors>

那么现在我们如何用SpringBoot来扩展像之前 MVC配置那样比如加拦截器等等呢?
那么就要编写一个配置类（@Configuration），是WebMvcConfigurerAdapter类型；不能标注@EnableWebMvc
既保留了所有的自动配置，也能用我们扩展的配置；

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

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
       // super.addViewControllers(registry);
        //浏览器发送 /atguigu 请求来到 success
        registry.addViewController("/atguigu").setViewName("success");
    }
}

原理：

​ 1）、WebMvcAutoConfiguration是SpringMVC的自动配置类

​ 2）、在做其他自动配置时会导入；@Import(EnableWebMvcConfiguration.class)

@Configuration
	public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {
      private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();

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

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

​ 4）、我们的配置类也会被调用；

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

3、全面接管SpringMVC；

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

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

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

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
       // super.addViewControllers(registry);
        //浏览器发送 /atguigu 请求来到 success
        registry.addViewController("/atguigu").setViewName("success");
    }
}

原理：

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

1）@EnableWebMvc的核心

public @interface EnableWebMvc {

2）、

@Configuration
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {

3）、

@Configuration
@ConditionalOnWebApplication
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class,
		WebMvcConfigurerAdapter.class })
//容器中没有这个组件的时候，这个自动配置类才生效
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
		ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {

4）、@EnableWebMvc将WebMvcConfigurationSupport组件导入进来；

5）、导入的WebMvcConfigurationSupport只是SpringMVC最基本的功能；

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

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

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

​ 3）、在SpringBoot中会有很多的xxxCustomizer帮助我们进行定制配置

8. 默认访问首页的方法

第一种:在Controller里面写一个空方法.

第二种:

9. 引入资源怎么的写法.

10、国际化

1）、编写国际化配置文件；
2）、使用ResourceBundleMessageSource管理国际化资源文件
3）、在页面使用fmt:message取出国际化内容
步骤：
1）、编写国际化配置文件，抽取页面需要显示的国际化消息

2）、SpringBoot自动配置好了管理国际化资源文件的组件；

@ConfigurationProperties(prefix = "spring.messages")
public class MessageSourceAutoConfiguration {
    
    /**
	 * Comma-separated list of basenames (essentially a fully-qualified classpath
	 * location), each following the ResourceBundle convention with relaxed support for
	 * slash based locations. If it doesn't contain a package qualifier (such as
	 * "org.mypackage"), it will be resolved from the classpath root.
	 */
	private String basename = "messages";  
    //我们的配置文件可以直接放在类路径下叫messages.properties；
    
    @Bean
	public MessageSource messageSource() {
		ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
		if (StringUtils.hasText(this.basename)) {
            //设置国际化资源文件的基础名（去掉语言国家代码的）
			messageSource.setBasenames(StringUtils.commaDelimitedListToStringArray(
					StringUtils.trimAllWhitespace(this.basename)));
		}
		if (this.encoding != null) {
			messageSource.setDefaultEncoding(this.encoding.name());
		}
		messageSource.setFallbackToSystemLocale(this.fallbackToSystemLocale);
		messageSource.setCacheSeconds(this.cacheSeconds);
		messageSource.setAlwaysUseMessageFormat(this.alwaysUseMessageFormat);
		return messageSource;
	}

3）、去页面获取国际化的值；
注意看下图 取值.




如果乱码了 去设置里面设置

原理：

​ 国际化Locale（区域信息对象）；LocaleResolver（获取区域信息对象）

@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;
		}
默认的就是根据请求头带来的区域信息获取Locale进行国际化

然后需要我们自己写一个区域信息解析器. 点击链接切换国际化

package com.jimmy.springboot.component;


import org.springframework.lang.Nullable;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.LocaleResolver;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Locale;

public class MyLocaleResolver implements LocaleResolver {
    @Override
    public Locale resolveLocale(HttpServletRequest httpServletRequest) {
        String l = httpServletRequest.getParameter("l");
        Locale locale = Locale.getDefault() ; // 参数如果没有带,就获取系统默认的
        if (!StringUtils.isEmpty(l)){ // 判断是否为空.
            String[] split = l.split("_"); // 截取串串
            locale = new Locale(split[0], split[1]);
        }
        return locale;
    }

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

    }
}

11 登录功能

开发期间模板引擎页面修改以后，要实时生效

1）、禁用模板引擎的缓存

# 禁用缓存
spring.thymeleaf.cache=false 

2）、页面修改完成以后ctrl+f9：重新编译；

登陆错误消息的显示

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

为了防止表单重复提交,我们要在登录成功的时候改成重定向.



下一步加拦截器机制进行登陆检查,不能让它直接调到这个页面.

12 CRUD-员工列表

实验要求：

1）、RestfulCRUD：CRUD满足Rest风格；

URI： /资源名称/资源标识 HTTP请求方式区分对资源CRUD操作

	普通CRUD（uri来区分操作）	RestfulCRUD
查询	getEmp	emp—GET
添加	addEmp?xxx	emp—POST
修改	updateEmp?id=xxx&xxx=xx	emp/{id}—PUT
删除	deleteEmp?id=1	emp/{id}—DELETE

2）、实验的请求架构;

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

3）、员工列表：
thymeleaf公共页面元素抽取

1、抽取公共片段
<div th:fragment="copy">
&copy; 2011 The Good Thymes Virtual Grocery
</div>

2、引入公共片段
<div th:insert="~{footer :: copy}"></div>
~{templatename::selector}：模板名::选择器
~{templatename::fragmentname}:模板名::片段名

3、默认效果：
insert的公共片段在div标签中
如果使用th:insert等属性进行引入，可以不用写~{}：
行内写法可以加上：[[~{}]];[(~{})]；

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

th:insert：将公共片段整个插入到声明引入的元素中

th:replace：将声明引入的元素替换为公共片段

th:include：将被引入的片段的内容包含进这个标签中

<footer th:fragment="copy">
&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>
    &copy; 2011 The Good Thymes Virtual Grocery
    </footer>
</div>

<footer>
&copy; 2011 The Good Thymes Virtual Grocery
</footer>

<div>
&copy; 2011 The Good Thymes Virtual Grocery
</div>

下一步,我们要实现 点击列表上的栏位,出现颜色变化,表示选中.

下一步替换这些假的数据.

运行结果

下一步是我们需要把,日期格式改一下.

添加按钮样式

CRUD-员工添加