Spring全家桶--SpringBoot
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring全家桶--SpringBoot相关的知识，希望对你有一定的参考价值。
SpringBoot
- 一、SpringBoot入门
- 1.1 什么是SpringBoot
- 1.2 SpringBoot优缺点
- 1.3 SpringBoot快速入门
- 1.3.1 通过Maven导入依赖
- 1.3.2 直接上代码运行
- 1.4 简化配置
- 1.5 简化部署
- 二、了解自动配置原理
- 2.1 SpringBoot特点
- 2.1.1 依赖管理
- 2.1.2 自动配置
- 2.2 常见注解
- 2.2.1 @Bean
- 2.2.2 @Configuration
- 2.2.3 @Import
- 2.2.4 @Conditional
- 2.2.5 @ImportResource
- 2.2.6 @ConfigurationProperties
- 2.3 自动配置原理入门
- 2.3.1 回顾注解
- 2.3.2 @SpringBootConfiguration
- 2.3.3 @ComponentScan
- 2.3.4 @EnableAutoConfiguration
- @AutoConfigurationPackage
- @Import(AutoConfigurationImportSelector.class)
- 2.3.5 总结
- 2.4 开发小技巧
- 2.4.1 lombok
- 2.4.2 dev-tools
- 2.4.3 Spring Initailizr
- 三、SpringBoot2核心功能
- 3.1 配置文件
- 3.1.1 properties
- 3.1.2 yaml
- 3.1.简介
- 3.2 Web开发
- 3.2.1 静态资源访问
- 3.2.2 欢迎页支持
- 3.2.3 自定义Favicon
- 3.2.4 请求映射
- 3.2.5 普通参数与基本注解
- 3.2.6 视图解析流程
- 3.2.7 Thymeleaf
- 3.2.8 SpringBoot实战
- 3.2.9 拦截器
- 3.2.10 文件上传功能
- 3.2.11 异常处理
- 3.2.12 Web原生组件注入
- 3.2.13 嵌入式Servlet容器
- 3.2.14 SpringBoot原理套路
- 3.3 数据访问
- 3.3.1 数据源的自动配置
- 3.3.2 使用Druid数据源
- 3.3.3 整合Mybatis操作
- 3.3.4 整合Mybatis-Plus完成CRUD
- 3.4 单元测试
- 3.4.1 Junit5的变化
- 3.4.2 Junit5常用注解
- 3.4.3 断言
- 3.4.4 前置条件（assumptions）
- 3.4.5 嵌套测试
- 3.5.6 参数化测试
- 3.5 指标监控
- 3.5.1 SpringBoot Actuator
- 3.5.2 Actuator Endpoint
- 3.5.3 定制Endpoint
- 3.6 原理解析
- 3.6.1 Profile功能
- 3.6.2 外部化配置
一、SpringBoot入门
1.1 什么是SpringBoot
Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。
官网这个图我们来简单了解一下，可以通过SpringBoot快速构建一个一个小的模块，我们可以认为是开发出一个个的微服务
之后通过SpringCloud协调你开发的微服务模块，这些微服务可以通过springdata进行数据交互
学习SpringBoot之前应该先学习SSM框架之后再来学习，这样才能体会到它带来的便利！
1.2 SpringBoot优缺点
优点：
- 创建独立Spring应用
- 内嵌web服务器
- 自动starter依赖，简化构建配置
- 自动配置Spring以及第三方功能
- 提供生产级别的监控、健康检查及外部化配置
- 无代码生成、无需编写XML
SpringBoot是整合Spring技术栈的一站式框架
SpringBoot是简化Spring技术栈的快速开发脚手架
什么是脚手架？？？
对于程序员来说脚手架就是代码生成器。不用重复的进行创建类和基本的增删改查等工作。只需要按照步骤配置好，就能自动完成基础类和各个实现类等的创建了。
缺点：
- 更新快，需要不断学习新技术
- 封装太深，不利于精通
1.3 SpringBoot快速入门
环境如下：
1.3.1 通过Maven导入依赖
pom文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.caq</groupId>
<artifactId>SpringBootStudy</artifactId>
<version>1.0-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.4.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
</project>
在SpringBoot中我们想进行WEB开发，可以直接导入一个spring-boot-starter-web即可
在原来的SSM阶段我们要导入大量的包，springboot中这一个包就可以把SSM阶段WEB开发需要的都导入进来
1.3.2 直接上代码运行
主程序代码
@SpringBootApplication代表这是一个springboot应用
ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);属于固定写法
package com.caq.boot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
@SpringBootApplication
public class MainApplication
public static void main(String[] args)
ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
控制层代码
@RestController是@ResponseBody的结合@Controller
@Controller是创建
@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系。
package com.caq.boot.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class Controller
@RequestMapping("/hello")
public String handle01()
return "Hello SpringBoot 2 !";
运行主程序访问8080端口
测试成功~~
1.4 简化配置
写一个application.properties配置文件，所有的配置文件都可以写这里面
比如我们改tomcat的端口号为8089
如下所示：
server.port=8089
重新启动程序访问测试
1.5 简化部署
把项目打成jar包，直接在目标服务器执行即可。
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
通过如下命令运行我们的程序
java -jar 运行我们的jar包
dir查看当前目录下的文件
测试依旧可以访问，我还更改了返回的字符串
二、了解自动配置原理
2.1 SpringBoot特点
2.1.1 依赖管理
父项目是用来解决依赖管理的
标签是maven中的继承，是用来做依赖管理的
spring-boot-dependencies是spring-boot-starter-parent的父项目。它几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制
spring-boot-starter-* ： *就某种场景
只要引入starter，这个场景的所有常规需要的依赖我们都自动引入
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.4.RELEASE</version>
</parent>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.3.4.RELEASE</version>
</parent>
修改默认版本号
在pom里直接写 这个标签，写你想要的版本即可
1、查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。
2、在当前项目里面重写配置
<properties>
<mysql.version>5.1.43</mysql.version>
</properties>
2.1.2 自动配置
- 自动配好SpringMVC
- 引入SpringMVC全套组件
- 自动配好SpringMVC常用组件（功能）
- 自动配好Web常见功能，如：字符编码问题
- SpringBoot帮我们配置好了所有web开发的常见场景
- 默认的包结构
- 主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
- 无需以前的包扫描配置
- 想要改变扫描路径，@SpringBootApplication(scanBasePackages=“com.example”)
@SpringBootApplication
等同于
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.caq.boot")
- @EnableAutoConfiguration帮助SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot，并创建对应配置类的Bean，并把该Bean实体交给IoC容器进行管理。
- 各种配置拥有默认值
- 默认配置最终都是映射到某个类上，如：MultipartProperties
- 配置文件的值最终会绑定每个类上，这个类会在容器中创建对象
- 按需加载所有自动配置项
- 非常多的starter
- 引入了哪些场景这个场景的自动配置才会开启
- SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面
那么它是如何自动配置的呢？
我们需要先了解下SpringBoot底层的相关注解
2.2 常见注解
2.2.1 @Bean
==@Bean给容器中添加组件。==以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
组件的概念在上面提到了就是符合某种规范的类，可以理解为给容器中添加对象
/**
User类和Pet要提前写好
*/
@Bean
public User user01()
return new User("zs",12);
这个我们自定义一个名字，不用方法名作为实例的名字了
@Bean("tiger")
public Pet animal01()
return new Pet("li");
如下，SpringApplication.run（）返回值是把IOC容器返回给我们了
ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
我们用返回的IOC容器进行测试看看通过@Bean添加的组件有没有添加成功
@SpringBootApplication
public class MainApplication
public static void main(String[] args)
// 1.返回值是IOC容器
ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
boolean tiger1 = run.containsBean("tiger");
System.out.println(tiger1);
boolean user01 = run.containsBean("user01");
System.out.println(user01);
2.2.2 @Configuration
组件(component):
组件也是抽象的概念,可以理解为一些符合某种规范的类组合在一起就构成了组件。他可以提供某些特定的功能。J2EE来说，有什么servlet，jsp, javabean，ejb都是组件。但实际他们都是类，只不过有他们特殊的规定。组件和类的关系:符合某种规范的类的组合构成组件
@Configuration作用是告诉SpringBoot这是一个配置类 == 配置文件
之前的Spring学习中，我们通过XML配置文件进行管理bean
通过@Configuration注解可以不用写XML配置文件，将它写在类上面可以把这个类当成配置类来用。对象的管理在这个配置类中进行
@Configurationpublic class Myconfig
@Configuration(proxyBeanMethods = true)，默认值是true的。那么它有什么用呢？
Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
组件依赖必须使用Full模式默认。其他默认是否Lite模式
我们打印Myconfig对象可以看到是EnhancerBySpringCGLIB，这个就代表它是一个被SpringCGLIB增强了的代理对象
com.caq.boot.config.Myconfig
dfb5b12f@55f45b92
如果代理对象调用配置类中注册组件使用的方法返回值一定是单实例
********配置类********
@Configuration(proxyBeanMethods = true)
public class Myconfig
@Bean
public User user01()
return new User("zs",12);
@Bean("tiger") //这个我们自定义一个名字，不用方法名作为实例的名字了
public Pet animal01()
return new Pet("li");
********主程序类********
@SpringBootApplication
public class MainApplication
public static void main(String[] args)
//1.返回值是IOC容器
ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
Myconfig myconfig = run.getBean(Myconfig.class);
System.out.println("对配置类中的这个组件注册方法调用看获取到的对象是不是同一对象");
User user02 = myconfig.user01();
User user03 = myconfig.user01();
System.out.println(user02==user03);
********测试结果*******
...
com.caq.boot.config.Myconfig$$EnhancerBySpringCGLIB$$3ea98f23@1d81e101
对配置类中的这个组件注册方法调用看获取到的对象是不是同一对象
true
2.2.3 @Import
和@Bean功能类似，都是注册组件的
@Import(User.class, DBHelper.class)作用是给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名
@SpringBootApplication
public class MainApplication
public static void main(String[] args)
ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
String[] beanNamesForType = run.getBeanNamesForType(User.class);
for (String s : beanNamesForType)
System.out.println(s);
*************打印结果************
com.caq.boot.bean.User
user01
2.2.4 @Conditional
@Conditional就是条件装配：满足Conditional指定的条件，则进行组件注入
@ConditionalOnBean(name = “tiger”)如果容器中有tiger这个组件才会执行下面的配置
@ConditionalOnMissingBean(name = “tiger”)如果容器中没有tiger这个组件才会执行下面的配置
@Import(User.class, DBHelper.class)
@Configuration(proxyBeanMethods = true)
@ConditionalOnBean(name = "tiger")
//@ConditionalOnMissingBean(name = "tiger")
public class Myconfig
@Bean
public User user01()
return new User("zs",12);
// @Bean("tiger")
public Pet animal01()
return new Pet("li");
2.2.5 @ImportResource
可以引入xml配置文件中的bean
======================beans.xml=========================
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<bean id="zs" class="com.caq.boot.bean.User">
<property name="name" value="zhangsan"></property>
<property name="age" value="18"></property>
</bean>
<bean id="dog" class="com.caq.boot.bean.Pet">
<property name="name" value="tomcat"></property>
</bean>
</beans>
@ImportResource("classpath:beans.xml")
public class MyConfig 2.2.6 @ConfigurationProperties
将我们的类和配置文件进行绑定
@ConfigurationProperties(prefix = “mycar”)和配置文件绑定，prefix是和配置文件中的前缀对应配置绑定可以理解为字面意思，将要配置给对象的属性写在配置文件中。通过@ConfigurationProperties注解来实现赋值
**************************car的实体类*******************
//只有在容器中的组件才有SpringBoot提供的功能
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car
private String brand;
private String price;
public String getBrand()
return brand;
public void setBrand(String brand)
this.brand = brand;
public String getPrice()
return price;
public void setPrice(String price)
this.price = price;
@Override
public String toString()
return "Car" +
"brand=" + brand + \\ +
", price=" + price + \\ +
;
**********************web层代码***************************
@RestController
//@RestController是@ResponseBody的结合@Controller
public class Controller
@RequestMapping("/hello")
public String handle01()
return "Hello SpringBoot 2 !" + "你好";
@Autowired
Car car;
@RequestMapping("/car")
public Car car()
return car;
运行springboot程序，访问可以发现成功把配置文件中的值注入到对象里了，绑定成功了
第二种配置文件绑定的方式
@Component+@ConfigurationProperties这种方式需要手动的把要绑定的类注册到容器中，如果是外部的类的话很不方便
@EnableConfigurationProperties(Car.class)+@ConfigurationProperties
其中@EnableConfigurationProperties(Car.class)能实现
1.开启car配置绑定功能
2.把这个car组件自动注册到容器中
@Configuration
@EnableConfigurationProperties(Car.class)
public class Myconfig
@ConfigurationProperties(prefix = "mycar")
public class Car
2.3 自动配置原理入门
2.3.1 回顾注解
什么是元注解?
元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面。它的作用和目的就是给其他普通的标签进行解释说明的。
Retention 的英文意为保留期的意思。当 @Retention 应用到一个注解上的时候，它解释说明了这个注解的的存活时间。
它的取值如下：
- RetentionPolicy.SOURCE 注解只在源码阶段保留，在编译器进行编译时它将被丢弃忽视。
- RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加载到 JVM 中。
- RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候，它会被加载进入到 JVM 中，所以在程序运行时可以获取到它们。
@Documented有什么用？
@Documented 保存到javadoc
顾名思义，这个元注解肯定是和文档有关。它的作用是能够将注解中的元素包含到 Javadoc 中去。（Javadoc用于描述类或者方法的作用）
@Target 限定使用场景
Target 是目标的意思，@Target 指定了注解运用的地方。当一个注解被 @Target 注解时，这个注解就被限定了运用的场景。类比到标签，原本标签是你想张贴到哪个地方就到哪个地方，但是因为 @Target 的存在，它张贴的地方就非常具体了，比如只能张贴到方法上、类上、方法参数上等等。
@Target 有下面的取值:
- ElementType.ANNOTATION_TYPE 可以给一个注解进行注解
- ElementType.CONSTRUCTOR 可以给构造方法进行注解
- ElementType.FIELD 可以给属性进行注解
- ElementType.LOCAL_VARIABLE 可以给局部变量进行注解
- ElementType.METHOD 可以给方法进行注解
- ElementType.PACKAGE 可以给一个包进行注解
- ElementType.PARAMETER 可以给一个方法内的参数进行注解
- ElementType.TYPE 可以给一个类型进行注解，比如类、接口、枚举
@Inherited 注解继承
Inherited 是继承的意思，它的意思是@Inherited注解了B注解，B再注解别人，那么如果它的子类没有被任何注解应用的话，那么这个子类就继承了超类的注解，代码来解释。
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@interface Test
@Test
public class A
public class B extends A
注解 Test 被 @Inherited 修饰，之后类 A 被 Test 注解，类 B 继承 A,类 B 也拥有 Test 这个注解。
2.3.2 @SpringBootConfiguration
这是注解@SpringBootConfiguration的源码，因为@Inherited注解
所以@SpringBootApplication注解的类继承了这个超类的三个注解@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
之后我们在分别看这三个注解
原来@SpringBootConfiguration是@Configuration是用来表示类为配置类的
2.3.3 @ComponentScan
Spring部分就学过，是知道扫描哪些，spring注解
2.3.4 @EnableAutoConfiguration
EnableAutoConfiguration的目的是启动SpringBoot的自动配置机制。
-
@AutoConfigurationPackage：自动配置包 -
@Import：给IOC容器导入组件
@AutoConfigurationPackage
我们可以发现，依靠的还是@Import注解，再点进去查看，我们发现重要的就是以下的代码：
它的作用就是在默认的情况下将主配置类(@SpringBootApplication)的所在包及其子包里边的组件扫描到Spring容器中。
这个扫描的和Component扫描的对象不同
比如说，你用了Spring Data JPA，可能会在实体类上写
@Entity注解。这个@Entity注解由@AutoConfigurationPackage扫描并加载，而我们平时开发用的@Controller/@Service/@Component/@Repository这些注解是由ComponentScan来扫描并加载的。
@Import(AutoConfigurationImportSelector.class)
使用Import自动导入所有符合自动配置条件的Bean定义并加载到IOC容器
2.3.5 总结
- pringBoot先加载所有的自动配置类 xxxxxAutoConfiguration
- 每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。xxxxProperties里面拿。xxxProperties和配置文件进行了绑定
- 生效的配置类就会给容器中装配很多组件
- 只要容器中有这些组件，相当于这些功能就有了
- 定制化配置
- 用户直接自己@Bean替换底层的组件
- 用户去看这个组件是获取的配置文件什么值就去修改。
2.4 开发小技巧
2.4.1 lombok
lombok能简化JavaBean的开发
在pom文件里添加依赖
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
并在idea中下载插件
以前的getset方法我们不用写了，通过注解@Data,它就可以在编译的时候自动生成getset方法了
@NoArgsConstructor//为JavaBean添加无参构造
@AllArgsConstructor//为JavaBean添加有参构造
@Data
@ToString
public class Pet
private String name;
Slf4j
简化日志开发
添加@Slf4j注解既有此功能
2.4.2 dev-tools
项目或者页面修改以后：Ctrl+F9；
修改后的页面效果就会立马显示出来
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
2.4.3 Spring Initailizr
这个功能能帮我们快速构建SpringBoot项目
如下：
选中想要开发的项目需要的组件
目录结构直接给我们创建好了，而且SpringBoot的启动程序也写好了
我们只需要关注逻辑代码即可~
三、SpringBoot2核心功能
3.1 配置文件
3.1.1 properties
就是正常的配置文件，和前面学的一样
3.1.2 yaml
3.1.简介
YAML 是 “YAML Ain’t Markup Language”（YAML 不是一种标记语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是：“Yet Another Markup Language”（仍是一种标记语言）。
非常适合用来做以数据为中心的配置文件
这个我太熟悉了啊，当时在专科的时候参加云计算竞赛，要写容器编排。我搁那天天练这个啊，当时也不知道格式啥的，就是死记硬背。
我想说的是，这个很重要，后面学ansible的时候也会用到这个，给爷狠学！！！
基本语法
- key: value；kv之间有空格
- 大小写敏感
- 使用缩进表示层级关系
- 缩进不允许使用tab，只允许空格
- 缩进的空格数不重要，只要相同层级的元素左对齐即可
- #表示注释
- 字符串无需加引号，如果要加，’与""表示字符串内容 会被 转义/不转义
数据类型
- 字面量：单个的、不可再分的值。date、boolean、string、number、null
k: v
- 对象：键值对的集合。map、hash、set、object
行内写法： k: k1:v1,k2:v2,k3:v3#或k: k1: v1 k2: v2 k3: v3
- 数组：一组按次序排列的值。array、list、queue
行内写法： k: [v1,v2,v3]#或者k: - v1 - v2 - v3
示例
person: userName: zs boss: true birth: 2019/12/9 age: 18# interests: [唱,跳,rap] interests: - 唱 - 跳 - rap# 集合也可以跟数组一样用-的形式来表示# 也可以写成[]的形式 animal: [Cat,Dog]# map的两种写法# score:# english: 99# math: 80# score: english:90,math:78# 这里面的冒号后面不用跟空格，因为这是json的表示方法# 也可以写成键值对的形式k:V,K:V score: english:90,math:78 salarys: - 9999.98 - 9999.97 pet: name: dog weight: 99.97 allPets: sick:# 以下这两种都表示对象，分别是k:v的形式和的形式 - name: dog,weight: 34 - name: cat weight: 23 health: - name: A,weight: 10 - name: B,weight: 20
访问测试
配置提示
自定义的类和配置文件绑定一般没有提示。
导入一个依赖即可~
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</artifactId> <optional>true</optional> </dependency> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <excludes> <exclude> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</artifactId> </exclude> </excludes> </configuration> </plugin> </plugins> </build>
之后就能愉快的自动提示了
3.2 Web开发
3.2.1 静态资源访问
只要静态资源放在类路径下： called
/static (or /public or /resources or /META-INF/resources访问 ： 当前项目根路径/ + 静态资源名
原理： 静态映射/**
请求进来，先去找Controller看能不能处理。不能处理的所有请求又都交给静态资源处理器。静态资源也找不到则响应404页面
启动成功后，直接访问 当前项目根路径/ + 静态资源名
改变默认的静态资源路径
改变为AAA文件为静态资源文件夹
webjar
WebJars是一个很神奇的东西，可以让大家以jar包的形式来使用前端的各种框架、组件。
完成依赖添加
<dependency> <groupId>org.webjars</groupId> <artifactId>jquery</artifactId> <version>3.5.1</version> </dependency>
进行测试
可以尝试CTRL+f9快速编译
记得重启之后在访问，便可访问web静态资源了
3.2.2 欢迎页支持
静态资源路径下 index.html
- 可以配置静态资源路径
- 但是不可以配置静态 资源的访问前缀。否则导致 index.html不能被默认访问
就是把index页面放到静态资源目录下，他会自动访问这个页面
如果访问不了，记得clean一下（Maven插件clean功能）
3.2.3 自定义Favicon
favicon.ico 放在静态资源目录下即可更换网站图标
设置静态资源访问路径会导致 Favicon 功能失效
3.2.4 请求映射
@xxxMapping
Rest风格支持使用HTTP请求方式动词来表示对资源的操作
以前访问资源路径:
- /getUser 获取用户
- /deleteUser 删除用户
- /editUser 修改用户
- /saveUser 存用户
现在访问资源路径:
/user
- GET-获取用户
- DELETE-删除用户
- PUT-修改用户
- POST-保存用户
核心Filter; HiddenHttpMethodFilter
SpringBoot中手动开启
#开启rest风格在springboot里要手动开启
spring:
mvc:
hiddenmethod:
filter:
enabled: true
表单
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
测试REST风格
<form action="/user" method="get">
<input value="REST-GET 提交" type="submit">
</form>
<form action="/user" method="post">
<input value="REST-POST 提交" type="submit">
</form>
表单method=post, 隐藏域 _method=put
<form action="/user" method="post">
<input name="_method" type="hidden" value="put">
<input value="REST-put 提交" type="submit">
</form>
<form action="/user" method="post">
<input name="_method" type="hidden" value="DELETE">
<input value="REST-delete 提交" type="submit">
</form>
</body>
</html>
3.2.5 普通参数与基本注解
基本注解：
@PathVariablev 获取路径变量
@RequestHeader 获取请求头
@RequestParams 获得请求参数
@CookieValue 获取Cookie的值
@RequestBody 获取请求体
<!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <title>Title</title></head><body>测试REST风格<form action="/user" method="get"> <input value="REST-GET 提交" type="submit"></form><form action="/user" method="post"> <input value="REST-POST 提交" type="submit"></form><form action="/user" method="post"> <input name="_method" type="hidden" value="put"> <input value="REST-put 提交" type="submit"></form><form action="/user" method="post"> <input name="_method" type="hidden" value="DELETE"> <input value="REST-delete 提交" type="submit"></form><hr>测试基本注解<ur> <a href="car/3/owner/zs?age=18&interest=girl&interest=boy">car/id/owner/username</a> <li>@PathVariable(路径变量)</li> <li>@RequestHeader（获取请求头）</li> <li>@RequestParam（获取请求参数）</li> <li>@CookieValue（获取cookie）</li> <li>@RequestAttribute（获取request域属性）</li> <li>@RequestBody（获取请求体）</li> <li>@MatrixVariable（矩阵变量）</li></ur><form action="/save" method="post"> 测试@RequestBody注解<br> 用户名:<input name="UserName"><br> 邮箱：<input name="email"><br> <input type="submit" value="提交"></form></body></html>
@GetMapping用于将HTTP get请求映射到特定处理程序的方法注解
具体来说，@GetMapping是一个组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写。@PostMapping用于将HTTP post请求映射到特定处理程序的方法注解
具体来说，@PostMapping是一个组合注解，是@RequestMapping(method = RequestMethod.POST)的缩写
package com.caq.boot.controller;import org.springframework.web.bind.annotation.*;import sun.management.Agent;import java.util.HashMap;import java.util.List;import java.util.Map;@RestControllerpublic class ParameterController @GetMapping("/car/id/owner/username") public Map<String,Object> getCar(@PathVariable("id") Integer id, @PathVariable("username") String username, @PathVariable Map<String,String> pv, @RequestHeader("user-Agent") String userAgent, @RequestHeader Map<String,String> header, @RequestParam("age") Integer age, @RequestParam("interest") List<String> interest, @RequestHeader Map<String,String> param ) /* @CookieValue("_ga") 传入一个Map<String,String>可以接受所有的参数 @PathVariable带key了就拿特点的，不带了就拿所有的 @RequestHeader同上 */ HashMap<String, Object> map = new HashMap<>(); map.put("id",id); map.put("username",username);// map.put("pv",pv);// map.put("userAgent",userAgent);// map.put("header",header);// map.put("age",age);// map.put("interest",interest); map.put("param",param); map.put("_ga",_ga); return map; @PostMapping("/save") public Map postMethod(@RequestBody String content) HashMap<String, Object> map = new HashMap<>(); map.put("content",content); return map; 3.2.6 视图解析流程
- 目标方法处理的过程中，所有数据都会被放在ModelAndViewContainer 里面。包括数据和视图地址
- 方法的参数是一个自定义类型对象（从请求参数中确定的），把他重新放在 ModelAndViewContainer
- 任何目标方法执行完成以后都会返回 ModelAndView（数据和视图地址）
- processDispatchResult 处理派发结果（页面改如何响应）
视图解析：
- 返回值以 forward: 开始： new InternalResourceView(forwardUrl); --> 转发request.getRequestDispatcher(path).forward(request, response);
- 返回值以 redirect: 开始：new RedirectView() --》 render就是重定向
- 返回值是普通字符串： new ThymeleafView（）—>
3.2.7 Thymeleaf
为什么用Thymeleaf？
JSP不好用，Thymeleaf好用它适用于SpringBoot模块。它使用html作为模板页，通过html一些特殊标签语法代表其含义，不破坏html的结构
Thymeleaf是一款现代化、服务端Java模板引擎
Thymeleaf是Springboot官方支持的模板引擎，有着动静分离等独有特点
- Thymeleaf的主要目标是为您的开发工作流程带来优雅自然的模板-HTML可以在浏览器中正确显示，也可以作为静态原型工作，从而可以在开发团队中加强协作。
- Thymeleaf拥有适用于Spring Framework的模块，与您喜欢的工具的大量集成以及插入您自己的功能的能
以上是关于Spring全家桶--SpringBoot的主要内容，如果未能解决你的问题，请参考以下文章
Spring全家桶系列--SpringBoot与Mybatis结合