SpringBoot笔记——（狂神说）—

路线

javase: OOPmysql:持久化
html+css+js+jquery+框架:视图，框架不熟练，css不好;

javaweb:独立开发MVC三层架构的网站了∶原始
ssm :框架:简化了我们的开发流程，配置也开始较为复杂;
war: tomcat运行
spring再简化: SpringBoot - jar:内嵌tomcat;微服务架构!服务越来越多: springcloud;

什么是SpringBoot？

什么是Spring
Spring是一个开源框架，2003年兴起的一个轻量级的Java开发框架，作者: Rod Johnson 。
Spring是为了解决企业级应用开发的复杂性而创建的，简化开发。

Spring是如何简化Java开发的
为了降低Java开发的复杂性，Spring采用了以下4种关键策略:
1、基于POJO的轻量级和最小侵入性编程;个
2、通过IOC，依赖注入(DI)和面向接口实现松耦合;
3、基于切面(AOP)和惯例进行声明式编程;
4、通过切面和模版减少样式代码;

SpringBoot呢，就是一个javaweb的开发框架，和SpringMVC类似，对比其他javaweb框架的好处，官方说是简化开发，约定大于配置, you can "just run"，能迅速的开发web应用，几行代码开发一个http接口。
所有的技术框架的发展似乎都遵循了一条主线规律:从个复杂应用场景衍生一种规范框架，人们只需要进行各种配置而不需要自己去实现它，这时候强大的配置功能成了优点;发展到一定程度之后，人们根据实际生产应用情况，选取其中实用功能和设计精华，重构出一些轻量级的框架;之后为了提高开发效率，嫌弃原先的各类配置过于麻烦，于是开始提倡“约定大于配置”，进而衍生出一些一站式的解决方案。
是的这就是Java企业级应用->J2EE-> spring-> springboot的过程。
随着Spring 不断的发展，涉及的领域越来越多，项目整合开发需要配合各种各样的文件，慢慢变得不那么易用简单，违背了最初的理念，甚至人称配置地狱。Spring Boot正是在这样的一个背景下被抽象出来的开发框架，目的为了让大家更容易的使用Spring、更容易的集成各种常用的中间件、开源软件;
Spring Boot基于Spring 开发，Spirng Boot本身并不提供Spring框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于Spring框架的应用程序。也就是说，它并不是用来替代Spring 的解决方案，而是和Spring框架紧密结合用于提升Spring 开发者体验的工具。SpringBoot以约定大于配置的核心思想，默认帮我们进行了很多设置，多数Spring Boot应用只需要很少的Spring 配置。同时它集成了大量常用的第三方库配置（例如Redis、MongoDB、Jpa、
RabbitMQ、Quartz等等)，Spring Boot应用中这些第三方库几乎可以零配置的开箱即用，

Spring Boot出生名门，从一开始就站在一个比较高的起点，又经过这几年的发展，生态足够完善，Spring Boot已经当之无愧成为Java领域最热门的技术。
Spring Boot的主要优点:
·为所有Spring开发者更快的入门
·开箱即用，提供各种默认配置来简化项目配置·内嵌式容器简化Web项目
·没有冗余代码生成和XML配置的要求

什么是微服务架构？

MVC、MVVM、

微服务是一种架构风格，它要求我们在开发一个应用的时候，这个应用必须构建成―系列小服务的组合;可以通过http的方式进行互通。要说微服务架构，先得说说过去我们的单体应用架构。

所谓单体应用架构(all in one)是指，我们将一个应用的中的所有应用服务都封装在一个应用中。
无论是ERP、CRM或是其他什么系统，你都把数据库访问，web访问，等等各个功能放到一个war包内。
·这样做的好处是，易于开发和测试;也十分方便部署;当需扩展时，只需要将war复制多份，然后放到多个服务器上，再做个负载均衡就可以了。
·单体应用架构的缺点是，哪怕我要修改一个非常小的地方，我都需要停掉整个服务，重新打包、部署这个应用war包。特别是对于一个大型应用，我们不可能吧所有内容都放在一个应用里面，我们如何维护、如何分工合作都是问题。

all in one的架构方式，我们把所有的功能单元放在一个应用里面。然后我们把整个应用部署到服务器上。如果负载能力不行，我们将整个应用进行水平复制，进行扩展，然后在负载均衡。
所谓微服务架构，就是打破之前all in one的架构方式，把每个功能元素独立出来。把独立出来的功能元素的动态组合，需要的功能元素才去拿来组合，需要多一些时可以整合多个功能元素。所以微服务架构是对功能元素进行复制，而没有对整个应用进行复制。
这样做的好处是:
1.节省了调用资源。
2.每个功能元素的服务都是一个可替换的、可独立升级的软件代码。

如何构建微服务
一个大型系统的微服务架构，就像一个复杂交织的神经网络，每一个神经元就是一个功能元素，它们各自完成自己的功能，然后通过http相互请求调用。比如一个电商系统，查缓存、连数据库、浏览页面、结账、支付等服务都是一个个独立的功能服务，都被微化了，它们作为一个个微服务共同构建了一个庞大的系统。如果修改其中的一个功能，只需要更新升级其中一个功能服务单元即可。
但是这种庞大的系统架构给部署和运维带来很大的难度。于是,spring为我们带来了构建大型分布式微服务的全套、全程产品:
·构建一个个功能独立的微服务应用单元，可以使用springboot，可以帮我们快速构建一个应用;

.大型分布式网络服务的调用，这部分由spring cloud来完成，实现分布式;
·在分布式中间，进行流式数据计算、批处理，我们有spring cloud data flow。

. spring为我们想清楚了整个从开始构建应用到大型分布式应用全流程方案。

快速入门和基础

创建项目

官方提供了一个快速构建项目的网站： Idea也集成了

https://start.spring.io/

创建项目可勾选依赖，web的依赖勾选上。官网下载zip解压后idea中项目中import module导入pom文件或导入根目录选maven即可然后pom文件中右键add as maven项目即可。或idea在项目中直接创建一个spring initoliar相同方式，选maven和jar和java版本springboot版本和依赖。

写代码

在引导类同级目录下创建包写代码

启动

直接运行引导类即可

Tomcat started on port(s): 8080 (http) with context path '' 访问8080即可，且默认无项目虚拟路径。

springboot项目内置了tomcat可独立运行：

或者使用maven的打包后，找到该jar包的根目录，然后敲cmd，然后使用java -jar 运行即可，如下：

C:\Users\kongdeyi\Desktop\IdeaProject666\spring-boot\quickstart\target>java -jar .\quickstart-0.0.1-SNAPSHOT.jar

引导类和pom文件

引导类本身就是一个bean ，@SpringBootApplication中有@Config注解。
<parent>有一个父项目，gav坐标（grout、artifict，verson），

spring-boot-starter依赖为启动器
所有的springboot的依赖都是以spring-boot-starter-开头的。
. dependencies:项目具体依赖，这里包含了spring-boot-starter-web用于实现HTTP接口（该依赖中包含了Spring MVC)，官网对它的描述是:使用Spring MVC构建Web (包括RESTful)
应用程序的入门者，使用Tomcat作为默认嵌入式容器。集成了tomcat.dispatcherServLet， xmL......; spring-boot-starter-test用于编写单元测试的依赖包。更多功能模块的使用我们将在后面逐步展开。
o build:构建配置部分。默认使用了spring-boot-maven-plugin，配合spring-boot-starter-parent就可以把Spring Boot应用打包成JAR来直接运行。

application配置文件

properties和yml和yaml都可

改端口号

server.prot

改banner

resource根目录下键banner.txt文件，复制下面网站选择好看的bannercopy后粘贴即可。Ascii艺术字实现个性化Spring Boot启动banner图案，轻松修改更换banner.txt文件内容，收集了丰富的banner艺术字和图，并且支持中文banner下载，让你的banner好玩儿更有意思。-bootschool.net

1、spring-boot-dependencies核心依赖在父工程中，这就是在引入很多依赖时为什么不用写版本号。
2、pom的parent（spring-boot-starter-parent）点进去，里面还有一个parent（spring-boot-dependencies）再点进去，这里管理了大量的jar包版本。
3、spring-boot-starter-paren里面配置了资源过滤application.yml. . .还有很多东西
pom中的springboot启动器如spring-boot-start，可自己去写。说白了就是Springboot的启动场景;. springboot会将所有的功能场景，都变成一个个的启动器。我们要使用什么功能，就只需要找到对应的启动器就可以了。可参考下面网址的start启动器：
https://docs.spring.io/spring-boot/docs/2.2.0.RELEASE/reference/html/using-spring-boot.html#using-boot-starter

自动装配原理

启动类

@SpringBootApplication点进去，除了@Target({ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@Inherited四个标准注解外还有@ComponentScan扫描的注解外，就剩下了两个核心组合注解：@SpringBootConfiguration @EnableAutoConfiguration。

对于@SpringBootConfiguration注解中有一个@Configuration，说明引导类为配置类，点进去@Configuration，只有一个@Component，说明引导类也是一个组件。

对于@EnableAutoConfiguration，见名知意自动配置。点进去，发现除了4个元注解外，

有@AutoConfigurationPackage自动配置包和@Import({AutoConfigurationImportSelector.class})导入选择器两个注解。

其中@AutoConfigurationPackage中点进去有个@Import({Registrar.class})导入自动注册配置包。

其中@Import({AutoConfigurationImportSelector.class})才是核心，我们跟进参数中的AutoConfigurationImportSelector.class自动导入选择器类跟进，

有个selectImports选择组件的方法，这里加载了一些元数据。

往下还有个getAutoConfigurationEntry获得自动配置实体方法中有行代码为：

List<String> configurations = this.getCandidateConfigurations(annotationMetad ata, attributes); //这个getCandidateConfigurations为获取候选的配置，

我们跟进这个getCandidateConfigurations方法：
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    //可在左侧依赖中，找到Maven: org.springframework.boot:spring-boot-autoconfigure:2.5.4中META-INF中的spring-factories中搜索WebMvcAutoConfiguration后跟进这个类，里面有很多配置，还能找到如WebMvcProperties跟进这个类
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.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;
    }
protected Class<?> getSpringFactoriesLoaderFactoryClass() {  
        return EnableAutoConfiguration.class;    //标柱了的类，就可获取其类下面的所有配置，比如引导类。
    }
其中的loadFactoryNames方法，获取所有的加载配置
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoader == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }

        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }
其中又有个loadSpringFactories方法位于同Java文件下，下面三行代码的位置，这个方法有个 classLoader.getResources("META-INF/spring.factories");来获取系统资源和项目资源。然后使用了一个while(urls.hasMoreElements()) {}从这些资源中遍历了所有的nextElement元素，自动配置，遍历完后封装为Properties供我们使用。

可在左侧依赖中，找到Maven: org.springframework.boot:spring-boot-autoconfigure:2.5.4中META-INF中的spring-factories中搜索WebMvcAutoConfiguration后跟进这个类，里面有很多配置，还能找到如WebMvcProperties跟进这个类

思考:这么多自动配置为什么有的没有生效，需要导入对应的start才能有作用？

因为spring-factories中的配置的这些类中基本都使用@ConditionalOnXXX来判断，判断条件成立才会加载这个类，才会生效:详见https://www.cnblogs.com/zjdxr-up/p/15685923.html

package org.springframework.boot.autoconfigure.condition

@ConditionalOnBean: 当容器中有指定的Bean的条件下

@ConditionalOnClass：当类路径下有指定的类的条件下

@ConditionalOnExpression:基于SpEL表达式作为判断条件

@ConditionalOnJava:基于JVM版本作为判断条件

@ConditionalOnJndi:在JNDI存在的条件下查找指定的位置

@ConditionalOnMissingBean:当容器中没有指定Bean的情况下

@ConditionalOnMissingClass:当类路径下没有指定的类的条件下

@ConditionalOnNotWebApplication:当前项目不是Web项目的条件下

@ConditionalOnProperty:指定的属性是否有指定的值

@ConditionalOnResource:类路径下是否有指定的资源

@ConditionalOnSingleCandidate:当指定的Bean在容器中只有一个，或者在有多个Bean的情况下，用来指定首选的Bean

@ConditionalOnWebApplication:当前项目是Web项目的条件下

那么多的自动配置类，必须在一定的条件下才能生效;也就是说，我们加载了这么多的配置类，但不是所有的都生效了。

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

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

然后启动项目，就会打印出三种：

Positive matches:代表已经启用且生效的

Negative matches:代表没有匹配成功的类没生效的可能没引依赖

Unconditional classes:代表没有条件的

结论

springboot所有自动配置都是在启动的时候扫描并加载: spring. factories所有的自动配置类都在这里面，但是不一定生效，要判断条件是否成立，只要导入了对应的start，就有对应的启动器了，有了启动器，我们自动装配就会生效，然后就配置成功!

springboot在启动的时候，从类路径下/META-INF/ spring.factories获取指定的值;
将这些自动配置的类导入容器，自动配置就会生效，帮我进行自动配置!
以前我们需要自动配置的东西，现在springboot帮我们做了!
整合javaEE，解决方案和自动配置的东西都在spring-boot-autoconfigure-2.2.0.RELEASE.jar这个包下
它会把所有需要导入的组件，以类名的方式返回，这些组件就会被添加到容器;
容器中也会存在非常多的xxxAutoConfiguration的文件(内部很多的方法加了@Bean)，就是这些类给容器中导入了这个场景需要的所有组件;并自动配置，@Configuration, JavaConfig!
有了自动配置类，免去了我们手动编写配置文件的工作!

这就是自动装配的原理!

1) . SpringBoot启动会加载大量的自动配置类
2)、我们看我们需要的功能有没有在SpringBoot默认写好的自动配置类当中;
3)、我们再来看这个自动配置类中到底配置了哪些组件;(只要我们要用的组件存在在其中，我们就不需要再手动配置了)
4)、给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们只需要在配置文件中指定这些属性的值即可;
xxxxAutoConfigurartion:自动配置类;给容器中添加组件

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

主启动类怎么运行？

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

SpringApplication

这个类主要做了以下四件事情
1.推断应用的类型是普通的项目还是Web项目

在其有参构造方法中判断改项目是不是web项目。

this.webApplicationType = WebApplicationType.deduceFromClasspath();

2.查找并加载所有可用初始化器，设置到initializers属性中

3.找出所有的应用程序监听器，设置到listeners属性中
    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        this.sources = new LinkedHashSet();
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        this.addCommandLineProperties = true;
        this.addConversionService = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = Collections.emptySet();
        this.isCustomEnvironment = false;
        this.lazyInitialization = false;
        this.applicationContextFactory = ApplicationContextFactory.DEFAULT;
        this.applicationStartup = ApplicationStartup.DEFAULT;
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        this.bootstrapRegistryInitializers = this.getBootstrapRegistryInitializersFromSpringFactories();
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }
4.推断并设置main方法的定义类，找到运行的主类

可参考下面博客的springboot启动流程图

springboot启动流程源码解析（带流程图）_springboot启动流程图_wuweixianzheng的博客-CSDN博客

yaml语法讲解

springboot的所有配置可参考下面官网：

Spring Boot Reference Guide

之前：

标记语言
以前的配置文件，大多数都是使用xml来配置;比如一个简单的端口配置，我们来对比下yaml和xmlyaml配置:
server:
        prot: 8080
xml配置:
<server>
        <port>8081<port> 

</server>

创建application.yml文件

官方推荐yml而不是properties，且properties只能保存键值对而且还容易乱码，我们删除application.properties，resource下新建application.yml文件

yml语法

可参见SpringBoot基础认识_阳光明媚UPUP的博客-CSDN博客

key冒号空格value ，层级缩进为点的作用。


# 自定义yml属性
country: 英国
birthday: 2002-11-15
user:
  name: 王六
  age: 22
user2:{name: "张三",age: 22}  #行内写法
# 单个数组
fruit:
  - apple
  - banana
maps: {k1: v1, k2: v2}
#  单个数组
fruit2: [apple,banana,pain apple]
#对象数组
userList:
  - name: zhangsan
    age: 18
  - name: lisi
    age 17
#对象数组
userlist3: [{name:zhangsan,age:18},{name:lisi,age:17}]
#对象数组
userList2:
  -
    name: zhangsan
    age: 18
  -
    name: lisi
    age 17

yml中写数据的作用？

可以给实体类赋值

@ConfigurationProperties赋值yml给类

可参考SpringBoot基础认识_阳光明媚UPUP的博客-CSDN博客

1、通过注解对一个实体类有set方法的属性映射

application.yml

person:
  name: 张三
  age: 18
  happy: yes
  birthday: 2021/02/01
  maps: {k1: v1, k2: v2}
  lists: [hello,hi,helloworld]
  dog:
    name: wangwang
    age: 3

Person.java

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
@ConfigurationProperties(prefix = "person")  //加上这个注解，就会把yml中person打头的配置数据直接和提供set方法的属性对号入座，spring容器中的该bean就是属性有值的了
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birthday;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
}

测试用例

@SpringBootTest
class QuickstartApplicationTests {
    @Autowired
    private Person person;
    @Test
    void contextLoads() {
        System.out.println(dog);
        System.out.println(person);
    }
}

所以，我们看springboot的自动装配如jdbc.DataSourceAutoConfiguration这个类中就有@EnableConfigurationProperties({DataSourceProperties.class})，继续跟进DataSourceProperties.class就有@ConfigurationProperties( prefix = "spring.datasource" )

所以我们在yml中配置的以spring-datasource打头的一些数据，就能够被这个文件读取并set方式注入给其属性。

1、这在properties文件的赋值需要使用@PropertySource("classpath:application.properties")

2、无论是yml还是properties文件中的数据，在实体类中通过@Value("${name}")这种el表达式可获得

yml还可使用一些占位符

person:
  id: ${random.uuid}
  random: ${random.int}
  hello: ${person.name}
  name: 张三
  age: 18
  happy: yes
  birthday: 2021/02/01
  maps: {k1: v1, k2: v2}
  lists: [hello,hi,helloworld]
  dog:
    name: ${person.hello:默认值}后面的值  #如果没有person.hello这个配置就会使用默认值 ，结果就是默认值后面的值
    age: 3

对比@ConfigurationProperties和@Value

@ConfigurationProperties 功能：批量注入配置文件中的属性

@Value 功能：一个个指定

@ConfigurationProperties 支持松散绑定(松散语法) 不支持SpEL 支持JSR303数据校验支持复杂类型封装

@Value 不支持松散绑定(松散语法) 支持SpEL 不支持JSR303数据校验不支持复杂类型封装

所谓松散绑定就是如yml中last-name，但我们Person中的属性为lastName并提供set方法，也可用@ConfigurationProperties绑定过来

yml或properties配置文件中怎么配

然后找Maven: org.springframework.boot:spring-boot-autoconfigure:2.5.4中META-INF中的spring-factories中的XXAutoConfiguration。这个类中可能包含很多类。找到相应类的@EnableConfigurationProperties(XXProperties.class）中的参数点进去，找@ConfigurationProperties( prefix = "spring.info" )这就是yml中需要配置的前缀，然后本类的成员属性且提供set方法的就是可配置的内容

JSR303数据校验@Validated

spring-boot中可以用@validated来校验数据，如果数据异常则会统一抛出异常，方便异常中心统一处理。我们这里来写个注解让我们的name只能支持Email格式

关于JSR 303的一些注解可参考：JSR-303 - 简书

或者引入spring-boot-starter-validation依赖后找这个包javax.validation.constraints

Person中我们给name字段加上一个@Email校验

import org.springframework.validation.annotation.Validated;
import javax.validation.constraints.Email;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
@ConfigurationProperties(prefix = "person")  //加上这个注解，就会把yml中person打头的配置数据直接和提供set方法的属性对号入座，spring容器中的该bean就是属性有值的
@Validated
public class Person {
    @Email(message = "邮箱格式不合法")   //也可加上message参数，validation中的注解验证赋给该字段的值是否为邮箱
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birthday;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
}

还是引用上面的yml中的内容，由于yml中的name不是邮箱类型的，所以启动报错。

多环境配置及配置文件的位置

可参考SpringBoot运维_阳光明媚UPUP的博客-CSDN博客

三个配置工程优先级properties>yml>yaml

不同配置文件中相同配置按照加载优先级相互覆盖，不同配置文件中不同配置全部保留

yml文件可写的位置：

1.jar包同级的config目录下的application.yml，打包前也可写在src的我同级目录下创建config文件夹中创建application.yml文件。

2.jar包同级目录下创建的application.yml，打包前也可写在src同级目录下创建application.yml文件

3.resource下创建config文件夹，里面写application.yml

4.resource下的application.yml

上面优先级1最高，递进到4最低

也可多环境开发在yml中选择要使用那一套配置

resource下的application.yml将这个配置文件进行copy，复制3份到resource目录下

一定要以application-(环境名)命名，dev\pro\test。,且要保留那个application命名的配置文件。删除配置中其他东西，只留一些配置相关的：

spring:
  profiles:
    active: dev

也可就一个application.yml中使用多文档模块

使用---分割多环境

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

---
server:
  port: 8081
spring:
  profiles: dev

---
server:
  port: 8081
spring:
  profiles: test

默认使用第一个，如果加上spring.profiles.active指定就以指定的优先

Springboot Web开发

1、静态资源分析

WebMvcAutoConfiguration中的WebMvcAutoConfigurationAdapter有个方法如下：

        public void addResourceHandlers(ResourceHandlerRegistry registry) {
            if (!this.resourceProperties.isAddMappings()) {
                logger.debug("Default resource handling disabled");
            } else {
                this.addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");
                this.addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (registration) -> {
                    registration.addResourceLocations(this.resourceProperties.getStaticLocations());
                    if (this.servletContext != null) {
                        ServletContextResource resource = new ServletContextResource(this.servletContext, "/");
                        registration.addResourceLocations(new Resource[]{resource});
                    }

                });
            }
        }

1、对于WebJars静态资源

官网：WebJars - Web Libraries in Jars

可以以maven的形式引入如jequery的坐标。引入后，就会在jar包依赖中看到/META-INF/resources/webjars/，上面代码中意思就是你只需浏览器输入80:webjars/**，就可替代80://META-INF/resources/webjars/**。

2、对其他静态资源

还配置了一个静态资源在getStaticPathPattern（properties文件中的值为/**，当前目录下所有内容都可识别了）以后只要url写/**就可找静态资源内容

然后就是WebMvcAutoConfiguration中的WebMvcAutoConfigurationAdapter类中的public WebMvcAutoConfigurationAdapter(ResourceProperties resourceProperties,...)有参构造上有个ResourceProperties，我们跟进这个类ResourceProperties extends Resources，再跟进这个父类，父类Resources有个属性，又这4个路径classpath:/META-INF/resources/", "classpath:/resources/", "classpath:/static/", "classpath:/public/

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

所以静态资源可放到：resource下的目录resources目录、static目录、public目录下和META-INF/resources/这个webjar的东西。

优先级

resource>static >public

一般public放公共资源，static放静态资源图片等等，resource放一些upload上传的文件。

测试

直接在resource下的目录resources目录、static目录、public目录下这三个目录下创建一个a.html，访问80/a.html即可访问到。

3、但，如果yml中配置静态资源路径，上面就不生效了，因为上面源码中写着呢

配置文件中这么配spring.mvc.static-path-pattern=/hello/** 。上面源码中默认会失效。但一般不在配置文件中这么写。没意义。

总结:

1.在springboot，我们可以使用以下方式处理静态资源
webjars loca7host:8080/webjars/
public，static，/**,resources1ocalhost:8080/2.优先级:resources>static(默认) >public

2、首页

WebMvcAutoConfiguration中有个类EnableWebMvcConfiguration，类中有方法

        @Bean
        public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext, FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
            WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(new TemplateAvailabilityProviders(applicationContext), applicationContext, this.getWelcomePage(), this.mvcProperties.getStaticPathPattern());
            welcomePageHandlerMapping.setInterceptors(this.getInterceptors(mvcConversionService, mvcResourceUrlProvider));
            welcomePageHandlerMapping.setCorsConfigurations(this.getCorsConfigurations());
            return welcomePageHandlerMapping;
        }

里面有个getWelcomePage又找了getIndexHtml

        private Resource getIndexHtml(Resource location) {
            try {
                Resource resource = location.createRelative("index.html");
                if (resource.exists() && resource.getURL() != null) {
                    return resource;
                }
            } catch (Exception var3) {
            }

            return null;
        }

找的是resource下的index.html

测试

resource下的目录resources目录、static目录、public目录下随便创建index.html。直接访问http://localhost:8080/

3、Thymeleaf模板引擎

resource下的templates目录下的所有页面，只能通过controller来跳转!这个需要模板引擎的支持!

1、Thymeleaf官网: Thymeleaf
2、Thymeleaf在Github 的主页: GitHub - thymeleaf/thymeleaf: Thymeleaf is a modern server-side Java template engine for both web and standalone environments.

3、Spring官方文档:Spring Boot Reference Guide，找到我们对应的版本

从上方第三个网址找到官网找到spring-boot-starter-thymeleafhttps://github.com/spring-projects/spring-boot/blob/v2.1.6.RELEASE/spring-boot-project/spring-boot-starters/spring-boot-starter-thymeleaf/pom.xml

		<dependency>
			<groupId>org.thymeleaf</groupId>
			<artifactId>thymeleaf-spring5</artifactId>
		</dependency>
		<dependency>
			<groupId>org.thymeleaf.extras</groupId>
			<artifactId>thymeleaf-extras-java8time</artifactId>
		</dependency>

模板引擎的作用就是我们来写一个页面模板，比如有些值呢，是动态的，我们写一些表达式。而这些值，从哪来呢，我们来组装一些数据，我们把这些数据找到。然后把这个模板和这个数据交给我们模板引擎，模板引擎按照我们这个数据帮你把这表达式解析、填充到我们指定的位置，然后把这个数据最终生成一个我们想要的内容给我们写出去，这就是我们这个模板引擎，不管是jsp还是其他模板引擎，都是这个思想。只不过呢，就是说不同模板引擎之间，他们可能这个语法有点不一样。其他的我就不介绍了，我主要来介绍一下SpringBoot给我们推荐的Thymeleaf模板引擎，这模板引擎呢，是一个高级语言的模板引擎，他的这个语法更简单。而且呢，功能更强大。

双击shift直接搜索这个类ThymeleafProperties，就是其配置类。

测试：

resource下的template目录下创建test.html，然后controller跳转
@RestController
public class HelloController {
    @RequestMapping("/test")
    public String index(){
        return "test";
    }
}