SpringBoot

SpringBoot1.0.1

导入依赖

  1. <!-- 引入了父Maven项目,继承父Maven项目所有的配置信息
  2. spring-boot-starter-parent 有引入了一个父Maven项目
  3. <parent>
  4. <groupId>org.springframework.boot</groupId>
  5. <artifactId>spring-boot-starter-parent</artifactId>
  6. <version>2.3.5.RELEASE</version>
  7. <relativePath/>
  8. </parent>
  9. spring-boot-starter-parent 帮我们管理了SpringBoot应用中所有依赖的版本,
  10. 以后我们导入已有依赖就不需要写版本号了,它帮我们解决了第三方库之间的版本冲突问题
  11. SpringBoot的版本仲裁中心
  12. -->
  13. <!--集成springboot的项目-->
  14. <parent>
  15. <groupId>org.springframework.boot</groupId>
  16. <artifactId>spring-boot-starter-parent</artifactId>
  17. <version>2.3.5.RELEASE</version>
  18. <relativePath/>
  19. </parent>
  20. <!--
  21. starter 场景启动器 : 不同的场景启动器维护了所有对应的所有依赖,从而简化maven文件书写
  22. spring-boot-starter-web : 使用Spring MVC构建Web(包括RESTFUL)应用程序,使用TomCat作为默认的嵌入式容器
  23. -->
  24. <dependencies>
  25. <!--引入springboot的web支持-->
  26. <dependency>
  27. <groupId>org.springframework.boot</groupId>
  28. <artifactId>spring-boot-starter-web</artifactId>
  29. </dependency>
  30. </dependencies>

@Configuration springBeans.xml : 也是配置类 声明Beans.xml 声明容器;

  1. /**
  2. * @SpringBootApplication : SpringBoot的启动类(入口)
  3. *
  4. * @Configuration spring.xml : 也是配置类
  5. *
  6. * @ComponentScan = <context:component-scan basePackages="com.xao."></context:component-scan>
  7. *
  8. * Spring底层在解析配置类, 会去解析@ComponentScan,读取basePackages,
  9. * 如果没有读取到,会将当前配置类所在的包当做扫描包 com/xiao/Application ......
  10. *
  11. * 位置: 最后放在需要扫描包的根目录.或者说放在所有包的顶层目录中
  12. */

标记SpringBoot启动类 SpringBoot内置TomCat

  1. @SpringBootApplication //标记成SpringBoot的启动类
  2. public class Application {
  3. public static void main(String[] args) {
  4. SpringApplication.run(Application.class,args);
  5. }
  6. }

打成jar包 cmd 命令直接启动 无需配置

  1. <!-- 部署springboot的插件, 只有加了这个插件 当我们运行 java -jar xxx.jar才能正常启动 -->
  2. <build>
  3. <plugins>
  4. <plugin>
  5. <groupId>org.springframework.boot</groupId>
  6. <artifactId>spring-boot-maven-plugin</artifactId>
  7. </plugin>
  8. </plugins>
  9. </build>

SpringBoot1.0.2

springboot配置文件 约定大于配置

resources —> application.properties

  1. 设置端口号
  2. server.port=8088
  3. 设置路径前缀 localhost:8088/xiao/hello/world
  4. server.servlet.context-path=/xiao

1.使用Spring Initializer快速创建SpringBoot项目

1.IDEA:使用Spring Initializer快速创建项目

  1. 继承关系-springbootmaven项目
  2. 1.使用spring initializer新建一个父maven,type选择POM
  3. 2.使用spring initizlizer新建一个子maven,type选择project
  4. 修改 子项目中的继承方式:
  5. 之前:
  1. <parent>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-parent</artifactId>
  4. <version>2.6.4</version>
  5. <relativePath/> <!-- lookup parent from repository -->
  6. </parent>
  1. 之后:
  1. <parent>
  2. <groupId>com.xaio.springboot</groupId>
  3. <artifactId>springboot_parent</artifactId>
  4. <version>0.0.1-SNAPSHOT</version>
  5. </parent>

spring_initializer —-> springboot_parent —->spring-boot-starter-parent

IDE都支持使用Spring的项目创建向导快速创建一个Spring Boot项目:

选择我们需要的模块; 向导会联网创建Spring Boot项目;

默认生成的Spring Boot项目;

  1. 主程序已经生成好了,我们只需要我们自己的逻辑
  2. resources文件夹中目录结构
  3. static:保存所有的静态资源 js css images
  4. templates: 保存所有的模板页面; (Spring Boot默认jar包使用嵌入式的TomCat,默认不支持JSP页面);
  5. 可以使用模板引擎(freemarker,thymeleaf)
  6. application.properties:Spring Boot应用的配置文件; 可以修改一些默认设置;

SpringBoot1.0.3自定义SpringApplication

  1. public static void main(String[] args) {
  2. SpringApplication app = new SpringApplication(SpringInitializrApplication.class);
  3. app.setBannerMode(Banner.Mode.OFF); //可以关闭springboot启动横幅
  4. app.run(args);
  5. }

@RestController = @ResponseBody and @Controller 合体

  1. @RestController
  2. public class HelloController {
  3. @RequestMapping("/hello")
  4. public String handle01(){
  5. return "Hello Spring Boot 2!";
  6. }
  7. public HelloController(){
  8. System.out.println("HelloController被执行");
  9. }
  10. }

1.1、依赖管理

  • 父项目做依赖管理
    依赖管理

org.springframework.boot
spring-boot-starter-parent
2.3.4.RELEASE

他的父项目

org.springframework.boot
spring-boot-dependencies
2.3.4.RELEASE

几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制

  • 开发导入starter场景启动器

1、见到很多 spring-boot-starter-就某种场景
2、只要引入starter,这个场景的所有常规需要的依赖我们都自动引入
3、SpringBoot所有支持的场景
https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter
4、见到的 *-spring-boot-starter: 第三方为我们提供的简化开发的场景启动器。
5、所有场景启动器最底层的依赖

org.springframework.boot
spring-boot-starter
2.3.4.RELEASE
compile

  • 无需关注版本号,自动版本仲裁
    1、引入依赖默认都可以不写版本
    2、引入非版本仲裁的jar,要写版本号
  • 可以修改默认版本号

1、查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。
2、在当前项目里面重写配置

5.1.43

1.2、自动配置

  • 自动配好Tomcat
    引入Tomcat依赖
    配置TomCat org.springframework.boot spring-boot-starter-tomcat 2.3.4.RELEASE compile
    自动配置好springMVC
    引入springMVC全套组件
    自动引入好SpringMVC常用组件(功能)
    自动配好Web常见功能,如:字符编码问题
    SpringBoot帮我们的配置好了所有web开发的常见场景
    默认的包结构
    主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
    想要改变扫描器路径
    无需以前的包扫描配置@SpringBootApplication(“com.xiao”) or @ComponentScan(“com.xiao”)
    各种配置拥有默认值
    默认配置都是映射到MultipartProperties
    配置文件的值最终会绑定每个类上,这个类会在容器中创建对象
    按需加载所有自动配置项
    非常多的starter
    引入了哪些场景这个场景的自动配置才会开启
    SpringBoot的所有自动配置都在spring-boot-autoconfigure包里:
    1. <dependency>
    2. <groupId>org.springframework.boot</groupId>
    3. <artifactId>spring-boot-autoconfigure</artifactId>
    4. <version>2.3.4.RELEASE</version>
    5. <scope>compile</scope>
    6. </dependency>

    ……

查看SpringBoot容器中所有组件

  1. //返回IOC容器
  2. ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
  3. //查看容器里面的组件
  4. String[] names = run.getBeanDefinitionNames();
  5. for (String name : names) {
  6. System.out.println(name);
  7. }

2,容器功能

2.1,组件添加

1,@Configuration

基本使用

  1. //告诉springboot 这是一个配置类 == 配置文件

Full模式与Lite模式

  1. 示例
  2. 最佳实战
  3. 配置 类组件之间无依赖关系用List模式加速容器启动过程,减少判断
  4. 配置类组件之间有依赖关系,方法会被调用得到之前单实例组件,用Full模式

2,@Bean,@Component,@Controller,@Service,@Repository

  1. /**
  2. * 1,配置类里面可以使用@Bean标注在方法上给容器注册组件,默认也是单实例的
  3. * 2,配置类本身也是组件
  4. * proxyBeanMethods: 代理bean的方法
  5. * Full(proxyBeanMethods = true),
  6. * Lite(proxyBeanMethods = false)
  7. * 组件依赖
  8. */
  9. @Configuration(proxyBeanMethods = true) //告诉springboot 这是一个配置类 == 配置文件
  10. public class MyConfig {
  11. /**
  12. * 外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
  13. * @return
  14. */
  15. @Bean //给容器中添加组件.以方法名作为组件的id,返回类型就是组件类型,返回的值,就是组件在容器中的实例
  16. public User user(){
  17. User zhangsan = new User("zhangsan", 18);
  18. //user组件依赖了Pet组件
  19. zhangsan.setPet(tomcatPet());
  20. return zhangsan;
  21. }
  22. @Bean("tom")
  23. public Pet tomcatPet(){
  24. return new Pet("tomcat");
  25. }
  26. }
  27. /**
  28. * 主程序类
  29. * @SpringBootApplication : 这是一个SpringBoot应用
  30. *
  31. * @SpringBootApplication("com.xiao") 想要改变包扫描器的扫描路径
  32. */
  33. @SpringBootApplication
  34. public class MainApplication {
  35. public static void main(String[] args) {
  36. //返回IOC容器
  37. ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
  38. //查看容器里面的组件
  39. String[] names = run.getBeanDefinitionNames();
  40. for (String name : names) {
  41. System.out.println(name);
  42. }
  43. //从容器中获取组件
  44. Pet tomcatPet = run.getBean("tom", Pet.class);
  45. Pet tomcatPet1 = run.getBean("tom", Pet.class);
  46. System.out.println("组件:"+(tomcatPet == tomcatPet1));
  47. MyConfig bean = run.getBean(MyConfig.class);
  48. //如果@Configuration(proxyBeanMethods = true)代理对象调用方法.springboot总会检查这个组件是否在容器中有
  49. //保持组件单实例
  50. User user = bean.user();
  51. User user1 = bean.user();
  52. System.out.println(user == user1);
  53. User user2 = run.getBean("user", User.class);
  54. Pet tom = run.getBean("tom", Pet.class);
  55. System.out.println(user2.getPet() == tom);
  56. }
  57. }

3,@ComponentScan,@Import

  1. 4,@Import({User.class, DBHelper.class})
  2. 给容器中自动创建出这连个类型的组件,默认组件的名字就是全类名

user自己设置的

  1. //@SpringBootApplication
  2. String[] beanNamesForType = run.getBeanNamesForType(User.class);
  3. System.out.println("=================");
  4. for (String s : beanNamesForType) {
  5. System.out.println(s);
  6. }
  7. String[] beanNamesForType1 = run.getBeanNamesForType(DBHelper.class);
  8. System.out.println("=================");
  9. for (String s : beanNamesForType1) {
  10. System.out.println(s);
  11. }

4,@Conditional 条件

在Config中使用 容器创建时

条件装配:满足Conditional指定的条件,则进行组件注册

2.2,原生配置文件引入

1,@ImportResource

Conditional

  1. //@ImportResource("classpath:beans.xml")导入Spring的配置文件
  2. @ImportResource("classpath:beans.xml") 引入外部容器xml
  3. public class MyConfig {}

2.3,属性绑定

1,@ConfigurationProperties

如何使用Java读取到properties文件中的内容,并且把它封装到JavaBean中,以供随时使用;

public class getProperties {
public static void main(String[] args) throws FileNotFoundException, IOException {
Properties pps = new Properties();
pps.load(new FileInputStream(“a.properties”));
Enumeration enum1 = pps.propertyNames();//得到配置文件的名字
while(enum1.hasMoreElements()) {
String strKey = (String) enum1.nextElement();
String strValue = pps.getProperty(strKey);
System.out.println(strKey + “=” + strValue);
//封装到JavaBean。
}
}
}

2,@EnableConfigurationProperties + @ConfigurationProperties
  1. @EnableConfigurationProperties(Car.class)
  2. //1,开启属性配置绑定功能
  3. //2,把这个Car这个组件自动注册到容器中
  4. public class MyConfig {}
  5. /**
  6. * 只有在容器中的组件,才会拥有SpringBoot提供的强大功能
  7. */
  8. //@Component
  9. @ConfigurationProperties(prefix = "mycar")
  10. public class Car {}
  11. //比如导入依赖包 包内没有@Component 就可以使用这个

3,@Component + @ConfigurationProperties
  1. /**
  2. * 只有在容器中的组件,才会拥有SpringBoot提供的强大功能
  3. */
  4. @Component
  5. @ConfigurationProperties(prefix = "mycar")
  6. public class Car {}

3,自动配置原理入门

3.1,引导加载自动配置类

  1. @EnableAutoConfiguration //启用自动配置
  2. @SpringBootConfiguration
  3. @EnableAutoConfiguration
  4. @ComponentScan(
  5. excludeFilters = {@Filter(
  6. type = FilterType.CUSTOM,
  7. classes = {TypeExcludeFilter.class}
  8. ), @Filter(
  9. type = FilterType.CUSTOM,
  10. classes = {AutoConfigurationExcludeFilter.class}
  11. )}
  12. )

1,@SpringBootConfiguration
  1. @Configuration //代表当前是一个配置类

2,@ComponentScan

指定扫描哪些,Spring注解;

3,@EnableAutoConfiguration
  1. @AutoConfigurationPackage
  2. @Import({AutoConfigurationImportSelector.class})
  3. public @interface EnableAutoConfiguration {}

1,@AutoConfigurationPackage
  1. @Import({Registrar.class}) //给容器导入一个组件
  2. public @interface AutoConfigurationPackage {}
  3. //利用Registrar给容器中导入一系列组件
  4. //将指定的一个包下的所有组件导入进来?MainApplication所在包下

2,@Import({AutoConfigurationImportSelector.class})
  1. 1,利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
  2. 2,调用List<String> configurations = getCandidateConfigurations(annotationMetadata,attributes)获取到所有需要导入到容器中的配置类
  3. 3,利用工厂加载Map<String,List<String>loadSpringFactories(@Nullable ClassLoader classLoader);得到所有的组件
  4. 4,从META-INF/spring.factories位置来加载一个文件.默认扫描我们系统里面所有META-INF/spring.factories位置的文件
  5. spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories

3.2,按需开启自动配置项

  1. 1,虽然我们127个场景的所有自动配置启动的时候默认全部加载
  2. 按照条件装配规则(@Conditional),最终会按需配置

3.3,修改默认配置

  1. @Bean
  2. @ConditionalOnBean({MultipartResolver.class}) //容器中有这个类型组件
  3. @ConditionalOnMissingBean(
  4. name = {"multipartResolver"}
  5. ) //容器中没有这个名字multipartResolver的组件
  6. public MultipartResolver multipartResolver(MultipartResolver resolver) {
  7. //给@Bean标注的方法传入了对象参数,这个参数的值就会从容器中找.
  8. //springmvc multipartResolver.防止有些用户配置的文件上传解析器不符合规范 文件上传解析器
  9. return resolver;
  10. }
  11. 给容器加入了文件上传解析器

SpringBoot默认会在底层配置好所有的组件,但是如果用户配置了以用户的优先

  1. @Bean
  2. @ConditionalOnMissingBean
  3. public CharacterEncodingFilter characterEncodingFilter() {}

总结:
  1. SpringBoot先加载所有的自动配置类 xxxxAutoConfiguration
  2. 每个指定配置类按照条件进行生效,默认配置文件指定的值. XXXXProperties里面拿.xxxPerperties和配置文件进行了绑定
  3. 生效的配置类就会给容器中装配很多的组件
  4. 只要容器中有这些组件,相当于这些功能就有了
  5. 只要用户有自己配置的,就以用户优先
  6. 定制化配置
  7. 用户直接自己@Bean替换底层组件
  8. 用户去看这个组件获取的配置文件什么值

xxxAutoConfiguration —>组件 —>xxxProperties里面拿值 —-> application.properties

3.4,最佳实践

引入场景依赖
  1. [https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.build-systems.starters](https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.build-systems.starters)

查看自动配置了哪些(选做)
  1. 自己分析,引入场景对应的自动配置一般都生效了
  2. 配置文件中debug=true 开启自动配置报告. Negative(不生效) \ Positive(生效)

是否需要定制化
  1. 参考文档修改配置项https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties.json
  2. 自己分析.xxxProperties绑定了配置文件的哪些

自定义加入或者替换组件
  1. [@Bean ](/Bean ) , [@Component.... ](/Component.... )

自定义器 XXXCustomizer;

4,开发小技巧

4.1,Lombok

简化javaBean开发

  1. <dependency>
  2. <groupId>org.projectlombok</groupId>
  3. <artifactId>lombok</artifactId>
  4. </dependency>
  5. 并搜索安装lombok
  6. @Data //get set
  7. @ToString //toString
  8. @NoArgsConstructor //无参构造
  9. @AllArgsConstructor //有参构造
  10. @Component
  11. @ConfigurationProperties(prefix = "mycar")
  12. public class Car {
  13. private String brand;
  14. private Integer price;
  15. }
  16. //写入日志
  17. @Slf4j
  18. @RestController
  19. public class HelloController {
  20. @RequestMapping("/hello")
  21. public String handle01(String name) {
  22. log.info("进入:handle01方法!"); //*********************
  23. return "Hello Spring Boot 2! 喜傲!"+name;
  24. }
  25. }

4.2,dev-tools

  1. <!-- springboot 自动快捷键重启-->
  2. <dependency>
  3. <groupId>org.springframework.boot</groupId>
  4. <artifactId>spring-boot-devtools</artifactId>
  5. <optional>true</optional>
  6. </dependency>

Ctel + F9;

4.3,Spring Initailizer

idea 快速创建 SpringBoot项目

04,配置文件

1,文件类型

1.1,properties

同以前的properties用法

1.2,yaml

1.2.1,简介

YAML是”YAML Ain’t Markup Language” (YAML 不是一种标记语言) 的递归缩写 .在开发的这种语言时,YAML的意思其实是:”Yet Another Markup Language” (扔是一种标记语言).

非常适合用来做以数据为中心的配置文件

1.2.2,基本语法

  1. key:value; kv之间有空格
  2. 大小写敏感
  3. 使用缩进表示层级关系
  4. 缩进不允许使用tab , 只允许使用空格
  5. 缩进的空格数不重要 , 只要相同层级的元素左对齐即可
  6. '#'表示注释
  7. "与"表示字符串类容会被 转义/不转义

1.2.3,数据类型

  1. 字面量: 单个的,不可再分的值. data,boolean,string,number,null
  1. k: v
  1. 对象: 键值对的集合.map,hash,set,object
  1. 行内写法: k: {k1:v1,k2:v2,k3:v3}
  2. #或
  3. k:
  4. k1: v1
  5. k2: v2
  6. k3: v3
  1. 数组: 一组按次序排列的值. array, list , queue
  1. 行内写法: k:[v1,v2,v3]
  2. #或者
  3. k:
  4. - v1
  5. - v2
  6. - v3

Component 在yaml 配置时自动提示 不打包自动提示

  1. <!-- bean类在yaml自动提示插件-->
  2. <dependency>
  3. <groupId>org.springframework.boot</groupId>
  4. <artifactId>spring-boot-configuration-processor</artifactId>
  5. <optional>true</optional>
  6. </dependency>
  7. 在springboot打包配置中 加入 可以在打包的时候 不打包processor自动提示包
  8. <build>
  9. <plugins>
  10. <plugin>
  11. <groupId>org.springframework.boot</groupId>
  12. <artifactId>spring-boot-maven-plugin</artifactId>
  13. <configuration>
  14. <excludes>
  15. <exclude>
  16. <groupId>org.springframework.boot</groupId>
  17. <artifactId>spring-boot-configuration- ` processor</artifactId>
  18. </exclude>
  19. </excludes>
  20. </configuration>
  21. </plugin>
  22. </plugins>
  23. </build>

05,Web开发

1,SpringMVC自动配置

Spring Boot provides auto-configuration for Spring MVC that works well with most applications.(大多场景我们都无需自定义配置)

The auto-configuration adds the following features on top of Spring’s defaults:

  • Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.
    • 内容协商视图解析器和BeanName视图解析器
  • Support for serving static resources, including support for WebJars (covered later in this document)).
    • 静态资源(包括webjars)
  • Automatic registration of Converter, GenericConverter, and Formatter beans.
    • 自动注册 Converter,GenericConverter,Formatter
  • Support for HttpMessageConverters (covered later in this document).
    • 支持 HttpMessageConverters (后来我们配合内容协商理解原理)
  • Automatic registration of MessageCodesResolver (covered later in this document).
    • 自动注册 MessageCodesResolver (国际化用)
  • Static index.html support.
    • 静态index.html 页支持
  • Custom Favicon support (covered later in this document).
    • 自定义 Favicon
  • Automatic use of a ConfigurableWebBindingInitializer bean (covered later in this document).
    • 自动使用 ConfigurableWebBindingInitializer ,(DataBinder负责将请求数据绑定到JavaBean上)

If you want to keep those Spring Boot MVC customizations and make more MVC customizations (interceptors, formatters, view controllers, and other features), you can add your own @Configuration class of type WebMvcConfigurer but without @EnableWebMvc.

不用@EnableWebMvc注解。使用 **@Configuration** + **WebMvcConfigurer** 自定义规则

If you want to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter, or ExceptionHandlerExceptionResolver, and still keep the Spring Boot MVC customizations, you can declare a bean of type WebMvcRegistrations and use it to provide custom instances of those components.

声明 **WebMvcRegistrations** 改变默认底层组件

If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc, or alternatively add your own @Configuration-annotated DelegatingWebMvcConfiguration as described in the Javadoc of @EnableWebMvc.

使用 **@EnableWebMvc+@Configuration+DelegatingWebMvcConfiguration 全面接管SpringMVC**

2,简单功能分析

2.1,静态资源访问

1,静态资源目录

类路径下: called/static(or/public or /resources or /META-INF/resources

访问 : 当前项目根路径 / + 静态资源名

静态资源 和ming请求同名

原理: 静态资源映射/**.

请求进来先去找controller看能不能处理,不能处理所有请求又都交给静态资源处理器.静态资源能不能找到:

静态资源能找到就返回静态资源,静态资源找不到就返回404

改变默认的静态资源路径

  1. spring:
  2. mvc:
  3. static-path-pattern: /static/**
  4. web:
  5. resources:
  6. # static-locations: [clsspath:/static,clsspath:/.......]
  7. static-locations: clsspath:/static

2,静态资源访问前缀

springboot 默认 是/** 是没有前缀的

但是可以在yaml中: 增加前缀

  1. spring:
  2. mvc:
  3. #默认是: /** 扫描根目录下所有资源
  4. static-path-pattern: /static/**

当前项目 + static-path-pattem+静态资源名 = 静态资源文件下找

3,webjar

自动映射

https://www.webjars.org/

  1. <dependency>
  2. <groupId>org.webjars</groupId>
  3. <artifactId>jquery</artifactId>
  4. <version>3.5.1</version>
  5. </dependency>

访问地址: http://localhost:8080/webjars/jquery/3.5.1/jquery.js 后面地址要按照依赖地址的包路径

2.2,欢迎页支持

  1. 静态资源路径下 index.html
  2. 可以配置静态资源路径
  3. 但是不可以配置静态资源的访问前缀.否则导致index.html不能被默认访问
  1. spring:
  2. # mvc:
  3. # static-path-pattern: /stat/** //这个会导致welcome page功能失效
  1. controller能处理/index

2.3,自定义 Favicon

favicon.ico 放在静态资源目录下即可.

  1. spring:
  2. ## mvc:
  3. ## static-path-pattern: /stat/** 这个会导致Favicon.ico 功能失效

2.4静态资源配置原理

SpringBoot启动默认加载 XXXAutoConfiguration类(自动配置类)

SpringMVC功能的自动配置类WebMvcAutoConfiguration,生效

  1. @Configuration(proxyBeanMethods = false)
  2. @ConditionalOnWebApplication(type = Type.SERVLET)
  3. @ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
  4. @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
  5. @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
  6. @AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
  7. ValidationAutoConfiguration.class })
  8. public class WebMvcAutoConfiguration {}

给容器中配置了什么

  1. @Configuration(proxyBeanMethods = false)
  2. @Import(EnableWebMvcConfiguration.class)
  3. @EnableConfigurationProperties({ WebMvcProperties.class, WebProperties.class })
  4. @Order(0)
  5. public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer, ServletContextAware {}

配置文件的相关属性和xxx进行了绑定,WebMvcPropertiesspring.mvc,WebPropertiesspring.web

1,配置了只有一个有参构造器
  1. //有参构器所有参数的值都会从容器中确定
  2. //WebProperties webProperties: 获取和spring.web绑定的所有值的对象
  3. //WebMvcProperties mvcProperties: 获取和spring.mvc绑定的所有值的对象
  4. //ListableBeanFactory beanFactory Spring的beanFactory
  5. //ResourceHandlerRegistrationCustomizer 找到 资源处理器的自定义器. ==========
  6. //DispatcherServletPath
  7. //ServletRegistrationBean //给应用注册Servlet,Filter...
  8. public WebMvcAutoConfigurationAdapter(WebProperties webProperties, WebMvcProperties mvcProperties,
  9. ListableBeanFactory beanFactory, ObjectProvider<HttpMessageConverters> messageConvertersProvider,
  10. ObjectProvider<ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider,
  11. ObjectProvider<DispatcherServletPath> dispatcherServletPath,
  12. ObjectProvider<ServletRegistrationBean<?>> servletRegistrations) {
  13. this.resourceProperties = webProperties.getResources();
  14. this.mvcProperties = mvcProperties;
  15. this.beanFactory = beanFactory;
  16. this.messageConvertersProvider = messageConvertersProvider;
  17. this.resourceHandlerRegistrationCustomizer = resourceHandlerRegistrationCustomizerProvider.getIfAvailable();
  18. this.dispatcherServletPath = dispatcherServletPath;
  19. this.servletRegistrations = servletRegistrations;
  20. this.mvcProperties.checkConfiguration();
  21. }
  1. @Override
  2. public void addResourceHandlers(ResourceHandlerRegistry registry) {
  3. if (!this.resourceProperties.isAddMappings()) {
  4. logger.debug("Default resource handling disabled");
  5. return;
  6. }
  7. //webjars的规则
  8. addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");
  9. addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (registration) -> {
  10. registration.addResourceLocations(this.resourceProperties.getStaticLocations());
  11. if (this.servletContext != null) {
  12. ServletContextResource resource = new ServletContextResource(this.servletContext, SERVLET_LOCATION);
  13. registration.addResourceLocations(resource);
  14. }
  15. });
  16. }
  1. spring:
  2. web:
  3. resources:
  4. add-mappings: false #引用所有的静态资源
  5. cache:
  6. period: 120 #设置静态缓存时间
  1. HandlerMapping: 处理器映射.保存了每一个handler能处理哪些请求
  2. @Bean
  3. public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext,
  4. FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
  5. WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(
  6. new TemplateAvailabilityProviders(applicationContext), applicationContext, getWelcomePage(),
  7. this.mvcProperties.getStaticPathPattern());
  8. welcomePageHandlerMapping.setInterceptors(getInterceptors(mvcConversionService, mvcResourceUrlProvider));
  9. welcomePageHandlerMapping.setCorsConfigurations(getCorsConfigurations());
  10. return welcomePageHandlerMapping;
  11. }
  12. WelcomePageHandlerMapping(TemplateAvailabilityProviders templateAvailabilityProviders,
  13. ApplicationContext applicationContext, Resource welcomePage, String staticPathPattern) {
  14. //要用欢迎页功能必须是/**
  15. if (welcomePage != null && "/**".equals(staticPathPattern)) {
  16. logger.info("Adding welcome page: " + welcomePage);
  17. setRootViewName("forward:index.html");
  18. }
  19. else if (welcomeTemplateExists(templateAvailabilityProviders, applicationContext)) {
  20. //掉用Controller /index
  21. logger.info("Adding welcome page template: index");
  22. setRootViewName("index");
  23. }
  24. }

4,favicon

浏览器会发送/favicon.ico请求获取到图标,整个session期间不能在获取

3,请求参数处理

  1. [@xxxMapping ](/xxxMapping ) GET POST
  2. Rest风格支持(谁用Http请求方式动词来表示对资源的操作)
  3. 以前:/getUser 获取用户 /deleteUser 删除用户 /editUser 修改用户 /saveUser保存用户
  4. 现在:/user GET-获取用户 DELETE-删除用户 PUT-修改用户 POST-保存用户
  5. 核心Filter; HiddenHttpMethodFilter
  6. 用法: 表单method=post , 隐藏域_method=put
  7. SpringBoot中手动开启
  1. @Bean
  2. @ConditionalOnMissingBean(HiddenHttpMethodFilter.class)
  3. @ConditionalOnProperty(prefix = "spring.mvc.hiddenmethod.filter", name = "enabled")
  4. public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
  5. return new OrderedHiddenHttpMethodFilter();
  6. }

Rest原理(表单提交使用REST的时候)

  1. 表单上提交会带上_method=PUT
  2. 请求过来被HiddenHttpMethodFilter拦截
  3. 请求是否正常,并且是POST
  4. 获取到_method的值
  5. 兼容以下请求:
  1. HttpMethod.PUT.name(),HttpMethod.DELETE.name(), HttpMethod.PATCH.name()
  1. 原生request(post),包装模式requesWrapper重写了getMethod方法,返回的是传入的值
  2. 过滤器链放行的时候用wrapper.以后的方法调用getMethod是调用requestWrapper

Rest使用客户端工具,

  1. PostMan直接发送Put,delete等方式请求,无需Filter
  1. Spring
  2. mvc:
  3. hiddenmethod:
  4. filter:
  5. enabled: true #开启页面表单的Rest功能

自定义修改_method

  1. @Bean
  2. public HiddenHttpMethodFilter hiddenHttpMethodFilter(){
  3. HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
  4. hiddenHttpMethodFilter.setMethodParam("_m");
  5. return hiddenHttpMethodFilter;
  6. }

2,请求映射原理

image

SpringMVC功能分析都从DispatcherServlet —> doDispatch

  1. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
  2. HttpServletRequest processedRequest = request;
  3. HandlerExecutionChain mappedHandler = null;
  4. boolean multipartRequestParsed = false;
  5. WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
  6. try {
  7. ModelAndView mv = null;
  8. Exception dispatchException = null;
  9. try {
  10. processedRequest = checkMultipart(request);
  11. multipartRequestParsed = (processedRequest != request);
  12. //找到当前请求使用那个handler(Controller)处理
  13. // Determine handler for the current request.
  14. mappedHandler = getHandler(processedRequest);
  15. //HandlerMapping : 处理器映射. /xxx->>xxxxx

image2

RequestMappingHandlerMapping : 保存了所有@RequestMapping和handler的映射规则

image3

所有的请求映射都在HandlerMapping中.

-SpringBoot自动配置欢迎页的 WelcomePageHandlerMapping HandlerMapping.访问/能访问到index.html;

-SpringBoot配置了默认的RequestMappingHandlerAdapter

-请求进来,挨个尝试所有的HandlerMapping看是否有请求信息.

  1. 如果有就找到请求对应的Handler
  2. 如果没有就是下一个HandlerMapping

我们需要一些自定义的映射处理,我们也可以给容器中放HandlerMapping . 自定义HandlerMapping

1,普通参数与基本注解

  1. **注解**

@PathVariable,@RequestHeader,@ModelAttribute,@RequesParam,@MatrixVariable,@CookieValue,

@RequestBody

@PathVariable 获取路径信息

  1. <a href="/car/3/owner/lisi">/car/{id}/owner/{username}</a>
  2. <li>@PathVariable(路径变量)</li>
  1. // car/2/owner/zhangsan
  2. @GetMapping("/car/{id}/owner/{username}")
  3. public Map<String,Object> getCar(@PathVariable("id") Integer id,
  4. @PathVariable("username") String name,
  5. @PathVariable() Map<String,String> pv){
  6. Map<String,Object> map = new HashMap<>();
  7. map.put("id",id);
  8. map.put("name",name);
  9. map.put("pv",pv);
  10. return map;
  11. }

@RequestHeader 获取请求头数据

  1. // car/2/owner/zhangsan
  2. @GetMapping("/car/{id}/owner/{username}")
  3. public Map<String,Object> getCar(@PathVariable("id") Integer id,
  4. @PathVariable("username") String name,
  5. @PathVariable() Map<String,String> pv,
  6. @RequestHeader("Host") String userHost,
  7. @RequestHeader Map<String,String> header){
  8. Map<String,Object> map = new HashMap<>();
  9. map.put("id",id);
  10. map.put("name",name);
  11. map.put("pv",pv);
  12. map.put("userHost",userHost); //获取请求用户的Host
  13. map.put("header",header); //获取请求用户的所有请求头信息
  14. return map;
  15. }

@RequesParam(“指定name”) 获取表单指定属性

@CookicValue 获取Cookic

  1. //@CookieValue("_ga") String _ga, //获取指定Cookie
  2. //@CookieValue Cookie cookie, //获取全部Cookie

@RequestBody post提交 获取表单全部数据

  1. @PostMapping("/save")
  2. public Map postMethod(@RequestBody String content){
  3. Map<String ,String> map = new HashMap<>();
  4. map.put("content",content);
  5. return map;
  6. }

@RequestAttribute() //获取转发来的request域中的数据 记住 forward: 请求转发

  1. @GetMapping("/goto")
  2. public String goToPage(HttpServletRequest request){
  3. request.setAttribute("msg","成功了");
  4. request.setAttribute("code",200);
  5. return "forward:/success"; //转发到 /success请求
  6. }
  7. @ResponseBody
  8. @GetMapping("/success")
  9. public Map success(@RequestAttribute("msg") String msg,
  10. @RequestAttribute("code") Integer code,
  11. HttpServletRequest request){
  12. Object msg1 = request.getAttribute("msg");
  13. Map<String,Object> map = new HashMap<>();
  14. map.put("reqMethod_msg",msg1);
  15. map.put("annotation_msg",msg);
  16. map.put("annotation_code",code);
  17. return map;
  18. }

@MatrixVariable

  1. // /cars/sell;low=34;brand=byd,audi,yd
  2. //SpringBoot默认禁用了矩阵变量的功能
  3. // 手动开启 : 原理. 对于路径的处理.UrlPathHelper进行解析.
  4. // removeSemicolonContent(移除分号内容)支持矩阵变量
  5. @GetMapping("/cars/{path}")
  6. public Map carsSell(@MatrixVariable("low") Integer low
  7. ,@MatrixVariable("brand") List<String> brand,
  8. @PathVariable("path") String path){
  9. Map<String, Object> map = new HashMap<>();
  10. map.put("low",low);
  11. map.put("brand",brand);
  12. map.put("path",path);
  13. return map;
  14. }

需要配置开启矩阵变量功能 因为默认是禁用矩阵变量 的 true 改成 set false

  1. //1,WebMvcConfigurer定制化SpringMVC的功能
  2. @Bean
  3. public WebMvcConfigurer webMvcConfigurer(){
  4. return new WebMvcConfigurer() {
  5. @Override
  6. public void configurePathMatch(PathMatchConfigurer configurer) {
  7. UrlPathHelper urlPathHelper = new UrlPathHelper();
  8. //不移除:后面的内容. 矩阵变量功能就可以生效
  9. urlPathHelper.setRemoveSemicolonContent(false);
  10. configurer.setUrlPathHelper(urlPathHelper);
  11. }
  12. };
  13. }
  1. @MatrixVariable("low") //不同名
  2. @MatrixVariable(value = "age" ,pathVar = "bossId") //同名
  1. //如果两个var 是同名
  2. @GetMapping("/boss/{bossId}/{empId}")
  3. public Map boss(@MatrixVariable(value = "age" ,pathVar = "bossId") Integer bossAge,
  4. @MatrixVariable(value = "age" ,pathVar = "empId") Integer empAge){
  5. Map<String, Object> map = new HashMap<>();
  6. map.put("bossAge",bossAge);
  7. map.put("empAge",empAge);
  8. return map;
  9. }
  1. <li>@PathVariable(路径变量)</li>
  2. <li>@RequestHeader(获取请求头)</li>
  3. <li>@RequestParam(获取请求参数)</li>
  4. <li>@CookieValue(获取Cookie值)</li>
  5. <li>@RequestAttribute(获取request域属性)</li>
  6. <li>@RequestBody(获取请求体)</li>
  7. <li>@MatrixVariable(矩阵变量)</li>

Servlet API

WebRequest, ServletRequest,MultipartRequest,HttpSession,javax.servlet.http.PushBuilder,Principal,

InputStream,Reader,HttpMethod,Locale,TimeZone,Zoneld

复杂参数

Map,Errors/BindingResult,Model,RedirectAttributes,ServletResponse,SessionStatus,UriComponentsBuider,ServletUriComponentsBuider

自定义对象参数

可以自动类型格式与格式化,可以级联封装.

2,POJO封装过程

3,参数处理原理

HandlerMappering中找到能处理请求的Handler(Controller.method())

为当前Handler找一个适配器HandlerAdapter; RequestMappingHandlerAdapter

1,HandlerAdapter

image00001

0-支持方法上标注@RequestMapping

1-支持函数式编程的

2,执行目标方法

  1. // Actually invoke the handler.
  2. //DispatcherServlet --- doDispach
  3. mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
  1. mav = invokeHandlerMethod(request, request,handlerMethod); //执行目标方法
  2. //ServietInvocableHandlerMethod
  3. Object returnValue = invokForRequest(webRequest,mavContainer,providedArgs);
  4. //获取方法参数值
  5. Object[] args = getMethodArgumentValues(request,mavContainer,providedArgs)

3,参数解析器

确定将要执行的目标方法的每一个值是什么

SpringMVC目标方法能写多少种参数类型,取决于参数解析器.

参数解析器

参数解析器接口

当前解析器是否支持解析这种参数

支持就调用 resolveArgument

4,返回值处理器

返回值处理器

5,如何确定目标方法每一个参数的值

  1. ============InvocableHandlerMethod==========================
  2. protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
  3. Object... providedArgs) throws Exception {
  4. MethodParameter[] parameters = getMethodParameters();
  5. if (ObjectUtils.isEmpty(parameters)) {
  6. return EMPTY_ARGS;
  7. }
  8. Object[] args = new Object[parameters.length];
  9. for (int i = 0; i < parameters.length; i++) {
  10. MethodParameter parameter = parameters[i];
  11. parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
  12. args[i] = findProvidedArgument(parameter, providedArgs);
  13. if (args[i] != null) {
  14. continue;
  15. }
  16. if (!this.resolvers.supportsParameter(parameter)) {
  17. throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
  18. }
  19. try {
  20. args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
  21. }
  22. catch (Exception ex) {
  23. // Leave stack trace for later, exception may actually be resolved and handled...
  24. if (logger.isDebugEnabled()) {
  25. String exMsg = ex.getMessage();
  26. if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
  27. logger.debug(formatArgumentError(parameter, exMsg));
  28. }
  29. }
  30. throw ex;
  31. }
  32. }
  33. return args;
  34. }

5.1挨个判断所有参数解析器那个支持解析这个参数
  1. @Nullable
  2. private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
  3. HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
  4. if (result == null) {
  5. for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
  6. if (resolver.supportsParameter(parameter)) {
  7. result = resolver;
  8. this.argumentResolverCache.put(parameter, result);
  9. break;
  10. }
  11. }
  12. }
  13. return result;
  14. }

自定义Converter原理

  1. <form action="/saveuser" method="post">
  2. 姓名: <input name="userName" value="zhangsan"/> <br>
  3. 年龄: <input name="age" value="18"/> <br>
  4. 生日: <input name="birth" value="2019/12/10"><br>
  5. <!-- 宠物姓名: <input name="pet.name" value="阿猫"><br>-->
  6. <!-- 宠物年龄; <input name="pet.age" value="5"><br>-->
  7. 宠物: <input name="pet" value="阿猫,3"/>
  8. <input type="submit" value="提交">
  9. </form>
  1. @Data
  2. public class Person {
  3. private String userName;
  4. private Integer age;
  5. private Date birth;
  6. private Pet pet;
  7. }
  8. @Data
  9. public class Pet {
  10. private String name;
  11. private Integer age;
  12. }
  1. /**
  2. * 数据绑定: 页面提交的请求数据(GET,POST)都可以和对象属性进行绑定
  3. * @param person
  4. * @return
  5. */
  6. @PostMapping("/saveuser")
  7. public Person saveuser(Person person){
  8. return person;
  9. }
  1. 自定义Converter
  2. @Bean
  3. public WebMvcConfigurer webMvcConfigurer(){
  4. return new WebMvcConfigurer() {
  5. @Override
  6. public void addFormatters(FormatterRegistry registry) {
  7. registry.addConverter(new Converter<String , Pet>() {
  8. @Override
  9. public Pet convert(String source) {
  10. //阿猫. 3
  11. if (!StringUtils.isEmpty(source)){
  12. Pet pet = new Pet();
  13. String[] split = source.split(",");
  14. pet.setName(split[0]);
  15. pet.setAge(Integer.parseInt(split[1]));
  16. return pet;
  17. }
  18. return null;
  19. }
  20. });
  21. }
  22. };
  23. }
  24. 浏览器会先传送一个name=pet的,值=”阿猫,3“的数据给服务器,
  25. 底层在处理到自定义对象参数(此时没有发生判断,在服务器层面这个参数此时和上面服务器传来的数据无关)的时候会先找到这个自定义对象参数类型,然后调用参数解析器,当调用自定义参数解析器
  26. 处理这个参数的时候,会先找所有的Converter进行类型转换,此时自定义的ConverterString->Pet,此时浏览器传送过来的是String类型的数据,服务器找到的接收数据的对象参数是Person,而Person中有Pet,所以在绑定Person中的Pet属性时,就会调用到String->Pet这个自定义的Converter进行属性数据绑定,而Person中的其他属性比如Integer类型的ageDate类型的birth就会调用其他的Converter比如String->Integer,String->Date来进行属性数据绑定
  27. ————————————————
  28. 版权声明:本文为CSDN博主「陪安琪度过一生」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
  29. 原文链接:https://blog.csdn.net/m0_56965737/article/details/118656010

4,响应数据与内容协商

1,响应JSON

1.1,jackson.jar+ResponseBody

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>
  5. web场景自动引入了json依赖
  6. <dependency>
  7. <groupId>org.springframework.boot</groupId>
  8. <artifactId>spring-boot-starter-json</artifactId>
  9. <version>2.6.4</version>
  10. <scope>compile</scope>
  11. </dependency>

@ResponseBody

给前段自动返回json数据;

2,返回值解析器原理

返回值解析器原理

1,返回值处理判是否支持这种类型返回值 supportsReturnType

2,返回值处理器调用HandleReturnValue进行处理

3,RequestResponseBodyMethodProcessor可以处理返回值标注了@ResponseBody注解的.

  1. 1,利用MessageConverters进行处理 将数据写为json
  2. 1,内容协商(浏览器默认会以请求头的方式告诉服务器他能接受什么样的内容类型)
  3. 2,服务器最终根据自己自身的能力,决定服务器能生产出什么样内容类型的数据
  4. 3,SpringMVC会挨个遍历所有容器底层的 HttpMessageConverter ,看谁能处理
  5. 1,

1.2,SpringMVC到底支持哪些返回值

  1. ModelAndView
  2. Mode
  3. View
  4. ResponseEntity
  5. ResponseBodyEmitter
  6. StreamingResonseBody
  7. HttpEntity
  8. HttpHeaders
  9. Callable
  10. DeferredResult
  11. ListenableFuture
  12. CompletionStage
  13. WebAsyncTack
  14. @ModelAttribute
  15. @ResponseBady 注解 -----> ResponseBodyMethodProcessor;

1.2,HTTPMessageConverter原理

1,MessageConverter规范

HttpMessageConverter: 看是否支持将此Class类型的对象,转为MediaType类型的数据.

例子:Person对象转为JSON

2,默认的MessageConverter

3,开启浏览器参数方式内容协商功能

为了方便内容协商,开启基于请求参数的内容协商功能.

  1. #开启参数方式的内容协商 地址后面携带 ?format=你要 指定的获取的请求类型类型
  2. spring:
  3. mvc:
  4. contentnegotiation:
  5. favor-parameter: true
  6. #http://localhost:8080/test/person?format=json
  7. #http://localhost:8080/test/person?format=xml

确定客户端接受什么样的内容类型;

1,Parameter策略优先确定是要返回json数据

return request.getParameter(getParameterName());

4,内容协商

  1. WebMvcConfigurationSupport
  2. jackson2XmlPresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.xml.XmlMapper", classLoader);

导入了jackson处理xml的包,xml的converter就会自动进来

5,自定义MessageConverter

实现多协议数据兼容.json,xml,x-guigu

0,@ResponseBody,响应数据出去 调用RequestResponseBodyMethodProcessor处理

1,Processor处理方法返回值,通过MessageConverter处理

2,所有MessageConverter合起来可以支持各种媒体类型数据的操作(读,写)

3,内容协商找到最终的messageConverter;

SpringMVC的什么功能.一个入口 给容器中添加一个: WebMvcConfigurer

  1. @Bean
  2. public WebMvcConfigurer webMvcConfigurer(){
  3. //矩阵变量生效
  4. return new WebMvcConfigurer() {
  5. @Override
  6. public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
  7. }
  8. }
  1. /**
  2. * 自定义的Converter
  3. */
  4. public class XiaoMessageConverter implements HttpMessageConverter<Person> {
  5. //能不能读 Mappring(String name)
  6. @Override
  7. public boolean canRead(Class<?> clazz, MediaType mediaType) {
  8. return false;
  9. }
  10. //能不能写
  11. @Override
  12. public boolean canWrite(Class<?> clazz, MediaType mediaType) {
  13. return clazz.isAssignableFrom(Person.class);
  14. }
  15. /**
  16. * 服务器要统计所有MessageConverter都能写出哪些内容类型
  17. *
  18. * application/x-xiao
  19. * @return
  20. */
  21. @Override
  22. public List<MediaType> getSupportedMediaTypes() {
  23. return MediaType.parseMediaTypes("application/x-xiao");
  24. }
  25. @Override
  26. public Person read(Class<? extends Person> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
  27. return null;
  28. }
  29. @Override
  30. public void write(Person person, MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
  31. //自定义协议数据的写出
  32. String data = person.getUserName()+";"+person.getAge()+";"+person.getBirth();
  33. //写出去
  34. OutputStream body = outputMessage.getBody();
  35. body.write(data.getBytes());
  36. }
  1. @Bean
  2. public WebMvcConfigurer webMvcConfigurer(){
  3. return new WebMvcConfigurer() {
  4. /**
  5. * 自定义内容协商策略
  6. * @param configurer
  7. */
  8. @Override
  9. public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
  10. //Map<String, MediaType> mediaTypes
  11. HashMap<String, MediaType> mediaTypes = new HashMap<>();
  12. mediaTypes.put("json",MediaType.APPLICATION_JSON);
  13. mediaTypes.put("xml",MediaType.APPLICATION_ATOM_XML);
  14. mediaTypes.put("xiao",MediaType.parseMediaType("application/x-xiao"));
  15. //指定支持解析哪些参数对应的哪些媒体类型
  16. ParameterContentNegotiationStrategy strategy = new ParameterContentNegotiationStrategy(mediaTypes);
  17. //软件 基于头的不可以是有加入
  18. HeaderContentNegotiationStrategy headerStrategy = new HeaderContentNegotiationStrategy();
  19. configurer.strategies(Arrays.asList(strategy));
  20. }
  21. @Override
  22. //新增MessageConverters
  23. public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
  24. //新增MessageConverters
  25. converters.add(new XiaoMessageConverter());
  26. }

有可能我们添加的自定义的功能会覆盖默认很多功能,导致默认功能失效.

5,视图解析器与模板引擎

视图解析:SpringBoot默认不支持JSP 需要引入第三方模板引擎技术实现页面渲染.

1,视图解析

1,视图解析原理

1,目标方法处理的过程中,所有数据都会被放在 ModelAndViewContainer 里面.包括数据和视图地址

2,方法的参数是一个自定义类型对象(从请求参数中确定的),把他重新放在 ModelAndViewContainer

3,任何目标方法执行完成以后都会返回 ModelAndView(视图和视图地址).

4,processDispatchResult 处理派发结果.(页面改如何响应)

  1. 1,render(mv,request,response);进行界面渲染

2,模板引擎-Thymeleaf

1,thymeleaf简介

现代化,服务端Java模板引擎

2,基本语法

1,表达式
表达式名字 语法 用途
变量取值 ${…} 获取请求域,session域,对象等值
选择变量 *{…} 获取上下文对象值
消息 #{…} 获取国际化等值
链接 @{…} 生成链接
片段表达式 ~{…} jsp:include 作用,引入公共页面

2,字面量

文本值:’one text’,’Another one!’,…

数字:0 , 34 , 3.0 , 12.3 ,…

布尔值:true , false

空值:null

变量: one,two,…变量不能有空格

3,文本操作

字符串拼接:+

变量替换:|The name is ${name}|

4,数学运算

运算符:+,-,*,/,%

5,布尔运算

运算符:and , or

一元运算:! , not

6,比较运算

比较:>,<,>=,<=(gt,lt,ge,le)

等式:=,=,!=(eq,ne)

7,条件运算

If-then:(if)?(then)

If-then-else:(if)?(then):(else)

Default: (value)?:(defaultvalue)

8,特殊操作

无操作: _

遍历操作

  1. <tr class="gradeX" th:each="user:${users}">
  2. <td>Trident</td>
  3. <td th:text="${user.userName}"></td>
  4. <td th:text="${user.password}"></td>
  5. </tr>
  6. stats 当前状态
  7. <tr class="gradeX" th:each="user,stats:${users}">
  8. <td th:text="${stats}">Trident</td>
  9. <td th:text="${user.userName}"></td>
  10. <td th:text="${user.password}"></td>
  11. </tr>

当前状态图片解释

引入页面

  1. 要引入的页面 common
  2. <div th:fragment="copy">
  3. ...
  4. </div>
  5. 被引入的页面
  6. <div th:insert="~{common :: copy}">
  7. </div>
  8. 被引入的页面 要引入的文件名字 和 引进设置的fragment value
  9. <div th:insert="common :: copy">
  10. </div>
  11. 也可以根据声明的id name class 进行 不用自己再次声明
  12. <div id="common">
  13. </div>
  14. 被引入的页面
  15. <div th:insert="~{commom :: #common}">
  16. </div>
  17. 有三种方法引入
  18. <div th:inscrt="footer :: copy">
  19. </div>
  20. <div th:replacr="footer :: copy">
  21. 相当于div 默认没有了
  22. 只有div内的内容
  23. </div>
  24. <div th:include="footer :: copy">
  25. 直接把内容放进来
  26. </div>
  27. th:insert :保留自己的主标签,保留th:fragment的主标签。
  28. th:replace :不要自己的主标签,保留th:fragment的主标签。
  29. th:include :保留自己的主标签,不要th:fragment的主标签。(官方3.0后不推荐)

3,设置属性值-th:attr

设置多个值
  1. <from action="subscribe.html" th:attr="action=@{/subscribe}">
  2. <fieldset>
  3. <input type="text" name="email" />
  4. <input type="submit" value="Subscribe!" th:attr="value=#{subscribe.submit}" />
  5. </fieldset>
  6. </from>

设置多个值
  1. <img src="../../images/gtvglogo.png" th:attr="src=@{/images/gtvglog.png},title=#{logo}"/>

以上两个的替代写法th:xxx

  1. <input type="submit" value="Subscribe!" th:value="#{subscribe.submit}" />
  2. <input action="subscribe.html" th:action="@{/subscribe}" />

所有h5兼容的标签写法

https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html#setting-value-to-specific-attributes

4,迭代

  1. <tr th:each="prod : ${prods}">
  2. <td th:text="${prod.name}" >Onions</td>
  3. <td th:text="${prod.price}" >2.41</td>
  4. <td th:text="${prod.inStock}? #{true} : #{false}" >yes</td>
  5. </tr>
  6. <tr class="gradeX odd" th:each="user:${users}">
  7. <tr class="gradeX odd" th:each="user,stat:${users}">
  8. <td th:text="${stat.count}">Trident</td>
  9. <td th:text="${user.getName()}">Internet
  10. Explorer 4.0</td>
  11. <td th:text="${user.getAge()}">Win 95+</td>
  12. <td class="center hidden-phone" th:text="${user.getEmail()}">4</td>
  13. <td class="center hidden-phone">X</td>
  14. </tr>

5,条件运算

  1. <a href="comments.html" th:href="@{/product/comments(prodId=${prod.id})}"
  2. th:if="${not #lists.isEmpty(prod.comments)}">
  3. View
  4. </a>
  1. <div th:switch="${user.role}" >
  2. <p th:case="'admin'">User is an administrator</p>
  3. <p th:case="#{roles.manager}">User is a manager</p>
  4. <p th:case="*">User is som other thing</p>
  5. </div>

3,thymeleaf使用

1,引入Starter

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-thymeleaf</artifactId>
  4. </dependency>

2,自动配置好了thymeleaf

  1. @Configuration(proxyBeanMethods = false)
  2. @EnableConfigurationProperties(ThymeleafProperties.class)
  3. @ConditionalOnClass({ TemplateMode.class, SpringTemplateEngine.class })
  4. @AutoConfigureAfter({ WebMvcAutoConfiguration.class, WebFluxAutoConfiguration.class })

自动配置好的策略
  1. 1,所有thymeleaf的配置都在 **ThymeleafProperties**
  2. 2,配置好了 **SpringTemplateEngine**
  3. 3,配置好了 **ThymeleafViewResolver**
  4. 4,我们只需要直接开发好页面
  1. public static final String DEFAULT_PREFIX = "classpath:/templates/"; //前缀
  2. public static final String DEFAULT_SUFFIX = ".html"; //后缀
  1. <html lang="en" xmlns:th="http://www.thymeleaf.org"> <!-- 加入获取代码提示 -->

3,页面开发

  1. <!DOCTYPE html> //引入代码提示
  2. <html lang="en" xmlns:th="http://www.thymeleaf.org"> <!-- *** -->
  3. <head>
  4. <meta charset="UTF-8">
  5. <title>Xiao</title>
  6. </head>
  7. <body>
  8. <h1 th:text="${msg}">哈哈</h1>
  9. <h2>
  10. <a href="www.baidu.com" th:href="${link}">去百度1</a>
  11. <a href="www.baidu.com" th:href="@{link}">去百度2</a>
  12. </h2>
  13. </body>
  14. </html>

4,构建后台管理系统

1,项目创建

2,静态资源处理

3,路径构建

4,模板抽取

5,页面跳转

6,数据渲染

6,拦截器

1,HandlerInterceptor接口

实现拦截器接口

  1. /**
  2. * 登录检查
  3. * 1,配置好拦截器要拦截哪些请求
  4. * 2,把这些配置放在容器中
  5. */
  6. public class LoginInterceptor implements HandlerInterceptor {
  7. /**
  8. * 目标方法执行之前
  9. * @param request
  10. * @param response
  11. * @param handler
  12. * @return
  13. * @throws Exception
  14. */
  15. @Override
  16. public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  17. //登录检查逻辑
  18. HttpSession session = request.getSession();
  19. Object loginUser = session.getAttribute("loginUser");
  20. if (loginUser !=null){
  21. //放行
  22. return true;
  23. }
  24. //拦截,未登录
  25. request.setAttribute("msg","请先登录");
  26. response.sendRedirect("/");
  27. return false;
  28. }
  29. /**
  30. * 目标方法执行完成以后
  31. * @param request
  32. * @param response
  33. * @param handler
  34. * @param modelAndView
  35. * @throws Exception
  36. */
  37. @Override
  38. public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
  39. HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
  40. }
  41. /**
  42. * 页面渲染以后
  43. * @param request
  44. * @param response
  45. * @param handler
  46. * @param ex
  47. * @throws Exception
  48. */
  49. @Override
  50. public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  51. HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
  52. }
  53. }

配置到容器中

  1. /**
  2. * 1,编写一个拦截器实现 HandlerInterceptor 接口
  3. * 2,拦截器注册到容器中(实现WebMvcConfigurer的addInterceptors)
  4. * 3,指定拦截规则[如果是拦截所有,静态拦截也会被拦截]
  5. */
  6. @Configuration
  7. public class AdMainWebConfig implements WebMvcConfigurer {
  8. @Override
  9. public void addInterceptors(InterceptorRegistry registry) {
  10. registry.addInterceptor(new LoginInterceptor())
  11. //拦截哪些
  12. .addPathPatterns("/**") //所有请求都会被拦截 包括 静态资源
  13. //放行哪些
  14. .excludePathPatterns("/","/login","/css/**","/fonts/**","/images/**","/js/**"); //放行的请求 放行静态资源
  15. }
  16. }

或者在yaml配置静态资源的路径id 但是所有静态资源请求都需要加上你设置的id /static/img…

  1. spring:
  2. mvc:
  3. static-path-pattern: /static/**

2,配置拦截器

↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑

3,验证拦截器

7,文件上传

1,页面表单

  1. <form method="post" action="/upload" enctype="multipart/from-data">
  2. <input type="file" name="file" />
  3. <input type="submit" value="提交"
  4. </form>

2,文件上传代码

前段代码

  1. <form role="form" th:action="@{/upload}" method="post" enctype="multipart/form-data">
  2. <div class="form-group">
  3. <label for="exampleInputEmail1">邮件</label>
  4. <input type="email" name="email" class="form-control" id="exampleInputEmail1" placeholder="Enter email">
  5. </div>
  6. <div class="form-group">
  7. <label for="exampleInputPassword1">名字</label>
  8. <input type="text" name="username" class="form-control" id="exampleInputPassword1" placeholder="Password">
  9. </div>
  10. <div class="form-group">
  11. <label for="exampleInputFile">头像</label>
  12. <input type="file" name="headerImg" id="exampleInputFile">
  13. </div>
  14. <div class="form-group">
  15. <label for="exampleInputFile">生活照片</label>
  16. <input type="file" name="photos" multiple>
  17. </div>
  18. <div class="checkbox">
  19. <label>
  20. <input type="checkbox"> Check me out
  21. </label>
  22. </div>
  23. <button type="submit" class="btn btn-primary">提交</button>
  24. </form>

后端代码

  1. /**
  2. * MultipartFile 自动封装上传过来的文件
  3. * @param email
  4. * @param username
  5. * @param headerImg
  6. * @param photos
  7. * @return
  8. */
  9. @PostMapping("/upload")
  10. public String upload(@RequestParam("email") String email,
  11. @RequestParam("username") String username,
  12. @RequestPart("headerImg") MultipartFile headerImg, //MultipartFile 获取上传文件的对象
  13. //RequestPart获取上传来的文件
  14. //MultipartFile[] 获取多个
  15. @RequestPart("photos") MultipartFile[] photos) throws IOException {
  16. log.info("上传的信息:email={},username={},headerImg={},photos={}",
  17. email,username,headerImg.getSize(),photos.length);
  18. if(!headerImg
  19. .isEmpty()){
  20. //保存到文件服务器.OSS服务器
  21. String originalFilename = headerImg.getOriginalFilename(); //拿取图片上传来了原生名
  22. //spring写自带的io
  23. headerImg.transferTo(new File("D:\\cache\\"+originalFilename));
  24. }
  25. if (photos.length > 0){
  26. for (MultipartFile photo : photos) {
  27. if (!photo.isEmpty()){
  28. String originalFilename = photo.getOriginalFilename();
  29. photo.transferTo(new File("D:\\cache\\"+originalFilename));
  30. }
  31. }
  32. }
  33. return "main";
  34. }

3,自动配置原理

  1. #spring自己设置了文件上传的最大值是1mb 所有可以自己修改
  2. spring:
  3. servlet:
  4. multipart:
  5. max-file-size: 10MB
  6. max-request-size: 100MB
  1. @EnableConfigurationProperties(MultipartProperties.class)
  2. MultipartAutoConfiguration

文件上传自动配置类-MultipartAutoConfiguration-MultiartProperties

  1. **自动配置好了 StandardServletMultipartResolver [文件上传]**
  2. **原理步骤**
  3. **1,请求进来使用文件上传解析器判断(isMultipart)并封装(resolveMultipart,返回MultipartHttpServletRequest)文件上传请求**
  4. **2,参数解析器来解析请求中的文件内容封装成multipartFile**
  5. 3,将request中文件信息封装为一个Map; MultiValueMap<String,MultipartFile>
  6. FileCopyUtils.实现文件流的拷贝

8,异常处理

1,错误处理

1,默认规则
  1. 默认情况下,Spring Boot提供/error处理所有错误的映射
  2. 对于机器客户端,它将生成JSON响应,其中包含错误,HTTP状态和异常消息的详细信息.对于浏览器客户端,
  3. 响应一个"whitelabel"错误视图,以HTML格式呈现相同的数据

要对其进行自定义,添加View解析为error

  1. 要完全替换默认行为,可以实现ErrorController并注册改类型的Bean定义,或添加ErrorAttributes类型的组件 以使用现有机制但替换其内容.

2,定义错误处理逻辑
  1. 自定义错误页
  2. error/404.html error/5xx.html
  3. [@ControllerAdvice ](/ControllerAdvice ) + @ExceptionHandler异常处理
  4. 实现HandlerExceptionResolver处理异常

3,异常处理原理
  1. **ErrorMvcAutoConfiguration 自动配置异常处理规则**
  2. **容器中的组件: DefaultErrorAttributes->id:errorAttributes**
  3. **public class DefaultErrorAttributes implements ErrorAttributes, HandlerExceptionResolver, Ordered {}**
  4. **容器中的组件: BasicErrorController->id:basicErrorController**
  5. **处理默认/error路径的请求; 页面响应 new ModelAndView("error",model)**
  6. **容器中有组件View->id:error;(响应默认错误页)**
  7. 容器中放组件 **BeanNameViewResolver(视图解析器);按照返回的视图名作为组件的id去容器中找View对象.**
  1. #server:
  2. # error:
  3. # path: /error 修改路径

9,原生组件注入

1,使用Servlet API

@Web…原生组件名称 //好记忆

@WebServlet //原生Servlet

@WebFilter //原生过滤器

@WebListener //原生监听器

  1. @ServletComponentScan(basePackages = "com.xiao.servlet") //指定扫描Servlet原生组件
  2. @SpringBootApplication
  3. public class Boot05WebAdminApplication { }
  1. @WebServlet(urlPatterns = "/my") //声明这是java HttpServlet 原生组件
  2. public class MyServlet extends HttpServlet {} //效果:直接响应,没有Spring拦截器
  1. @WebFilter(urlPatterns = {"/css/*","/images"}) //java 原生 过滤器声明
  2. public class MyFilter implements Filter {}
  1. @WebListener //Java原生 声明监听器
  2. public class MyServletContextListener implements ServletContextListener {}

推荐可以使用这种方式;

扩展:DispachServlet如何注册进来

  1. 容器中自动配置了 DispatchServlet 属性绑定到 WebMvcproperties;对应的配置文件配置项是 spring.mvc
  2. **通过** ServletRegistrationBean DispatchServlet 配置进来
  3. 默认映射的是"/"路径.

Tomcat-Servlet;

多个Servlet都能处理到同一层,精确优先原则

A:/my/

B:/my/1

2,使用RegistrationBean

ServletRegistrationBean,FilterRegistrationBean,and ServletlistenerRegistrationBean

  1. //(proxyBeanMethods = false):保证依赖的组件始终是单实例的
  2. @Configuration(proxyBeanMethods = true)
  3. public class MyRegistConfig {
  4. @Bean
  5. public ServletRegistrationBean myServlet(){
  6. MyServlet myServlet = new MyServlet();
  7. return new ServletRegistrationBean(myServlet,"/my");
  8. }
  9. @Bean
  10. public FilterRegistrationBean myFilter01(){
  11. MyFilter myFilter = new MyFilter();
  12. return new FilterRegistrationBean(myFilter,myServlet()); //第一种Filter设置
  13. }
  14. // @Bean
  15. // public FilterRegistrationBean myFilter02(){
  16. // MyFilter myFilter = new MyFilter();
  17. // FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(myFilter);
  18. // filterRegistrationBean.setUrlPatterns(Arrays.asList("/my","/css")); //第二种filter自定义设置路径
  19. // return filterRegistrationBean;
  20. // }
  21. @Bean
  22. public ServletListenerRegistrationBean myListener(){
  23. MyServletContextListener myServletContextListener = new MyServletContextListener();
  24. return new ServletListenerRegistrationBean(myServletContextListener);
  25. }
  26. }

10,嵌入式web容器

1,切换嵌入式Servlet容器

默认支持的webServlet

  1. Tomcat,Jetty,orUndertow
  2. ServletWebServerApplicationContext 容器启动寻找ServletWerbServerFactory 并引导创建服务器

切换服务器

原理;

  1. SpringBoot应用发现是Web应用.web场景包-导入tomcat
  2. web应用会创建一个web版的ioc容器 ServletWebServerApplicationContext
  3. ServletWebServerApplicationContext 启动的时候寻找 **ServeltWebServerFactory**(Servlet web服务器工厂--->Servlet web服务器)
  4. SpringBoot底层默认有很多WebServer工厂
  5. TomcatServletWebServerFactory,JettyServletWebServerFactory,or UndertowServletWebServerFactory
  6. 底层直接会有一个自动配置类. ServletWebServerFactoryAutoConfiguration

ServletWebServerFactoryAutoConfiguration导入了ServletWebServerFactoryAutoConfiguration(配置类)

ServletWebServerFactoryAutoConfiguration 配置类 根据动态判断系统中到底导入了那个web服务器的包.(默认是导入Web-start Tomcat包),容器中就有 TomcatServletWebServerFactory

TomcatServletWebServerFactory 创建出Tomcat服务器并启动;TomcatWebServer的构造器拥有初始化 方法

内嵌服务器,就是把手动启动服务器的代码调用(Tomcat核心jar包存在)s

2,定制Servlet容器

  1. 实现WebServerFactoryCustomizer
  2. 把配置文件的值和 **ServletWebServerFactory** 进行绑定绑定
  3. 修改配置文件server.xxx
  4. **直接自定义 ConfigurableServletWebServerFactory**

xxxxxCustomizer: 定制化器,可以改变xxx的默认规则

11,定制化原理

1,定制化的常见方式

  1. @Bean替换,增加容器中默认组件;视图解析器
  2. 修改配置文件;
  3. xxxxCustomizer;
  4. 编写自定义的配置类 xxxConfiguration;
  5. web应用 实现 WebMvcConfigurer即可定制化web功能;
  6. [@EnableWebMvc ](/EnableWebMvc ) + WebMvcConfigurer ---- [@Bean ](/Bean ) 可以全面接管 SpringMVC, 所有规则全部自己重新配置; 实现定制和扩展功能
  7. ........

2,原理分析套路

场景starter - xxxxAutoConfiguration - 导入xxx组件 - 绑定xxxProperties — 绑定配置文件项

6,数据访问

1,SQL

1,数据源的自动配置

1,导入JDBC场景
  1. 导入了数据源,jdbc,事务

1,自动配置的类
  1. DataSourceAutoConfiguration : 数据源的自动配置
  2. 修改数据源相关的配置: **spring.datasource**
  3. 数据库连接池的配置, 是自己容器中没有DataSource才自动配置的
  4. 底层默认配置好的连接池是: HikariDataSource
  5. 数据源配置跟 spring.datasource 绑定的
  6. DataSourceTransactionManagerAutoConfiguration: 事务管理器的自动配置
  7. jdbcTemplateAutoConfiguration: **JdbcTemplate的自动配置, 可以来对数据库进行crud**
  8. **可以修改这个配置项**[**@Configurationproperties(prefix **](/Configurationproperties(prefix )** = "spring.jdbc")来修改 jdbcTemplate **
  9. @Bean[@Primary ](/Primary ) JdbcTemplate; 容器中有这个组件
  10. JndiDataSourceAutoConfiguration: jndi的自动配置
  11. XADataSourceAutoConfiguration: 分布式事务相关

修改配置项

  1. spring:
  2. datasource:
  3. driver-class-name: com.mysql.jdbc.Driver
  4. url: jdbc:mysql://localhost:3306/springdb
  5. username: root
  6. password: zhang..0902
  7. #type: 数据源

2,使用Druid数据源

1,druid官方github地址

https://github.com/alibaba/druid

整合第三方技术的两种方式

  1. 自定义
  2. starter

2,自定义方式

1,创建数据源
  1. <dependency>
  2. <groupId>com.alibaba</groupId>
  3. <artifactId>druid</artifactId>
  4. <version>1.1.17</version>
  5. </dependency>
  6. <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
  7. destroy-method="close">
  8. <property name="url" value="${jdbc.url}" />
  9. <property name="username" value="${jdbc.username}" />
  10. <property name="password" value="${jdbc.password}" />
  11. <property name="maxActive" value="20" />
  12. <property name="initialSize" value="1" />
  13. <property name="maxWait" value="60000" />
  14. <property name="minIdle" value="1" />
  15. <property name="timeBetweenEvictionRunsMillis" value="60000" />
  16. <property name="minEvictableIdleTimeMillis" value="300000" />
  17. <property name="testWhileIdle" value="true" />
  18. <property name="testOnBorrow" value="false" />
  19. <property name="testOnReturn" value="false" />
  20. <property name="poolPreparedStatements" value="true" />
  21. <property name="maxOpenPreparedStatements" value="20" />
  22. </bean>
  1. <dependency>
  2. <groupId>com.alibaba</groupId>
  3. <artifactId>druid-spring-boot-starter</artifactId>
  4. <version>1.1.17</version>
  5. </dependency>
  6. spring:
  7. datasource:
  8. type: com.alibaba.druid.pool.DruidDataSource
  9. driver-class-name: com.mysql.jdbc.Driver
  10. url: jdbc:mysql://localhost:3306/springdb
  11. username: root
  12. password: zhang..0902
  13. druid:
  14. #2.连接池配置
  15. #初始化连接池的连接数量 大小,最小,最大
  16. initial-size: 5
  17. min-idle: 5
  18. max-active: 20
  19. #配置获取连接等待超时的时间
  20. max-wait: 60000
  21. #配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
  22. time-between-eviction-runs-millis: 60000
  23. # 配置一个连接在池中最小生存的时间,单位是毫秒
  24. min-evictable-idle-time-millis: 30000
  25. validation-query: SELECT 1 FROM DUAL
  26. test-while-idle: true
  27. test-on-borrow: true
  28. test-on-return: false
  29. # 是否缓存preparedStatement,也就是PSCache 官方建议MySQL下建议关闭 个人建议如果想用SQL防火墙 建议打开
  30. pool-prepared-statements: true
  31. max-pool-prepared-statement-per-connection-size: 20
  32. # 配置监控统计拦截的filters,去掉后监控界面sql无法统计,'wall'用于防火墙
  33. filter:
  34. stat:
  35. merge-sql: true
  36. slow-sql-millis: 5000
  37. wall:
  38. enabled: true
  39. #3.基础监控配置
  40. web-stat-filter:
  41. enabled: true
  42. url-pattern: /*
  43. #设置不统计哪些URL
  44. exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
  45. session-stat-enable: true
  46. session-stat-max-count: 100
  47. stat-view-servlet:
  48. enabled: true
  49. url-pattern: /druid/*
  50. reset-enable: true
  51. #设置监控页面的登录名和密码
  52. login-username: admin
  53. login-password: admin
  54. allow: 127.0.0.1
  55. #deny: 192.168.1.100

2,分析自动配置
  1. 扩展配置项 spring.datasource.druid
  1. @Import({DruidSpringAopConfiguration.class, //监控springBean的;配置spring.datasource.druid.aop-patterns
  2. DruidStatViewServletConfiguration.class,//监控页的配置:spring.datasource.druid.stat-view-servlet.enabled 默认开启
  3. DruidWebStatFilterConfiguration.class, //web监控配置spring.datasource.druid.web-stat-filter.enabled 默认开启
  4. DruidFilterConfiguration.class}) //所有Druid自己filter的配置
  1. private static final String FILTER_STAT_PREFIX = "spring.datasource.druid.filter.stat";
  2. private static final String FILTER_CONFIG_PREFIX = "spring.datasource.druid.filter.config";
  3. private static final String FILTER_ENCODING_PREFIX = "spring.datasource.druid.filter.encoding";
  4. private static final String FILTER_SLF4J_PREFIX = "spring.datasource.druid.filter.slf4j";
  5. private static final String FILTER_LOG4J_PREFIX = "spring.datasource.druid.filter.log4j";
  6. private static final String FILTER_LOG4J2_PREFIX = "spring.datasource.druid.filter.log4j2";
  7. private static final String FILTER_COMMONS_LOG_PREFIX = "spring.datasource.druid.filter.commons-log";
  8. private static final String FILTER_WALL_PREFIX = "spring.datasource.druid.filter.wall";
  9. private static final String FILTER_WALL_CONFIG_PREFIX = "spring.datasource.druid.filter.wall.config";

3,整合MyBatis

https://github.com/mybatis

starter

SpringBoot官方的Starter: spring-boot-starter-*

第三方: *-spring-boot-starter

  1. <dependency>
  2. <groupId>org.mybatis.spring.boot</groupId>
  3. <artifactId>mybatis-spring-boot-starter</artifactId>
  4. <version>2.2.2</version>
  5. </dependency>

1,配置模式
  1. 全局配置文件
  2. SqlSessionFactory : 自动配置好了
  3. SqlSession 自动配置了**SqlSessionTemplate**组合了**SqlSession**
  4. @Import(**AutoConfiguredMapperScannerRegistrar.class**)
  5. Mapper : 只要我们写的操作MyBatis的接口标准了[**@Mapper **](/Mapper )** ** 就会被自动扫描进来
  1. @EnableConfigurationProperties(MybatisProperties.class) //MyBatis配置项绑定类
  2. @AutoConfigureAfter({ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class })
  3. public class MybatisAutoConfiguration implements InitializingBean {}
  4. @ConfigurationProperties(prefix = MybatisProperties.MYBATIS_PREFIX)
  5. public class MybatisProperties {
  6. public static final String MYBATIS_PREFIX = "mybatis";
  7. }

可以修改配置文件中mybatis 开始的所有;

使用非注解
  1. #配置mybatis规则
  2. mybatis:
  3. config-location: classpath:mybatis/mybatis-config.xml #配置mybatis主配置文件
  4. mapper-locations: classpath:mybatis/mapper/*.xml #配置mybatis mappere文件
  5. configuration: #指定mybatis全局配置文件中的相关配置 #使用yaml配置文件 就不可以 指定主配置文件
  6. map-underscore-to-camel-case: true

所有mybatis yaml配置 都在 MybatisProperties 中

  1. 导入mybatis官方starter
  2. 编写mapp接口 . 标注@Mapper注解
  3. 编写sql映射文件并绑定mapper接口
  4. applicattion.yaml中指定Mapper配置文件的位置,以及指定全局配置文件的信息 (建议,配置在mybatis.configuration)

2,注解模式
  1. @Mapper
  2. public interface AccountDao {
  3. @Select("select * from account_tbl where id = #{id}")
  4. Account selectAcctById(int id);
  5. }

3,混合模式

在配置中加入mapper就行了

最佳实战:

  1. 引入mybatis-starter
  2. 配置application.yaml中,指定mapper-location位置即可
  3. 编写Mapper接口并标注@Mapper注解
  4. 简单方法直接注解方式
  5. 复杂方法编写Mapper.xml进行映射绑定映射
  6. //@MapperScan("com.xiao.dao,mapper")可以使用简化开发 在@SpringBootApplication类 可以不用每个 dao都写上[@Mapper ](/Mapper )

4,整合MyBatis-Plus完成CRUD

1,什么是MyBatis-Plus

MyBatis-Plus(简称 MP) 是一个MyBtis的增强工具,在MyBatis的基础上只做增强不做改变,为简化开发,提高效率而生.

mybatis plus 官网

不(我写的不 哈哈哈哈) 建议安装MyBatisX插件

2,整合MyBatis-Plus

自动配置

  1. **MybatisPlusAutoConfiguration**配置类,**MybatisPlusProperties**配置项绑定.**mybatis-plus: xxx就是对 mybatis-plus的定制**
  2. **SqlSessionFactory 自动配置好了** **底层是容器默认的数据源**
  3. **mapperLocations 自动配置好了的.有默认值. classpath_:/mapper/_/**.xml;**任意包的类路径下的所有 mapper文件夹下任意路径下的所有xml都是映射sql映射文件,建议以后sql映射文件,放在mapper下****
  4. **容器中也自动配置好了 SqlSessionTemplate**
  5. @**Mapper 标注的接口也会被自动扫描;** 建议直接MapperScan("com.xiao.dao.mapper")进行批量扫描

继承BaseMapper 优点:只需要继承BaseMapper就可以拥有crud能力

3,CRUD功能
  1. service <查询哪些数据类型>
  2. public interface User1Service extends IService<User1> {
  3. }
  1. serviceimpl
  2. @Service
  3. <当前service要用那个Dao,返回数据的类型>
  4. public class User1ServiceImpl extends ServiceImpl<User1Dao, User1> implements User1Service {
  5. }

分页插件

  1. @GetMapping("/dynamic_table")
  2. public String dynamic_table(Model model,@RequestParam(value = "page",defaultValue = "1")Integer page){
  3. //从数据库中查出user表中的用户进行展示
  4. // List<User1> list = user1Service.list();
  5. //
  6. //分页查询数据
  7. Page<User1> userPage = new Page<>(page, 2);
  8. //分页查询结果
  9. Page<User1> page1 = user1Service.page(userPage, null);
  10. //当前页
  11. long current = page1.getCurrent();
  12. //总页数
  13. long pages = page1.getPages();
  14. //总条记录
  15. long total = page1.getTotal();
  16. //查出数据库的数据
  17. List<User1> records = page1.getRecords();
  18. model.addAttribute("page",page1);
  19. return "table/dynamic_table";
  20. }

分页配置文件

  1. @Configuration
  2. public class MyBatisConfig {
  3. /**
  4. * MybatisPlusInterceptor
  5. * @return
  6. */
  7. @Bean
  8. public MybatisPlusInterceptor paginationInterceptor(){
  9. MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
  10. //这是分页拦截器
  11. PaginationInnerInterceptor paginationInnerInterceptor = new PaginationInnerInterceptor();
  12. //设置请求的页面大于最大页后操作, true 调回到首页, false 继续请求 默认false
  13. paginationInnerInterceptor.setOverflow(true);
  14. //设置最大单页限制数量, 默认500条, -1 不受限制
  15. paginationInnerInterceptor.setMaxLimit(500L);
  16. mybatisPlusInterceptor.addInnerInterceptor(paginationInnerInterceptor);
  17. return mybatisPlusInterceptor;
  18. }
  19. }

HTML Thymeleaf使用

  1. <tr class="gradeX" th:each="user,start:${page.records}">
  2. <td th:text="${start.count}">Trident</td>
  3. <td th:text="${user.name}">Internet
  4. Explorer 4.0
  5. </td>
  6. <td th:text="${user.age}">Win 95+</td>
  7. <td class="center hidden-phone" th:text="${user.email}">4</td>
  8. <td class="center hidden-phone">
  9. <a class="btn btn-danger" type="button" th:href="@{/user/delete/{id}(id=${user.id},pn=${page.current})}">删除</a>
  10. </td>

数据

  1. <div class="span6">
  2. <div class="dataTables_info" id="dynamic-table_info">
  3. 当前第 [[${page.current}]] 页,总计 [[${page.pages}]] 页,共 [[${page.total}]] 条记录
  4. </div>
  5. </div>

翻页

  1. <li class="prev disabled"><a href="#">← Previous</a></li>
  2. <li th:class="${num == page.current?'active':''}" th:each="num:${#numbers.sequence(1,page.pages)}"> //#numbers.sequence(遍历数字几到,几)
  3. <a th:href="@{/dynamic_table(page=${num})}">[[${num}]]</a>//**********
  4. </li>
  5. <li class="next disabled"><a href="#">Next → </a></li>

删除

  1. @GetMapping("/user/delete/{id}")
  2. public String deleteUser(@PathVariable("id") Long id,
  3. @RequestParam(value = "pn",defaultValue = "1")Integer pn,
  4. RedirectAttributes ra){
  5. user1Service.removeById(id);
  6. //重定向后会携带 page 这个值 也就是页数
  7. ra.addAttribute("pn", pn);
  8. return "redirect:/dynamic_table";
  9. }

2,NoSQL

Redis 是一个开源(BSD许可)的,内存中的数据结构存储系统,它可以用作数据库、缓存消息中间件。 它支持多种类型的数据结构,如 字符串(strings)散列(hashes)列表(lists)集合(sets)有序集合(sorted sets) 与范围查询, bitmapshyperloglogs地理空间(geospatial) 索引半径查询。 Redis 内置了 复制(replication)LUA脚本(Lua scripting)LRU驱动事件(LRU eviction)事务(transactions) 和不同级别的 磁盘持久化(persistence), 并通过 Redis哨兵(Sentinel)和自动 分区(Cluster)提供高可用性(high availability)。

1,Redis自动配置
  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-data-redis</artifactId>
  4. </dependency>

自动配置:

  1. RedisAutoConfiguration 自动配置类. RedisProperties 属性类 --> spring.redis.xxx 是对redis的配置
  2. 连接工厂是准备好的.LettuceConnectionConfiguration,JedisConnectionConfiguration
  3. 自动注入了**RedisTemplate**<**Object**, **Object**> : xxxTemplate;

自动注入了StringRedisTemplate;k:v都是String

  1. **key: value**
  2. **底层只要我们使用RedisTemplate,StringRedisTemplate就可以操作redis**

2,RedisTemplate与Lettuce
  1. @Test
  2. void testRedis(){
  3. ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();
  4. String hello = operations.get("hello");
  5. System.out.println(hello);
  6. }

3,切换至jedis
  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-data-redis</artifactId>
  4. </dependency>
  5. <!-- 导入jedis-->
  6. <dependency>
  7. <groupId>redis.clients</groupId>
  8. <artifactId>jedis</artifactId>
  9. </dependency>

配置redis and 声明 jedis

  1. spring:
  2. redis:
  3. url: redis://localhost:6379 #本地redis连接
  4. client-type: jedis #声明jedis

设置监听器 所有路径访问 默认 key为访问路径 每访问一次 就 value+1

  1. @Autowired
  2. StringRedisTemplate redisTemplate;
  3. String uri = request.getRequestURI();
  4. //默认每次访问当前uri就会计数+1
  5. redisTemplate.opsForValue().increment(uri);

获取redis 数据库中的数据 放入 域中

  1. ValueOperations<String, String> operations = redisTemplate.opsForValue();
  2. String mains = operations.get("/main.html");
  3. model.addAttribute("mains",mains);

7,单元测试

1,JUnit5的变化

SpringBoot2.2.0版本开始引入JUnit5 作为单元测试默认库

作为最新版本的JUnit框架,JUnit5与之前版本的Junit框架有很大的不同.由三个不同子项目的几个不同模块组成.

  1. JUnit5 = JUnit Platform + JUnit Jupiter + JUnit Vintage

JUnit Platform: JUnit Platform是在JVM上启动测试框架的基础,不仅支持JUnit自制的测试引擎,其他测试引擎也都可以接入.

Junit Jupiter : Junit Jupiter提供了JUnit5的新的编程模型,是Junit5新特性核心.包含了一个测试引擎,用于在Junit Platform上运行.

JUnit Vintage : 由于JUnit已经发展多年,为了照顾老的项目,JUnit Vintage提供了兼容Junit4.x,Junit3.x的测试引擎.

注意:

SpringBoot 2.4 以上版本移除了默认对 Vintage 的依赖.如果需要兼容junit4需要自行引入

  1. <!-- 单元测试-->
  2. <dependency>
  3. <groupId>org.springframework.boot</groupId>
  4. <artifactId>spring-boot-starter-test</artifactId>
  5. <scope>test</scope>
  6. </dependency>

现在版本:

  1. @Slf4j
  2. @SpringBootTest
  3. class Boot05WebAdminApplicationTests {
  4. @Test
  5. void testRedis(){
  6. }
  7. }

以前:

@SpringBootTest + @RunWith(SpringTest.class)

SpringBoot真个Junit以后

  1. 编写测试方法 : @Test标注 (注意需要使用junit5版本的注解)
  2. Junit类具有Spring的功能,@Autowired,比如 [@Transactional ](/Transactional ) 标注方法 测试完成后 会自动回滚

2,JUnit5常用注解

JUnit5的注解与JUnit4的注解有所变化

  1. @Test: 表示方法是测试方法,但是与JUnit4@Test不同,他的责任非常单一不能声明任何属性, 拓展的测 试将会由Jupiter提供额外测试
  2. @**ParameterizedTest**:表示方法是参数化测试,下面会有详细介绍
  3. @**RepeatedTest**:表示方法可以重复执行,下方会有详细介绍
  4. @**DisplayName**:为测试类或者测试方法设置展示名称
  5. @**BeforeEach**:表示在每个单元测试执行之前执行
  6. @**AfterEach**:表示在每个单元测试执行之后执行
  7. @**BeforeAll**:表示在所有单元测试执行之前执行
  8. @**AfterAll**:表示在所有单元测试之后执行
  9. @**Tag**:表示单元测试类别,类似与JUnit4中的[@lgnore ](/lgnore )
  10. @**Disabled** : 禁用当前测试方法
  11. @**Timeout**:表示测试方法运行如果超过了指定时间将会返回错误
  12. @**ExtendWith**:为测试类或者测试方法提供扩展类引用

3,断言(assertions)

断言(assertions)是测试方法中的核心部分,用来对测试需要满足的条件进行验证.这些断言方法都是org.juniter.api.Assertions的静态方法. JUnit 5 内置的断言可以分成如下几个类型:

检查业务逻辑返回的数据是否合理.

所有的测试运行结束以后,会有一个详细的测试报告;

1,简单断言

用来对单个值进行简单的验证.如:

方法 说明
assertEquals 判断两个对象或者两个原始类型是否相等
assertNotEquals 判断两个对象或者两个原始类型是否不相等
assertSame 判断两个对象引用是否指向同一个对象
assertNotSame 判断两个对象引用是否指向不同的对象
assertTrue 判断给定的布尔值是否为true
assertFalse 判断给定的布尔值是否为false
assertNull 判断给定的对象引用是否为null
assertNotNull 判断给定的对象引用是否不为null

2,数组断言

通过assertArrayEquals 方法来判断两个对象或原始类型的数组是否相等

  1. @Test
  2. @DisplayName("array assertion")
  3. void TestArrayAssertArrayEquals(){
  4. Assertions.assertArrayEquals(new int[]{1,2},new int[]{1,2},"数组内容不相等");
  5. }

3,组合断言

assertAll 方法接受多个 org.junit.jupiter.api.Executable 函数式接口的实例作为要验证的断言,可以通过lambda表达式很容易的提供这些断言

  1. @Test
  2. @DisplayName("array all 组合断言")
  3. void TestAll(){
  4. /**
  5. * 所有断言全部需要成功
  6. * 可以使用函数写法
  7. */
  8. Assertions.assertAll("test",
  9. ()-> Assertions.assertTrue(true && true,"结果不为true"),
  10. ()->Assertions.assertEquals(1,1,"结果不是预期"));
  11. }

4,异常断言

在JUnit4时期,想要测试方法的异常情况时,需要用@Rule注解的ExpectedException变量还是比较麻烦的.而JUnit5提供了一种新的断言方式Assertions.assertThrows(),配合函数式编程就可以进行使用.

  1. @Test
  2. @DisplayName("异常断言")
  3. void testExceptionAssert(){
  4. //断定业务逻辑一定会出现异常
  5. Assertions.assertThrows(ArithmeticException.class,
  6. ()->{int i=10/0;},
  7. "业务逻辑数据运算居然正常运行");
  8. }

5,超时断言

Junit5还提供了Assertions.asserTimeout()为测试方法设置了超时时间

  1. @Test
  2. @DisplayName("超时断言")
  3. void timeoutTest(){
  4. //如果测试方法时间超过1s将会异常
  5. Assertions.assertTimeout(Duration.ofMillis(1000),
  6. () -> Thread.sleep(500),"业务方法超时");
  7. }

6,快速失败

通过 fail 方法直接使得测试失败

  1. @Test
  2. @DisplayName("快速失败断言")
  3. void shouldFail(){
  4. //判断业务逻辑一定出现异常
  5. if (2 == 2){
  6. Assertions.fail("This should fail");
  7. }
  8. }

4,前置条件(assumptions)

JUnit5的前置条件 (assumptions [假设]) 类似于断言,不同之处在于不满足的断言会使得测试方法失败,而不满足的前置条件只会使得测试方法的执行终止.前置条件可以看成是测试方法执行的前提,当该前提不满足是,就没有据需执行的必要.

  1. /**
  2. * 测试前置条件
  3. */
  4. @Test
  5. @DisplayName("测试前置条件")
  6. void testAssumptions(){
  7. Assertions.assertTrue(false,"结果不是true");
  8. System.out.println(111);
  9. }

assumeTrue 和 assumFalse 确保给定的条件为 true 或 false , 不满足条件会使得测试执行终止. assumingThat的参数是表示条件的布尔值和对应的Executable接口的实现对象.只有条件满足时,Executable对象才会被执行;当条件不满足时,测试执行并不会终止.

5,嵌套测试

JUnit5可以通过java中的内部类和@Nested注解实现嵌套测试,从而可以更好的把相关的测试方法组织在一起.在内部类中可以使用@BeforeEach和@AfterEach注解,而且嵌套的层次没有限制.

  1. @DisplayName("嵌套测试")
  2. public class TestingAStackDemo {
  3. Stack<Object> stack;
  4. @Test
  5. @DisplayName("new Stack()")
  6. void isInstantiatedWithNew() {
  7. new Stack<>();
  8. //在嵌套测试情况下,外层的Test不能驱动内层的Before(After)Each/All之类的方法提前/之后运行
  9. // Assertions.assertNotNull(stack);
  10. Assertions.assertNull(stack);
  11. }
  12. @Nested
  13. @DisplayName("when new")
  14. class WhenNew {
  15. @BeforeEach
  16. void createNewStack() {
  17. stack = new Stack<>();
  18. }
  19. @Test
  20. @DisplayName("is empty")
  21. void isEmpty() {
  22. //判断元素是空的
  23. Assertions.assertTrue(stack.isEmpty());
  24. }
  25. @Test
  26. @DisplayName("throws EmptyStackException when popped")
  27. void throwsExceptionWhenPopped() {
  28. Assertions.assertThrows(EmptyStackException.class, stack::pop);
  29. }
  30. @Test
  31. @DisplayName("throws EmptyStackException when peeked")
  32. void throwsExceptionWhenPeeked() {
  33. Assertions.assertThrows(EmptyStackException.class, stack::peek);
  34. }
  35. @Nested
  36. @DisplayName("after pushing an element")
  37. class AfterPushing {
  38. String anElement = "an element";
  39. @BeforeEach
  40. void pushAnElement() {
  41. stack.push(anElement);
  42. }
  43. /**
  44. * 内层的Test可以驱动外层的Before(After)Each/All之类的方法提前/之后运行
  45. */
  46. @Test
  47. @DisplayName("it is no longer empty")
  48. void isNotEmpty() {
  49. Assertions.assertFalse(stack.isEmpty());
  50. }
  51. @Test
  52. @DisplayName("returns the element when popped and is empty")
  53. void returnElementWhenPopped() {
  54. Assertions.assertEquals(anElement, stack.pop());
  55. Assertions.assertTrue(stack.isEmpty());
  56. }
  57. @Test
  58. @DisplayName("returns the element when peeked but remains not empty")
  59. void returnElementWhenPeeked() {
  60. Assertions.assertEquals(anElement, stack.peek());
  61. Assertions.assertFalse(stack.isEmpty());
  62. }
  63. }
  64. }
  65. }

6,参数化测试

参数化测试是JUnit5很重要的一个新特性,他使得用不同的参数多次运行测试成为了可能,也为我们的单元测试带来许多便利.

利用@ValueSource等注解,指定入参,我们将可以使用不同的参数进行多次单元测试,而不需要每新增一个参数就新增一个单元测试,省去了很多冗余代码.

@ValueSource: 为参数化测试指定入参来源,支持八大基础类以及String类型.Class类型

@NullSource: 表示参数化测试提供一个null的入参

@EnumSource: 表示为参数化测试提供一个枚举入参

@CsvFileSource: 表示读取指定CSV文件内容作为参数化测试入参

@MethodSource: 表示读取指定方法的返回值作为参数化测试入参(注意方法返回值需要是一个流)

当然如果参数化测试仅仅只能做到指定普通的入参还达不到让我觉得惊艳的地步. 让我真正感到他的强大之处的地方在于他可以支持外部的各类入参. 如:CSV,YML,JSON 文件甚至方法的返回值也可以作为入参.只需要去实现 ArgumentsProvuder接口, 任何外部文件都可以作为它的入参.

@ValueSource(ints = {1,2,3,4,5})

  1. @DisplayName("参数化测试")
  2. //声明这不是一个普通的测试 而是一个参数化测试
  3. @org.junit.jupiter.params.ParameterizedTest
  4. //这是个什么类型 valueSource 普通类型都有
  5. @ValueSource(ints = {1,2,3,4,5})
  6. void ParameterizedTest1(int i){
  7. System.out.println(i);
  8. }

@MethodSource(“要获取的方法名”)

  1. @DisplayName("参数化测试")
  2. //声明这不是一个普通的测试 而是一个参数化测试
  3. @org.junit.jupiter.params.ParameterizedTest
  4. //获取方法流中的 字符串 参数
  5. @MethodSource("stringProvider")
  6. void ParameterizedTest2(String i){
  7. System.out.println(i);
  8. }
  9. static Stream<String> stringProvider(){
  10. return Stream.of("apple","banana","atguigu");
  11. }

8,指标监控

1,SpringBoot Actuator

1,简介

未来每一个微服务在云上部署以后,我们都需要对其进行监控,追踪,审计,控制等. SpringBoot就抽取了Actuator场景,使得我们每个微服务快速引用即可获取生产级别的应用监控,审计功能.

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-actuator</artifactId>
  4. </dependency>

2,1.x与2.x的不同

3,如何使用
  1. 引入场景
  2. 访问http://localhost:8080/actuator/**
  3. 暴露所有监控信息为HTTP
  1. management:
  2. endpoints:
  3. enabled-by-default: true #默认开始所有监控端点 暴露所有端点信息
  4. web:
  5. exposure:
  6. include: '*' #以web方式暴露所有端点
  1. 测试
  2. [http://localhost:20010/actuator/beans](http://localhost:20010/actuator/beans)
  3. [http://localhost:20010/actuator/configprops](http://localhost:20010/actuator/configprops)
  4. [http://localhost:20010/actuator/metrics](http://localhost:20010/actuator/metrics)
  5. [http://localhost:20010/actuator/mertrics/jvm.gc.pause](http://localhost:20010/actuator/mertrics/jvm.gc.pause)
  6. .......

4,可视化
  1. [http://github.com/codecentric/spring-boot-admin](http://github.com/codecentric/spring-boot-admin)

2,Actuator Endpoint

1,最常用的端点

ID 描述
auditevents 公开当前应用程序的审计事件信息。需要一个AuditEventRepository
豆子。
beans 显示应用程序中所有 Spring bean 的完整列表。
caches 公开可用的缓存。
conditions 显示在配置和自动配置类上评估的条件以及它们匹配或不匹配的原因。
configprops 显示所有@ConfigurationProperties
.
env 公开 Spring 的ConfigurableEnvironment
.
flyway 显示已应用的任何 Flyway 数据库迁移。需要一个或多个Flyway
豆子。
health 显示应用程序运行状况信息。
httptrace 显示 HTTP 跟踪信息(默认情况下,最近 100 个 HTTP 请求-响应交换)。需要一个HttpTraceRepository
豆子。
info 显示任意应用程序信息。
integrationgraph 显示 Spring 集成图。需要依赖spring-integration-core
.
loggers 显示和修改应用程序中记录器的配置。
liquibase 显示已应用的任何 Liquibase 数据库迁移。需要一个或多个Liquibase
豆子。
metrics 显示当前应用程序的“指标”信息。
mappings 显示所有@RequestMapping
路径的整理列表。
quartz 显示有关 Quartz 调度程序作业的信息。
scheduledtasks 显示应用程序中的计划任务。
sessions 允许从 Spring Session 支持的会话存储中检索和删除用户会话。需要使用 Spring Session 的基于 servlet 的 Web 应用程序。
shutdown 让应用程序正常关闭。默认禁用。
startup 显示由. _
ApplicationStartup
需要SpringApplication
配置BufferingApplicationStartup
.
threaddump 执行线程转储。

如果您的应用程序是 Web 应用程序(Spring MVC、Spring WebFlux 或 Jersey),您可以使用以下附加端点:

ID 描述
heapdump 返回一个堆转储文件。在 HotSpot JVM 上,HPROF
返回一个 -format 文件。在 OpenJ9 JVM 上,PHD
返回一个 -format 文件。
jolokia 当 Jolokia 在类路径上时,通过 HTTP 公开 JMX bean(不适用于 WebFlux)。需要依赖jolokia-core
.
logfile 返回日志文件的内容(如果已设置logging.file.name
或属性)。logging.file.path
支持使用 HTTPRange
标头检索部分日志文件内容。
prometheus 以 Prometheus 服务器可以抓取的格式公开指标。需要依赖micrometer-registry-prometheus
.

最常用的Endpoint

  1. **Health: 监控状况**
  2. **Metrics: 运行时指标**
  3. **Loggers: 日志记录**

2,Health Endpoint

健康检查点,我们一般用于在云平台,平台会定时的检查应用健康状况,我们就需要Health Endpoint可以为平台返回当前应用的一系列组件健康状况的集合.

重要的几点:

  1. health endpoint返回的结果,应该是一系列健康检查后的一个汇总报告
  2. 很多的健康检查默认已经自动配置好了,比如:数据库,redis
  3. 可以很容易的添加自定义的健康检查机制

对某个端点的具体配置

  1. #management 是所有actuator的配置
  2. #management.endpoint.端点名.xxx: 对某个端点的具体配置
  3. management:
  4. #配置所有端点的默认行为
  5. endpoints:
  6. enabled-by-default: true #默认开始所有监控端点 暴露所有端点信息
  7. web:
  8. exposure:
  9. include: '*' #以web方式暴露所有端点
  10. #配置单个的端点的默认行为
  11. endpoint:
  12. health:
  13. show-details: always #health的详细信息 always 显示health的详细信息

3,Metrics Endpoint

提供详细的,层级的,空间指标信息,这些信息可以被pull(主动推送) 或者push (被动获取) 方式得到;

  1. 通过Metrics对接多种监控系统
  2. 简化核心Metrics开发
  3. 添加自定义Metrics或者拓展已有Metrics

4,管理Endpoints

1,开始与禁用Endpoints

  1. 默认所有的Endpoint除过shutdown都是开启的.
  2. 需要开启或者禁用摸个Endpoint.配置模式为 **management.endpoint..enabled = true**
  1. management:
  2. endpoints:
  3. beans:
  4. enabled: true
  1. 或者禁用所有的Endpoint然后手动开启指定的Endpoint
  1. management:
  2. endpoints:
  3. enabled-by-default: false #暴露所有端点信息
  4. endpoints:
  5. beans:
  6. enabled: true
  7. health:
  8. enabled: true

2,暴露Endpoints

支持的暴露方式

  1. HTTP: 默认只暴露**health**和**info** Endpoint
  2. JMX: 默认暴露所有Endpoint
  3. 除过healthinfo,剩下的Endpoint都应该进行保护访问.如果引入SpringSecurity,则会默认配置安全访问规则
ID JMX Web
auditevents 是的
beans 是的
caches 是的
conditions 是的
configprops 是的
env 是的
flyway 是的
health 是的 是的
heapdump 不适用
httptrace 是的
info 是的
integrationgraph 是的
jolokia 不适用
logfile 不适用
loggers 是的
liquibase 是的
metrics 是的
mappings 是的
prometheus 不适用
quartz 是的
scheduledtasks 是的
sessions 是的
shutdown 是的
startup 是的
threaddump 是的
  1. management:
  2. endpoints:
  3. enabled-by-default: true #默认开始所有监控端点 暴露所有端点信息
  4. web:
  5. exposure:
  6. include: '*' #以web方式暴露所有端点
  1. #management 是所有actuator的配置
  2. #management.endpoint.端点名.xxx: 对某个端点的具体配置
  3. management:
  4. #配置所有端点的默认行为
  5. endpoints:
  6. enabled-by-default: false #默认开始所有监控端点 暴露所有端点信息
  7. web:
  8. exposure:
  9. include: '*' #以web方式暴露所有端点
  10. #配置单个的端点的默认行为
  11. endpoint:
  12. health:
  13. show-details: always #health的详细信息 always 显示health的详细信息
  14. enabled: true
  15. info:
  16. enabled: true
  17. beans:
  18. enabled: true
  19. metrics:
  20. enabled: true

3,定制 Endpoint

1,定制Health信息

实现 implements(继承) HealthIndicator 或者 继承抽象类 AbstractHealthIndicator

类名必须是 XXXHealthIndicator

  1. @Component //XXXHealthIndicator
  2. public class MyComHealthIndicator extends AbstractHealthIndicator {
  3. /**
  4. * 真实的检查方法
  5. * @param builder
  6. * @throws Exception
  7. */
  8. @Override
  9. protected void doHealthCheck(Health.Builder builder) throws Exception {
  10. //mongodb 获取连接进行测试
  11. Map<String,Object> map = new HashMap<>();
  12. if (1 == 1){
  13. // builder.up(); //健康
  14. builder.status(Status.UP);
  15. map.put("count",1);
  16. map.put("ms",100);
  17. }else {
  18. // builder.down(); //不健康
  19. builder.status(Status.OUT_OF_SERVICE);
  20. map.put("err","连接超时");
  21. map.put("ms",3000);
  22. }
  23. builder.withDetail("code",100)
  24. .withDetails(map);
  25. }
  26. }

2,定制info信息

常用两种方式

1,编写配置文件
  1. #设置当前info信息 但是好像使用不了了 可能是版本更新了
  2. #info:
  3. # appName: boot-admin
  4. # appVersion: 1.0.0
  5. # mavenProjectName: @project.artifactId@
  6. # mavenProjectVersion: @project.version@

2,编写InfoContributor info 实现 InfoContributor 接口
  1. @Component
  2. public class AppInfoInfoContributor implements InfoContributor{
  3. @Override
  4. public void contribute(Info.Builder builder) {
  5. builder.withDetail("function","web")
  6. .withDetail("edition","1.0.0");
  7. }
  8. }

http://localhost:8080/actuator/info 会输出以上方式返回所有info信息

3,定制Metrics信息

1,SpringBoot支持自动适配的Metrics
  1. JVM metrics,report utilization of:
  2. Various memory and buffer pools
  3. Statisics related to garbage collection
  4. Threads utilization
  5. Number of classes loaded/unloaded
  6. CPU metrics
  7. File descriptor metrics
  8. Kafka consumer and producer metrics
  1. @Service
  2. public class CityServicImpl implements CityServic {
  3. @Autowired
  4. private CityDao cityDao;
  5. Counter counter;
  6. //写在构造方法里 ****
  7. public CityServicImpl(MeterRegistry meterRegistry){
  8. counter = meterRegistry.counter("cityService.saveCity.count");
  9. }
  10. @Override
  11. public City SelectCityById(long id) {
  12. //每执行一次CityServicImpl counter ++
  13. counter.increment();
  14. City byId = cityDao.getById(id);
  15. return byId;
  16. }
  17. }
  18. //也可以使用下面的方式
  19. @Bean
  20. MeterBinder queueSize(Queue queue){
  21. return (registry) -> Gauge.builder("queueSize",queue::size).register(registry)
  22. }

4,定制Endpoint

放入容器中

@Endpoint(id = “myservice”) 设置这是一个Endpoint 命名为 myservice
@ReadOperation 声明是一个端点的读操作

@WriteOperation 声明是一个端点的写操作

http://localhost:20010/actuator/myservice

  1. @Component
  2. @Endpoint(id = "myservice") //设置这是一个Endpoint
  3. public class MyServiceEndPoint {
  4. //@ReadOperation 声明是一个端点的读操作
  5. @ReadOperation
  6. public Map getDockerInfo(){
  7. return Collections.singletonMap("dockerInfo","docker started.....");
  8. }
  9. //@WriteOperation 声明是一个端点的写操作
  10. @WriteOperation
  11. public void stopDocker(){
  12. System.out.println("docker stopped....");
  13. }
  14. }

09,原理解析

1,Profile功能

为了方便多环境适配,SpringBoot简化了Profile功能

1,application-profile功能

  1. 默认指定配置文件 application.yaml; 任何时候都会加载
  2. 指定环境配置文件 application-{env}.yaml
  3. 激活指定环境
  4. 配置文件激活
  5. 命令行激活: java -jar xxx.jar --spring.profiles.active=prod --person.name=haha
  6. 可以修改配置文件的任意值,命令行优先
  1. @RestController
  2. public class HelloController {
  3. //如果拿不到person.name 那就返回默认值 : 后是默认值
  4. @Value("${person.name:李四}")
  5. private String name;
  6. @GetMapping("/")
  7. public String hello(){
  8. System.out.println(name);
  9. return "Hello" + name;
  10. }
  11. }
  12. //使用那个配置文件 application.yaml 默认配置文件 默认加载
  13. //如果出现同名配置 会以指定激活的配置文件优先
  14. spring.profiles.active=prod //指定激活环境那个配置文件
  15. //prod 环境 application-prod.yaml
  16. person:
  17. name: prod-张三
  18. //test 环境 application-test.yaml
  19. person:
  20. name: test-张三

打成jar包 开启时 可以指定使用那个环境

java -jar boot-09-features-profile-0.0.1-SNAPSHOT.jar —spring.profiles.active=指定环境

2,@Profile条件装配功能

  1. @Profile("test") //放在类上或者方法上 当前环境激活是 指定环境 才会开启使用
  2. @Configuration //也一样里面

3,profile分组

  1. #设置使用那个组
  2. spring.profiles.active=myprod
  3. #定义分组
  4. spring.profiles.group.myprod[0]=ppd
  5. spring.profiles.group.myprod[1]=prod
  6. spring.profiles.group.mytest[0]=test
  7. #同个组里的属性会合在一起

2,外部化配置

1,外部配置源

常用: java属性文件, YAML文件,环境变量,命令行参数;

  1. //从环境变量里取值
  2. @Value("${JAVA_HOME}")
  3. private String msg;
  4. //获取操作系统
  5. @Value("${os.name}")
  6. private String osName;

2,配置文件查找位置

(1)classpath 根路径

(2)classpath 根路径下config目录

(3)jar包当前目录

(4)jar包当前目录的config目录

(5)/config 子目录的直接子目录

3,配置文件加载顺序:

1,当前jar包内部的application.properties和application.yaml

2,当前jar包内部的application-{profile}.properties 和 application-{profile}.yaml

3,引用的外部jar包的application.properties和application.yaml

4,引用的外部jar包的applicat-{profile}.properties 和 application-{profile}.yaml

4,指定环境优先,外部优先,后面的可以覆盖前面的同名配置项

3,自定义Starter

1,starter启动原理

autoconfigure包中配置使用 META-INF/spring.factories 中 EnableAutoConfiguration 的值,使得项目启动加载指定的自动配置类

编写自动配置类 xxxAutoConfiguration -> xxxxProperties

  1. [**@Configuration **](/Configuration )** **
  2. [**@Conditional **](/Conditional )** **
  3. **@EnableConfigurationProperties**
  4. [**@Bean **](/Bean )** **
  5. **....**

引入starter —- xxxAutoConfiguration —-容器中放入组件 —- 绑定xxxProperties —- 配置项

2,自定义starter

HelloProperties

  1. @ConfigurationProperties("xiao.hello")
  2. public class HelloProperties {
  3. private String prefix;
  4. private String suffix;
  5. public String getPrefix() {
  6. return prefix;
  7. }
  8. public void setPrefix(String prefix) {
  9. this.prefix = prefix;
  10. }
  11. public String getSuffix() {
  12. return suffix;
  13. }
  14. public void setSuffix(String suffix) {
  15. this.suffix = suffix;
  16. }
  17. }

——————————>

HelloServiceAutoConfiguration

  1. @Configuration
  2. @EnableConfigurationProperties(HelloProperties.class) //默认HelloProperties放在容器中
  3. public class HelloServiceAutoConfiguration {
  4. @Bean
  5. @ConditionalOnMissingBean(HelloService.class)
  6. public HelloService helloService(){
  7. HelloService helloService = new HelloService();
  8. return helloService;
  9. }
  10. }

——————————>

HelloServce

  1. /**
  2. * 默认不要放在容器中
  3. */
  4. public class HelloService {
  5. @Autowired
  6. HelloProperties helloProperties;
  7. public String sayHello(String userName){
  8. return helloProperties.getPrefix() + ":" + userName + ">" + helloProperties.getSuffix();
  9. }
  10. }

4,SpringBoot原理

Spring原理[Spring注解],SpringMVC原理,自动配置原理,SpringBoot原理

1,SpringBoot启动过程

  • 创建 SpringApplication
    • 保存一些信息。
    • 判定当前应用的类型。ClassUtils。Servlet
    • bootstrappers:初始启动引导器(List):去spring.factories文件中找 org.springframework.boot.Bootstrapper
    • ApplicationContextInitializer;去spring.factories找 ApplicationContextInitializer
      • List> initializers
    • ApplicationListener ;应用监听器。spring.factories找 ApplicationListener
      • List> listeners
  • 运行 SpringApplication
    • StopWatch
    • 记录应用的启动时间
    • 创建引导上下文(Context环境)createBootstrapContext()
      • 获取到所有之前的 bootstrappers 挨个执行 intitialize() 来完成对引导启动器上下文环境设置
    • 让当前应用进入headless模式。java.awt.headless
    • 获取所有 RunListener(运行监听器)【为了方便所有Listener进行事件感知】
      • getSpringFactoriesInstances 去spring.factories找 SpringApplicationRunListener.
    • 遍历 SpringApplicationRunListener 调用 starting 方法;
      • 相当于通知所有感兴趣系统正在启动过程的人,项目正在 starting。
    • 保存命令行参数;ApplicationArguments
    • 准备环境 prepareEnvironment();
      • 返回或者创建基础环境信息对象。StandardServletEnvironment
      • 配置环境信息对象。
        • 读取所有的配置源的配置属性值。
      • 绑定环境信息
      • 监听器调用 listener.environmentPrepared();通知所有的监听器当前环境准备完成
    • 创建IOC容器(createApplicationContext())
      • 根据项目类型(Servlet)创建容器,
      • 当前会创建 AnnotationConfigServletWebServerApplicationContext
    • 准备ApplicationContext IOC容器的基本信息 prepareContext()
      • 保存环境信息
      • IOC容器的后置处理流程。
      • 应用初始化器;applyInitializers;
        • 遍历所有的 ApplicationContextInitializer 。调用 initialize.。来对ioc容器进行初始化扩展功能
        • 遍历所有的 listener 调用 contextPrepared。EventPublishRunListenr;通知所有的监听器contextPrepared
      • 所有的监听器 调用 contextLoaded。通知所有的监听器 contextLoaded;
    • 刷新IOC容器。refreshContext
      • 创建容器中的所有组件(Spring注解)
    • 容器刷新完成后工作?afterRefresh
    • 所有监听 器 调用 listeners.started(context); 通知所有的监听器 started
    • 调用所有runners;callRunners()
      • 获取容器中的 ApplicationRunner
      • 获取容器中的 CommandLineRunner
      • 合并所有runner并且按照@Order进行排序
      • 遍历所有的runner。调用 run 方法
    • 如果以上有异常,
      • 调用Listener 的 failed
    • 调用所有监听器的 running 方法 listeners.running(context); 通知所有的监听器 running
    • running如果有问题。继续通知 failed 。调用所有 Listener 的 failed;通知所有的监听器 failed

2,Application Events and Listeners

https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-application-events-and-listeners

ApplicationContextInitializer

ApplicationListener

SpringApplicationRunListener

3,ApplicationRunner 与 CommandLineRunner

4,响应数据与内容协商

5,视图解析与模板引擎

ok