尚硅谷SpringBoot2核心技术-核心功能(二)

发表于 更新于 分类于 本文字数： 83k 阅读时长 ≈ 2:32

配置文件

文件类型

properties

同以前的properties用法
比如给user下的name赋值

1
user.name=xxx

yaml

简介

YAML是“YAML Ain’t Markup Language”(YAML不是一种标记语言)的递归缩写。
在开发这种语言时，YAML的意思其实是：“Yet Another Markup Language”(仍是一种标记语言)

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

基本语法

  • key: value kv之间有空格
  • 大小写敏感
  • 使用缩进表示层级关系
  • 缩进不允许使用tab，只允许使用空格
  • 缩进的空格数不重要，只要相同层级的元素左对齐即可
  • #表示注释
  • 字符串无需加引号，如果要加，’’与””表示字符串内容会被 转义/不转义

数据类型

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

配置提示

自定义的类和配置文件绑定一般没有提示
不过可以加入一下依赖就会有提示

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

不过这个注解只是在开发的时候使用，打包的时候并没有必要打进去，可以通过一下配置进行排除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<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>

web开发

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**

简单功能分析

静态资源访问

静态资源目录

只要静态资源放在类路径下：/static (or /public or /resources or /META-INF/resources)
访问地址：当前项目根路径/+静态资源名（http://127.0.0.1:8080/123.jpg）

原理：静态映射/**
接收到请求，先查找controller是否能够处理，如果不能处理，就把请求交给静态资源处理器；静态资源处理器也找不到则响应404页面（如果有rest路径和静态资源路径恰好相同，rest路径优先响应）

改变默认的静态资源路径

1
2
3
4
5
6
7
8
spring:  
  mvc:  # 修改静态资源访问前缀，默认没有前缀，现在的设置 /res/123.jpg
    static-path-pattern: /res/**  
  resources:  # 静态资源文件存放目录，已经废弃
    static-locations: classpath:/ss/  
  web:  
    resources:  # 静态资源文件存放目录，推荐使用
      static-locations: classpath:/public/

静态资源访问前缀

默认无前缀，下面配置需要访问（http://127.0.0.1:8080/res/123.jpg）

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

webjar

把静态资源以jar包的形式引入
自动映射 /webjar/** 文件夹
WebJars - Web Libraries in Jars

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

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

欢迎页支持

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

自定义Favicon

favicon.ico放在静态资源目录下即可自动访问
spring.mvc.static-path-pattern 配置同样会导致该功能失效

静态资源配置原理

  • springboot启动默认加载 xxxAutoConfiguration类（自动配置类）

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    @AutoConfiguration(after = { DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,  
           ValidationAutoConfiguration.class })  
           //是一个servlet项目
    @ConditionalOnWebApplication(type = Type.SERVLET)  
    //项目中包含这三个类
    @ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })  
    //项目中不存在这个bean
    @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)  
    @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)  
    public class WebMvcAutoConfiguration {}

  • 给容器中配了什么

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

  • 配置文件的相关属性和xxx进行了绑定

    • WebMvcProperties == spring.mvc
    • WebProperties == spring.web

配置类只有一个有参构造器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//在只有一个构造器的情况下，创建这个bean会从容器中获取构造器中的所有参数
//WebProperties webProperties 获取和 spring.web绑定的所有的值的对象
//WebMvcProperties mvcProperties 获取和 spring.mvc绑定的所有的值的对象
//ListableBeanFactory beanFactory spring的beanFactory
//HttpMessageConverters 找到所有的 HttpMessageConverters
//ResourceHandlerRegistrationCustomizer 找到资源处理器
//DispatcherServletPath
//ServletRegistrationBean 给应用注册 servlet、filter....
public WebMvcAutoConfigurationAdapter(WebProperties webProperties, WebMvcProperties mvcProperties,  
       ListableBeanFactory beanFactory, ObjectProvider<HttpMessageConverters> messageConvertersProvider,  
       ObjectProvider<ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider,  
       ObjectProvider<DispatcherServletPath> dispatcherServletPath,  
       ObjectProvider<ServletRegistrationBean<?>> servletRegistrations) {  
    this.resourceProperties = webProperties.getResources();  
    this.mvcProperties = mvcProperties;  
    this.beanFactory = beanFactory;  
    this.messageConvertersProvider = messageConvertersProvider;  
    this.resourceHandlerRegistrationCustomizer = resourceHandlerRegistrationCustomizerProvider.getIfAvailable();  
    this.dispatcherServletPath = dispatcherServletPath;  
    this.servletRegistrations = servletRegistrations;  
    this.mvcProperties.checkConfiguration();  
}

资源处理的默认规则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Override  
public void addResourceHandlers(ResourceHandlerRegistry registry) {  
//spring.web.resources.add-mappings=false 配置可以禁用静态文件
    if (!this.resourceProperties.isAddMappings()) {  
       logger.debug("Default resource handling disabled");  
       return;    }  
       //webjars的规则，所以webjars的包只要进入后按固定规则就可以使用
    addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");  
    //自定义的规则，如果没有自定义，则会使用默认的规则
    addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (registration) -> {  
       registration.addResourceLocations(this.resourceProperties.getStaticLocations());  
       if (this.servletContext != null) {  
          ServletContextResource resource = new ServletContextResource(this.servletContext, SERVLET_LOCATION);  
          registration.addResourceLocations(resource);  
       }  
    });  
}
1
2
3
4
5
6
public static class Resources {  
  //spring.mvc.static-path-pattern 配置默认值，静态资源默认位置
    private static final String[] CLASSPATH_RESOURCE_LOCATIONS = { "classpath:/META-INF/resources/",  
          "classpath:/resources/", "classpath:/static/", "classpath:/public/" };  
	private String[] staticLocations = CLASSPATH_RESOURCE_LOCATIONS;
}

欢迎的处理规则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Bean  
public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext,  
       FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {  
    return createWelcomePageHandlerMapping(applicationContext, mvcConversionService, mvcResourceUrlProvider,  
          WelcomePageHandlerMapping::new);  
}  
  
private <T extends AbstractUrlHandlerMapping> T createWelcomePageHandlerMapping(  
       ApplicationContext applicationContext, FormattingConversionService mvcConversionService,  
       ResourceUrlProvider mvcResourceUrlProvider, WelcomePageHandlerMappingFactory<T> factory) {  
    TemplateAvailabilityProviders templateAvailabilityProviders = new TemplateAvailabilityProviders(  
          applicationContext);  
    String staticPathPattern = this.mvcProperties.getStaticPathPattern();  
    T handlerMapping = factory.create(templateAvailabilityProviders, applicationContext, getIndexHtmlResource(),  
          staticPathPattern);  
    handlerMapping.setInterceptors(getInterceptors(mvcConversionService, mvcResourceUrlProvider));  
    handlerMapping.setCorsConfigurations(getCorsConfigurations());  
    return handlerMapping;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
WelcomePageHandlerMapping(TemplateAvailabilityProviders templateAvailabilityProviders,  
       ApplicationContext applicationContext, Resource indexHtmlResource, String staticPathPattern) {  
    setOrder(2);  
    WelcomePage welcomePage = WelcomePage.resolve(templateAvailabilityProviders, applicationContext,  
          indexHtmlResource, staticPathPattern);  
    if (welcomePage != WelcomePage.UNRESOLVED) {  
       logger.info(LogMessage.of(() -> (!welcomePage.isTemplated()) ? "Adding welcome page: " + indexHtmlResource  
             : "Adding welcome page template: index"));  
       ParameterizableViewController controller = new ParameterizableViewController();  
       controller.setViewName(welcomePage.getViewName());  
       setRootHandler(controller);  
    }  
}
1
2
3
4
5
6
7
8
9
10
static WelcomePage resolve(TemplateAvailabilityProviders templateAvailabilityProviders,  
       ApplicationContext applicationContext, Resource indexHtmlResource, String staticPathPattern) {  
    if (indexHtmlResource != null && "/**".equals(staticPathPattern)) {  
       return new WelcomePage("forward:index.html", false);  
    }  
    if (templateAvailabilityProviders.getProvider("index", applicationContext) != null) {  
       return new WelcomePage("index", true);  
    }  
    return UNRESOLVED;  
}

从上面的代码可以看到，欢迎页的最终是在底层写死了 /** ，所以当我们自定义前缀后，无法匹配也就会导致欢迎页失效。

favicon

favicon.ioc是浏览器进行处理的，默认会去根目录下寻找，如果加入了前缀，就会导致图标不在根目录下，也就会找不到。

请求参数处理

请求映射

rest使用与原理

  • xxxMapping
  • rest风格支持，使用HTTP请求方式动词来表示对资源的操作
    • 以前：/getUser 获取用户 /deleteUser 删除用户 /editUser修改用户 /saveUser 保存用户
    • 现在：/user GET-获取用户 DELETE-删除用户 PUT-修改用户 POST-保存用户
    • 核心Filter，HiddenHttpMethodFilter （仅限于表单请求，表单只能发送post和get请求，可以使用这个Filter实现delete和put请求，现在一般都是前后端分离，可以直接发送对应的请求）
      • 用法：表单的meehod=post，隐藏域_method=put
        1
        2
        3
        4
        <form method="post">  
            <input name="_method" value="delete" type="hidden">  
            <input type="button" value="发送delete请求">  
        </form>
      • SpringBoot中手动开启
        1
        2
        3
        4
        5
        spring:  
          mvc:  
            hidden-method:  
              filter:  
                enabled: true
    • 扩展：如何把_method定义成自己喜欢的名字
      1
      2
      3
      4
      5
      6
      @Bean  
      public HiddenHttpMethodFilter hiddenHttpMethodFilter(){  
          HiddenHttpMethodFilter methodFilter = new HiddenHttpMethodFilter();  
          methodFilter.setMethodParam("_m");  
          return methodFilter;  
      }
      只需要定义一个Bean即可，spring默认的Filter上面标记了@ConditionalOnMissingBean(HiddenHttpMethodFilter.class)注解，当我们自定义了这个类型的Bean之后，springboot默认的就不会生效。

rest原理：

  • 表单提交会带上_method=PUT
  • 请求过来被HiddenHttpMethodFilter拦截
    • 请求是否正常，并且是POST请求
      • 获取到_method的值
      • 兼容一下请求：PUT, DELETE, PATCH
      • 原生request（post），包装模式requestWrapper重写了getMethod方法，返回的是传入的值
      • 过滤器链放行的时候用requestWrapper，以后调用getMethod方法调用的是requestWrapper的

rest使用客户端工具：

  • 如PostMan直接发送PUT、DELETE等方式请求，无需Filter

请求映射原理

DispatcherServlet继承图示

DispatcherServlet方法调用图示
分析DispatcherServlet直接看doDispatch方法即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {  
    HttpServletRequest processedRequest = request;  
    HandlerExecutionChain mappedHandler = null;  
    boolean multipartRequestParsed = false;  
  
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);  
  
    try {  
       ModelAndView mv = null;  
       Exception dispatchException = null;  
  
       try {  
          processedRequest = checkMultipart(request);  
          multipartRequestParsed = (processedRequest != request);  
  
          // 找到当前请求使用那个Handler（Controller的方法）处理
          mappedHandler = getHandler(processedRequest);  
          if (mappedHandler == null) {  
             noHandlerFound(processedRequest, response);  
             return;          
             }
             //HandlerMapping：处理器映射。/xxx --> xxx
             ....
    }

springboot默认创建了6个HandlerMapping，其中RequestMappingHandlerMapping用来处理我们平时定义在Controller中的请求，保存了所有@RequestMapping和Handler的映射规则
HandlerMapping图示

所有的请求映射都在HandlerMapping中

  • SpringBoot自动配置欢迎页的 WelcomePageHandlerMapping，访问/能访问到index.html
  • SpringBoot自动配置了默认的RequestMappingHandlerMapping
  • 请求进来，挨个尝试所有的HandlerMapping看是否能处理请求信息
    • 如果有就找到这个请求对应的handler
    • 如果没有就下一个HandlerMapping
  • 我们如果需要自定义的映射处理，也可以自己给容器中放HandlerMapping
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {  
        if (this.handlerMappings != null) {  
           for (HandlerMapping mapping : this.handlerMappings) {  
              HandlerExecutionChain handler = mapping.getHandler(request);  
              if (handler != null) {  
                 return handler;  
              }  
           }  
        }  
        return null;  
    }

普通参数与基本注解

注解

@PathVariable
  • 从请求路径中变量的值
  • 可以使用变量名称一个一个获取
  • 也可以使用Map<String,String>方式获取所有的值，key和value只能是String
    1
    2
    3
    4
    @GetMapping("/test/{id}/t1/{name}")  
    public Map<String,Object> test(@PathVariable("id") Integer id,  
                                   @PathVariable("name") String name,  
                                   @PathVariable Map<String,String> pv){ ... }
@RequestHeader
  • 获取请求头中的信息
  • 可以通过名称获取请求头中单个参数的信息
  • 可以使用Map<String, String>获取所有请求头中的信息
  • 可以使用MultiValueMap<String, String>（多值map）获取所有请求头中的信息
  • 可以使用HttpHeaders获取请求中的信息
    1
    2
    3
    4
    5
    @GetMapping("/test")  
    public Map<String, Object> test(@RequestHeader("User-Agent") String userAgent,  
                                    @RequestHeader Map<String, String> pv,  
                                    @RequestHeader MultiValueMap<String, String> mpv,  
                                    @RequestHeader HttpHeaders httpHeaders) { ... }
@RequestParam
  • /test?id=1&name=liming&hobby=篮球&hobby=足球
  • 从请求中获取参数
  • 可以通过名称获取单个参数
  • 如果有多个名称相同的参数，可以使用集合接收参数
  • 可以使用Map<String, String>获取所有参数，不过多个相同名称的参数只会保留第一个
  • 可以使用MultiValueMap<String, String>获取参数，同名参数会存放到集合中
    1
    2
    3
    4
    5
    6
    7
    @GetMapping("/test")  
    public Map<String, Object> test(@RequestParam("id") Integer id,  
                                    @RequestParam("name") String name,  
                                    @RequestParam("hobby")List<String> hobby,  
                                    @RequestParam Map<String,String> pv,  
                                    @RequestParam MultiValueMap<String,String> mpv  
                                    ) { ... }
@CookieValue
  • 获取cookie中的值
  • 可以通过cookie中的key获取Cookie中某个key的值
  • 可以通过key获取Cookie中的Cookie对象
    1
    2
    3
    @GetMapping("/test")  
    public Map<String, Object> test(@CookieValue("cookie1") String cookie1,  
                                    @CookieValue("cookie2")Cookie cookie2 ) { ... }
@RequestBody
  • 从请求中获取参数（因为只有post和put请求才有请求体，所以只有在这两种请求类型中使用）
  • 把json串映射成
    1
    2
    @PostMapping("/test")  
    public Map<String, Object> test(@RequestBody Map<String,String> content ) { ... }
@RequestAttribute
  • 从请求域中获取参数
  • forward关键字转发，将一个请求转发到某个路径，两个请求公用的一个请求信息，所以可以从请求域中携带数据
  • 可以使用注解获取，也可以直接使用request方法获取
  • 一般用户前后端不分离的项目传值使用
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    @Controller  
    public class RequestController {  
        @GetMapping("/goto")  
        public String gotoPage(HttpServletRequest request){  
            request.setAttribute("name","小明");  
            return "forward:/success";  
        }  
        @ResponseBody  
        @GetMapping("/success")  
        public Map<String,Object> index(@RequestAttribute("name") String name){  
            Map<String,Object> map = new HashMap<>();  
            map.put("name",name);  
            return map;  
        }  
    }
@MatrixVariable
  • 矩阵变量，需要绑定到路径变量中
  • 语法：/cars/sell;low=34;brand=byd,audi,yd
    1
    2
    3
    4
    5
    //  /cars/sell;low=34;brand=byd,audi,yd  
        @GetMapping("/cars/{path}")  
        public Map<String, Object> cars(@MatrixVariable("low") Integer low,  
                                        @MatrixVariable("brand") List<String> brand,  
                                        @PathVariable("path") String path) {...}
  • 矩阵变量是绑定在路径变量中的，路径变量可以设置多个，如果多个路径变量中有名称相同的矩阵变量，可以设置参数根据路径变量的名称获取矩阵变量，如果不设置，直接以矩阵变量名称获取，默认会获取到第一个
    1
    2
    3
    4
    // boss/1;age=12/2;age=34  
     @GetMapping("/boss/{bossId}/{empId}")  
    public Map<String, Object> boss(@MatrixVariable(value = "age",pathVar = "bossId") Integer bossAge,  
                                        @MatrixVariable(value = "age",pathVar = "empId")  Integer empAge) { ... }
  • springboot默认禁用矩阵变量，需要手动配置开启
    • 路径处理是通过UrlPathHelper进行处理的
    • 其中有一个变量removeSemicolonContent（是否移除分号），该变量默认为true需要修改成false
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      //自定义WebMvcConfigurer，替换springboot的默认定义
      //也可以继承WebMvcConfigurer接口，实现其中的方法进行处理
      @Bean  
      public WebMvcConfigurer webMvcConfigurer(){  
          return new WebMvcConfigurer(){  
              @Override  
              public void configurePathMatch(PathMatchConfigurer configurer) {  
                  UrlPathHelper urlPathHelper = new UrlPathHelper();  
                  urlPathHelper.setRemoveSemicolonContent(false);  
                  configurer.setUrlPathHelper(urlPathHelper);  
              }  
          };  
      }

Servlet API

WebRequest、ServletRequest、MultipartRequest、 HttpSession、javax.servlet.http.PushBuilder、Principal、InputStream、Reader、HttpMethod、Locale、TimeZone、ZoneId

ServletRequestMethodArgumentResolver 以上的部分参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Override  
public boolean supportsParameter(MethodParameter parameter) {  
    Class<?> paramType = parameter.getParameterType();  
    return (WebRequest.class.isAssignableFrom(paramType) ||  
          ServletRequest.class.isAssignableFrom(paramType) ||  
          MultipartRequest.class.isAssignableFrom(paramType) ||  
          HttpSession.class.isAssignableFrom(paramType) ||  
          (pushBuilder != null && pushBuilder.isAssignableFrom(paramType)) ||  
          (Principal.class.isAssignableFrom(paramType) && !parameter.hasParameterAnnotations()) ||  
          InputStream.class.isAssignableFrom(paramType) ||  
          Reader.class.isAssignableFrom(paramType) ||  
          HttpMethod.class == paramType ||  
          Locale.class == paramType ||  
          TimeZone.class == paramType ||  
          ZoneId.class == paramType);  
}

复杂参数

Map、Model（map、model里面的数据会被放在request的请求域 request.setAttribute）、Errors/BindingResult、RedirectAttributes（ 重定向携带数据）、ServletResponse（response）、SessionStatus、UriComponentsBuilder、ServletUriComponentsBuilder

Map<String,Object> map、Model model HttpServletRequest request都可以给request域中放数据

示例代码如下，向Map、Model和request中分别放入参数，然后转发到另外一个接口，尝试能不能从request作用域中取出参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@GetMapping("/params")  
public String params(Map<String,Object> map,  
                     Model model,  
                     HttpServletRequest request,  
                     HttpServletResponse response){  
    map.put("hello","world6666");  
    model.addAttribute("world","hello666");  
    request.setAttribute("message","hello world");  
    Cookie cookie = new Cookie("c1","v1");  
    response.addCookie(cookie);  
    return "forward:/success";  
}  
@ResponseBody  
@GetMapping("/success")  
public Map<String,Object> index(HttpServletRequest request){  
    Object hello = request.getAttribute("hello");  
    Object world = request.getAttribute("world");  
    Object message = request.getAttribute("message");  
  
    Map<String,Object> map = new HashMap<>();  
    map.put("hello",hello);  
    map.put("world",world);  
    map.put("message",message);  
    return map;  
}
  • Map、Model类型的参数，会返回mavContainer.getModel();两种类型的参数，返回的是同一个对象，对象类型是BindingAwareModelMap，这个类既是Map又是Model(同时继承了Model和Map接口并做了相应实现)
    • org.springframework.web.method.support.ModelAndViewContainer#getModel

第一个参数是Map参数，第二个是Model参数，他们获取到的是同一个对象
Map&Model对象图示
可以看到Map和Model中存放的参数最终都会到同一个对象中
Map&Model参数示意图

自定义对象参数

可以自动类型转换与格式化，可以级联封装。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 *     姓名： <input name="userName"/> <br/>
 *     年龄： <input name="age"/> <br/>
 *     生日： <input name="birth"/> <br/>
 *     宠物姓名：<input name="pet.name"/><br/>
 *     宠物年龄：<input name="pet.age"/>
 */
@Data
public class Person {
    private String userName;
    private Integer age;
    private Date birth;
    private Pet pet;
}
@Data
public class Pet {
    private String name;
    private String age;
}

POJO封装过程

ServletModelAttributeMethodProcessor
只是单体项目表单传参，前后端分离项目传的是json数据使用的是 RequestResponseBodyMethodProcessor

参数处理原理

  • HandlerMapping中找到能处理请求的Handler（Controller.method()那个类的那个方法）
  • 为当前Handler找到一个适配器HandlerAdapter；RequestMappingHandlerAdapter
  • 适配器执行目标方法并确定方法参数的每一个值

HandlerAdapter

HandlerAdapter图示
0- 支持方法上标注了@RequestMapping注解的
1- 支持函数式编程
…..

执行目标方法

1
2
3
//org.springframework.web.servlet.DispatcherServlet#doDispatch
// Actually invoke the handler.  
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
1
2
3
4
5
6
7
8
9
10
11
//org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#handleInternal
// 执行目标方法
mav = invokeHandlerMethod(request, response, handlerMethod);

//org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod#invokeAndHandle
//真正执行目标方法
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);

//org.springframework.web.method.support.InvocableHandlerMethod#invokeForRequest
//获取方法参数值，然后就会反射调用方法执行
Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);

参数解析器-HandlerMethodArgumentResolver

  • 确定要执行的木变更方法的每一个参数的值是什么；
  • springboot目标方法能够写多少中参数类型，取决于参数解析器（目前springboot一共有27种解析器）
    参数解析器图示

HandlerMethodArgumentResolver接口图示

  • 所有参数解析器的父接口
  • 先调用supportsParameter方法判断当前解析器能不能解析该参数
  • 如果能够解析，就调用resolveArgument方法进行解析

返回值处理器

  • springboot能够返回多少中返回值类型，也取决于返回值处理器
    返回值处理器图示

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//org.springframework.web.method.support.InvocableHandlerMethod#getMethodArgumentValues
protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,  
       Object... providedArgs) throws Exception {  
  //获取所有方法参数的声明
    MethodParameter[] parameters = getMethodParameters();  
    if (ObjectUtils.isEmpty(parameters)) {  
       return EMPTY_ARGS;  
    }  
  //声明参数值的存储数组
    Object[] args = new Object[parameters.length];  
    for (int i = 0; i < parameters.length; i++) {  
       MethodParameter parameter = parameters[i];  
       parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);  
       args[i] = findProvidedArgument(parameter, providedArgs);  
       if (args[i] != null) {  
          continue;  
       }  
       //判断参数解析器中有没有能够解析该参数的解析器
       if (!this.resolvers.supportsParameter(parameter)) {  
          throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));  
       }  
       try {  
          args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);  
       }  
       catch (Exception ex) {  
          // Leave stack trace for later, exception may actually be resolved and handled...  
          if (logger.isDebugEnabled()) {  
             String exMsg = ex.getMessage();  
             if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {  
                logger.debug(formatArgumentError(parameter, exMsg));  
             }  
          }  
          throw ex;  
       }  
    }  
    return args;  
}
挨个判断所有的参数解析器那个支持解析这个参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//org.springframework.web.method.support.HandlerMethodArgumentResolverComposite#getArgumentResolver
//循环所有解析器，挨个判断那个解析器能够解析这个参数
@Nullable  
private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {  
    HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);  
    if (result == null) {  
       for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {  
          if (resolver.supportsParameter(parameter)) {  
             result = resolver;  
             this.argumentResolverCache.put(parameter, result);  
             break;          }  
       }  
    }  
    return result;  
}
解析这个参数的值

调用各自 HandlerMethodArgumentResolver 的 resolveArgument 方法即可

自定义类型参数 封装POJO

ServletModelAttributeMethodProcessor 这个参数处理器支持
是否为简单类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
public static boolean isSimpleValueType(Class<?> type) {
		return (Void.class != type && void.class != type &&
				(ClassUtils.isPrimitiveOrWrapper(type) ||
				Enum.class.isAssignableFrom(type) ||
				CharSequence.class.isAssignableFrom(type) ||
				Number.class.isAssignableFrom(type) ||
				Date.class.isAssignableFrom(type) ||
				Temporal.class.isAssignableFrom(type) ||
				URI.class == type ||
				URL.class == type ||
				Locale.class == type ||
				Class.class == type));
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
@Override
	@Nullable
	public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

		Assert.state(mavContainer != null, "ModelAttributeMethodProcessor requires ModelAndViewContainer");
		Assert.state(binderFactory != null, "ModelAttributeMethodProcessor requires WebDataBinderFactory");

		String name = ModelFactory.getNameForParameter(parameter);
		ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.class);
		if (ann != null) {
			mavContainer.setBinding(name, ann.binding());
		}

		Object attribute = null;
		BindingResult bindingResult = null;

		if (mavContainer.containsAttribute(name)) {
			attribute = mavContainer.getModel().get(name);
		}
		else {
			// Create attribute instance
			try {
				attribute = createAttribute(name, parameter, binderFactory, webRequest);
			}
			catch (BindException ex) {
				if (isBindExceptionRequired(parameter)) {
					// No BindingResult parameter -> fail with BindException
					throw ex;
				}
				// Otherwise, expose null/empty value and associated BindingResult
				if (parameter.getParameterType() == Optional.class) {
					attribute = Optional.empty();
				}
				bindingResult = ex.getBindingResult();
			}
		}

		if (bindingResult == null) {
			// Bean property binding and validation;
			// skipped in case of binding failure on construction.
	//web数据绑定器，将请求参数的值绑定到指定的javaBean中
	//利用它里面的Converters将请求数据转成指定的数据类型，再次封装到JavaBean中
	
			WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
			if (binder.getTarget() != null) {
				if (!mavContainer.isBindingDisabled(name)) {
					bindRequestParameters(binder, webRequest);
				}
				validateIfApplicable(binder, parameter);
				if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
					throw new BindException(binder.getBindingResult());
				}
			}
			// Value type adaptation, also covering java.util.Optional
			if (!parameter.getParameterType().isInstance(attribute)) {
				attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
			}
			bindingResult = binder.getBindingResult();
		}

		// Add resolved attribute and BindingResult at the end of the model
		Map<String, Object> bindingResultModel = bindingResult.getModel();
		mavContainer.removeAttributes(bindingResultModel);
		mavContainer.addAllAttributes(bindingResultModel);

		return attribute;
	}

**GenericConversionService**：在设置每一个值的时候，找它里面的所有Converter那个可以将这个数据类型（request带来参数的字符串）转换到指定的类型（javaBean–Integer）
byte–file

1
2
@FunctionalInterface  
public interface Converter<S, T>{}

springboot字段类型转换器图示1

springboot字段类型转换器图示2

未来我们可以给WebDataBinder里面放自己的Converter；
private static final class StringToNumber<T extends Number> implements Converter<String, T>
自定义Converter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//1、WebMvcConfigurer定制化SpringMVC的功能
@Bean
public WebMvcConfigurer webMvcConfigurer(){
    return new WebMvcConfigurer() {
        @Override
        public void configurePathMatch(PathMatchConfigurer configurer) {
            UrlPathHelper urlPathHelper = new UrlPathHelper();
            // 不移除；后面的内容。矩阵变量功能就可以生效
            urlPathHelper.setRemoveSemicolonContent(false);
            configurer.setUrlPathHelper(urlPathHelper);
        }

        @Override
        public void addFormatters(FormatterRegistry registry) {
            registry.addConverter(new Converter<String, Pet>() {
	//原本提交数据是通过 pet.name 和 pet.age 来进行绑定的
	//现在直接通过 pet=啊猫,3  这个种自定义格式
                @Override
                public Pet convert(String source) {
                    // 啊猫,3
                    if(!StringUtils.isEmpty(source)){
                        Pet pet = new Pet();
                        String[] split = source.split(",");
                        pet.setName(split[0]);
                        pet.setAge(Integer.parseInt(split[1]));
                        return pet;
                    }
                    return null;
                }
            });
        }
    };
}

目标方法执行完成

目标方法执行完毕后，将所有的数据都存放在ModelAndViewContainer中，包含要去的页面地址View，还包含Model数据
Map&Model参数示意图

处理派发结果

1
2
3
//org.springframework.web.servlet.DispatcherServlet#doDispatch
//处理最终结果,结果已经被封装到了 mv 对象中
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
1
2
3
//org.springframework.web.servlet.view.AbstractView#render
//合并相应结果
renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//org.springframework.web.servlet.view.InternalResourceView#renderMergedOutputModel
@Override  
protected void renderMergedOutputModel(  
       Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {  
  
    // Expose the model object as request attributes.  
    //暴露模型作为请求域属性（将Model和Map中的参数放到请求域中）
    exposeModelAsRequestAttributes(model, request);  
  
    // Expose helpers as request attributes, if any.  
    exposeHelpers(request);  
  
    // Determine the path for the request dispatcher.  
    String dispatcherPath = prepareForRendering(request, response);  
  
    // Obtain a RequestDispatcher for the target resource (typically a JSP).  
    RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);  
    if (rd == null) {  
       throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +  
             "]: Check that the corresponding file exists within your web application archive!");  
    }  
  
    // If already included or response already committed, perform include, else forward.  
    if (useInclude(request, response)) {  
       response.setContentType(getContentType());  
       if (logger.isDebugEnabled()) {  
          logger.debug("Including [" + getUrl() + "]");  
       }  
       rd.include(request, response);  
    }  
  
    else {  
       // Note: The forwarded resource is supposed to determine the content type itself.  
       if (logger.isDebugEnabled()) {  
          logger.debug("Forwarding to [" + getUrl() + "]");  
       }  
       rd.forward(request, response);  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
protected void exposeModelAsRequestAttributes(Map<String, Object> model,  
       HttpServletRequest request) throws Exception {  
  //把Model中的所有数据挨个遍历放到了请求域中
    model.forEach((name, value) -> {  
       if (value != null) {  
          request.setAttribute(name, value);  
       }  
       else {  
          request.removeAttribute(name);  
       }  
    });  
}

数据响应与内容协商

数据响应与内容协商

响应JSON

jackson.jar+@ResponseBody

1
2
3
4
5
6
7
8
9
10
11
<dependency>  
  <groupId>org.springframework.boot</groupId>  
  <artifactId>spring-boot-starter-web</artifactId>  
</dependency>
<!--  引入web场景后，会自动引入json场景处理json数据  -->  
<dependency>  
  <groupId>org.springframework.boot</groupId>  
  <artifactId>spring-boot-starter-json</artifactId>  
  <version>2.7.13</version>  
  <scope>compile</scope>  
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<!--  springboot的json处理主要是依靠jackson进行处理的，所以json场景中引入了jackson的依赖  -->  
<dependency>  
  <groupId>com.fasterxml.jackson.core</groupId>  
  <artifactId>jackson-databind</artifactId>  
  <version>2.13.5</version>  
  <scope>compile</scope>  
</dependency>  
<dependency>  
  <groupId>com.fasterxml.jackson.datatype</groupId>  
  <artifactId>jackson-datatype-jdk8</artifactId>  
  <version>2.13.5</version>  
  <scope>compile</scope>  
</dependency>  
<dependency>  
  <groupId>com.fasterxml.jackson.datatype</groupId>  
  <artifactId>jackson-datatype-jsr310</artifactId>  
  <version>2.13.5</version>  
  <scope>compile</scope>  
</dependency>

我们只需要在controller方法或者类上面添加 @ResponseBody 注解，就会自动返回json格式数据

返回值解析器

springboot默认情况下有15个返回值解析器
返回值解析器图示

1
2
3
4
5
6
//org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod#invokeAndHandle 
try {  
	// 调用返回值处理器处理返回值
    this.returnValueHandlers.handleReturnValue(  
          returnValue, getReturnValueType(returnValue), mavContainer, webRequest);  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite
//获取返回值处理器，并对返回值进行处理
@Override  
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,  
       ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {  
  //获取返回值处理器
    HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);  
    if (handler == null) {  
       throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());  
    }  
    //处理返回值
    handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);  
}
//获取返回值处理器
@Nullable  
private HandlerMethodReturnValueHandler selectHandler(@Nullable Object value, MethodParameter returnType) {  
//判断是否是异步返回
    boolean isAsyncValue = isAsyncReturnValue(value, returnType);  
    //循环所有的返回值处理器
    for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) {  
       if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) {  
          continue;  
       }  
       //判断返回值处理器是否可以处理该返回值
       if (handler.supportsReturnType(returnType)) {  
          return handler;  
       }  
    }  
    return null;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor#handleReturnValue
//最终处理标记了ResponseBody注解的返回值的处理器
@Override  
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,  
       ModelAndViewContainer mavContainer, NativeWebRequest webRequest)  
       throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {  
  
    mavContainer.setRequestHandled(true);  
    ServletServerHttpRequest inputMessage = createInputMessage(webRequest);  
    ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);  
  
    // Try even with null return value. ResponseBodyAdvice could get involved.  
    //使用消息转换器进行写出操作
    writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);  
}
返回值解析器原理

返回值解析器内部方式图示

  • 1、返回值处理器判断是否支持这种返回值 supportsReturnType
  • 2、返回值处理器调用 handleReturnValue 进行处理
  • 3、RequestResponseBodyMethodProcessor 可以处理返回值标了@ResponseBody注解的
    • 1、利用MessageConverters进行处理将数据写为json
      • 1、内容协商（浏览器默认会以请求头的方式告诉服务器他能接受什么样的内容类型）
      • 2、服务器最终根据自身能力，决定服务器能生成什么样的内容数据（浏览器可以接受*/*表示所有格式的数据）
      • 3、springMVC会挨个遍历容器底层的 HttpMessageConverter ，看谁能够处理？
        • 1、得到MappingJackson2HttpMessageConverter可以将对象写为JSON
        • 2、利用MappingJackson2HttpMessageConverter将对象转为JSON再写出去。

请求头Accept参数图示

SpringMVC到底支持哪些返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ModelAndView
Model
View
ResponseEntity
ResponseBodyEmitter
StreamingResponseBody
HttpEntity
HttpHeaders
Callable
DeferredResult
ListenableFuture
CompletionStage
WebAsyncTask
有 @ModelAttribute 注解，并且不是一个简单类型
有 @ResponseBody 注解   ----> RequestResponseBodyMethodProcessor

HttpMessageConverter原理

MessageConverter规范

HttpMessageConverter方法图示

HttpMessageConverter：看是否支持将此 Class 类型的对象，转为MediaType类型的数据
例如：将 Person 对象转为 JSON 或者将 JSON 转为 Person

默认的MessageConverter

系统中默认的HttpMessageConverter图示
（每个MessageConverter中都会初始化自己能够支持的 MediaType ，Class类型匹配之后也需要支持的 MediaType 匹配才能处理）
0 - ByteArrayHttpMessageConverter 只支持返回类型为 byte[]类型的
1 - StringHttpMessageConverter 只支持返回值类型为 String 类型的
2 - StringHttpMessageConverter 只支持返回值类型为 String 类型的
3 - ResourceHttpMessageConverter 只支持返回值类型为 Resource 接口实现类的
4 - ResourceRegionHttpMessageConverter 只支持返回值类型为 ResourceRegion 或其子类
5 - SourceHttpMessageConverter 支持类型为：DOMSource、SAXSource、StAXSource、StreamSource、Source五种类型的
6 - FormHttpMessageConverter 只支持 MultiValueMap 类型
7 - MappingJackson2HttpMessageConverter 支持任何类型
8 - MappingJackson2HttpMessageConverter 支持任何类型
9 - Jaxb2RootElementHttpMessageConverter 标记了XmlRootElement注解（支持注解方式xml处理）

最终MappingJackson2HttpMessageConverter 把对象转为JSON（利用底层Jackson的ObjectMapper转换的）
HttpMessageConverter处理后的数据图示

内容协商

根据客户端接收能力不同，返回不同媒体类型的数据。

引入xml依赖

1
2
3
4
<dependency>  
  <groupId>com.fasterxml.jackson.dataformat</groupId>  
  <artifactId>jackson-dataformat-xml</artifactId>  
</dependency>

postman分别测试返回json和xml

只需要改变请求头中 Accept 字段，HTTP协议中规定的，告诉服务器本客户端可以接收的数据类型
Accept: application/xml 接收xml格式数据
Accept: application/json 接收json格式数据

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

为了方便内容协商，开启基于请求参数的内容协商功能（浏览器在默认情况下是基于请求头的，但是浏览器的请求头没办法很方便的修改）

1
2
3
4
spring:  
  mvc:  
    contentnegotiation:  
      favor-parameter: true

只需要在路径上添加format参数指定想要的请求类型即可
http://127.0.0.1:8080/test/person?format=xml
http://127.0.0.1:8080/test/person?format=json

新增了一个ParameterContentNegotiationStrategy策略，策略中默认要解析的参数名称为format，并且支持xml和json两种格式数据
内容协商管理器策略图示2

确定客户端接收什么样的内容类型：
1、ParameterContentNegotiationStrategy 策略优先确定是要返回json数据（获取请求头中的format的值）
2、最终进行内容协商返回给客户端json数据

内容协商原理

  • 1、判断当前响应头中是否已经又确定的媒体类型。MediaType

  • 2、获取客户端（postMan、浏览器）支持接收的内容类型。（获取客户端Accept请求头字段）【application/xml】

    • contentNegotiationManager 内容协商管理器 默认使用基于请求头的策略
    • 内容协商管理器策略图示
    • HeaderContentNegotiationStrategy 确定客户端可以接收的内容类型
    • HeaderContentNegotiationStrategy图示

  • 3、循环遍历当前系统中所有的HttpMessageConverter，看谁能支持操作这个对象（Person）

  • 4、找到支持操作Person的Converter，把Converter支持的媒体类型统计出来。

  • 5、客户端需要【application/xml】。服务端能力【10种、json、xml】

  • 服务的支持的媒体类型图示

  • 6、进行内容协商匹配最佳媒体类型

  • 7、再次循环所有的HttpMessageConverter找到支持处理返回值类型（Person）并且支持最佳媒体类型的Converter，调用它进行转化。

支持XML的HttpMessageConverter图示

导入了jackson处理xml的依赖，xml的converter就会自动注入进来

1
2
3
4
5
6
7
8
9
//WebMvcConfigurationSupport
//通过判断类 com.fasterxml.jackson.dataformat.xml.XmlMapper 是否存在，来确定是否添加xml的处理器
if (jackson2XmlPresent) {  
    Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.xml();  
    if (this.applicationContext != null) {  
       builder.applicationContext(this.applicationContext);  
    }  
    messageConverters.add(new MappingJackson2XmlHttpMessageConverter(builder.build()));  
}

自定义MessageConverter

实现多协议数据兼容，json、xml、y-data(自定义类型)
0、@ResponseBody 响应数据出去，调用 RequestResponseBodyMethodProcessor 处理
1、Processor处理方法返回值，通过HttpMessageConverter处理
2、所有 HttpMessageConverter 合起来可以支持各种媒体类型数据的操作（读、写）
3、内容协商找到最终的 HttpMessageConverter

springMVC的功能，都有一个入口给容器中添加自定义，WebMvcConfigurer

1
2
3
4
5
6
7
8
9
@Bean  
public WebMvcConfigurer webMvcConfigurer(){  
    return new WebMvcConfigurer() {  
        @Override  
        public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {  
            converters.add(new YdataHttpMessageConverter());  
        }  
    };  
}

请求的时候只需要设置请求头就可以实现数据格式切换

1
2
GET http://127.0.0.1:8080/test/person  
Accept: application/y-data

自定义实现代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**  
 * 自定义HttpMessageConverter  
 * 将 Person 类型转换成 字段1;字段2;字段3;.... 这种格式  
 * @author YS  
 * @date 2023/10/21  
 */public class YdataHttpMessageConverter implements HttpMessageConverter<Person> {  
  
    @Override  
    public boolean canRead(Class<?> clazz, MediaType mediaType) {  
        //不在实现读取功能，直接返回false  
        return false;  
    }  
  
    @Override  
    public boolean canWrite(Class<?> clazz, MediaType mediaType) {  
        //处理所有Person类型的返回值  
        return clazz.isAssignableFrom(Person.class);  
    }  
  
    /**  
     * 服务器要统计所有HttpMessageConverter都能写出哪些内容类型  
     * application/y-data  
     */    @Override  
    public List<MediaType> getSupportedMediaTypes() {  
        return MediaType.parseMediaTypes("application/y-data");  
    }  
  
    @Override  
    public Person read(Class<? extends Person> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {  
        //读取不做处理  
        return null;  
    }  
  
    @Override  
    public void write(Person person, MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {  
        //自定义协议数据写出  
        String data = person.getUserName()+";"+person.getAge()+";"+person.getBirth();  
        //写出去  
        OutputStream body = outputMessage.getBody();  
        body.write(data.getBytes());  
    }  
}

如何实现url参数形式切换数据格式？
自定义内容基于参数的内容协商策略
自定义基于参数内容协商策略图示

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Bean  
public WebMvcConfigurer webMvcConfigurer(){  
    return new WebMvcConfigurer() {  
        /**  
         * 自定义内容协商策略  
         */  
        @Override  
        public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {  
            //使用springboot提供的基于参数的内容协商策略进行扩展  
            Map<String, MediaType> mediaTypes = new HashMap<>();  
            mediaTypes.put("json",MediaType.APPLICATION_JSON);  
            mediaTypes.put("xml",MediaType.APPLICATION_XML);  
            mediaTypes.put("yd",MediaType.parseMediaType("application/y-data"));  
            //指定支持解析哪些参数对应的哪些媒体类型  
            ParameterContentNegotiationStrategy strategy = new ParameterContentNegotiationStrategy(mediaTypes);  
            configurer.strategies(Collections.singletonList(strategy));  
        }  
  
        @Override  
        public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {  
        //自定义HttpMessageConverter
            converters.add(new YdataHttpMessageConverter());  
        }  
    };  
}

如上，自定义了基于参数的内容协商策略之后，由于是进行了覆盖，所以导致基于请求头的内容协商策略失效。
我们添加一些其他的功能也有可能导致同样的事情发生，所以有些扩展需要谨慎使用。
也可以使用如下配置来增加参数和媒体类型的对应：

1
2
3
4
5
6
7
8
spring:  
  mvc:  
    contentnegotiation:  
      # 开启基于参数的内容协商策略  
      favor-parameter: true  
      # 增加基于参数的内容协商策略中的参数和媒体类型的对应  
      media-types:  
        yd: application/y-data

视图解析与模板引擎

试图解析：springboot默认不支持JSP，需要引入第三方模板引擎技术实现页面渲染。

视图解析

视图处理方式图示

视图解析原理流程

  • 1、目标方法处理的过程中，所有数据都会被放在 ModelAndViewContainer 里面，包括数据和视图地址
  • 2、方法的参数是一个自定义类型对象（从请求参数中确定的），也会放在 ModelAndViewContainer 里面
  • 3、任何目标方法执行完成以后都会返回 ModelAndView （数据和视图地址）
  • 4、processDispatchResult 处理派发结果（页面该如何响应）
    • 1、render(mv, request, response);进行页面渲染逻辑
      • 1、根据方法的String返回值得到 View 对象【定义了页面的渲染逻辑】
        • 1、循环所有的视图解析器尝试是否能根据当前返回值得到view对象
        • 视图解析器图示
        • 2、得到了 login –> ThymeleafView (根据返回值得到对应的view)
        • 3、ContentNegotiatingViewResolver 里面包含了下面所有的视图解析器，内部还是利用下面所有视图解析器得到视图对象
        • 4、view.render(mv.getModelInternal(), request, response); 视图对象调用自定义的 render 进行页面渲染工作
          • RedirectView 如何渲染【重定向到一个页面】
          • 1、获取目标url地址
          • 2、response.sendRedirect(encodedURL); 重定向到啊对应页面

视图解析：

  • 返回值以 forward: 开始：new InternalResourceView(forwardUrl); –> 转发，request.getRequestDispatcher(path).forward(request, response);
  • 返回值以 redirect: 开始：new RedirectView() –> render 就是重定向
  • 返回值是普通字符串：new ThymeleafView() –> 使用视图解析器，进行文本解析，然后将解析后的视图返回到输出流

自定义视图解析器+自定义视图；

模板引擎-Thymeleaf

Thymeleaf简介

Thymeleaf is a modern server-side Java template engine for both web and standalone environments.
现代化、服务端Java模板引擎

基本语法

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

文本值：’one text’ 单引号
数字：0，12，3.0 直接写数字即可
布尔值：true，false
空值：null
变量：one，two，变量不能有空格

文本操作

字符串拼接：+
变量替换：【The name is #{name}】

数学运算

运算符：+，-，*，/，%

布尔运算

运算符：and，or
一元运算：!，not

比较运算

比较：>, <, >=, <=(gt, lt, ge, le)
等式：==，!= (eq, ne)

条件运算

if-then: (if) ? (then)
if-then-else:(if) ? (then) : (else)
Default:(value) ?: (defaultvalue)

特殊操作

无操作：_

设置属性值-th:attr

设置单个值：

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

设置多个值：

1
<img src="../../images/gtvglogo.png"  th:attr="src=@{/images/gtvglogo.png},title=#{logo},alt=#{logo}" />

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

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

所有h5兼容的标签写法：
https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html#setting-value-to-specific-attributes

迭代

1
2
3
4
5
<tr th:each="prod : ${prods}">
        <td th:text="${prod.name}">Onions</td>
        <td th:text="${prod.price}">2.41</td>
        <td th:text="${prod.inStock}? #{true} : #{false}">yes</td>
</tr>
1
2
3
4
5
<tr th:each="prod,iterStat : ${prods}" th:class="${iterStat.odd}? 'odd'">
  <td th:text="${prod.name}">Onions</td>
  <td th:text="${prod.price}">2.41</td>
  <td th:text="${prod.inStock}? #{true} : #{false}">yes</td>
</tr>

条件运算

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

属性优先级

thymeleaf属性优先级图示

thymeleaf使用

引入Starter

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

自动配置好了Thymeleaf

1
2
3
4
5
6
@AutoConfiguration(after = { WebMvcAutoConfiguration.class, WebFluxAutoConfiguration.class })  
@EnableConfigurationProperties(ThymeleafProperties.class)  
@ConditionalOnClass({ TemplateMode.class, SpringTemplateEngine.class })  
@Import({ TemplateEngineConfigurations.ReactiveTemplateEngineConfiguration.class,  
       TemplateEngineConfigurations.DefaultTemplateEngineConfiguration.class })  
public class ThymeleafAutoConfiguration { }

自动配好的策略：

  • 1、所有thymeleaf的配置值都在 ThymeleafProperties
    • org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration
  • 2、配置好了 SpringTemplateEngine （模板引擎）
    • org.springframework.boot.autoconfigure.thymeleaf.TemplateEngineConfigurations
  • 3、配好了 ThymeleafViewResolver （视图解析器）
    • org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration
  • 4、我们只需要直接开发页面就可以了
1
2
3
4
5
//ThymeleafProperties中默认的前缀和后缀
//默认前缀，也就是页面文件需要存放的相对路径
public static final String DEFAULT_PREFIX = "classpath:/templates/";  
//默认后缀，也就是页面文件默认的文件格式
public static final String DEFAULT_SUFFIX = ".html";

页面开发

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

拦截器

HandlerInterceptor接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/**  
 * 登录检查  
 * 1、配置好拦截器需要拦截哪些请求  
 * 2、把这些配置放到容器中  
 */  
public class LoginHandlerInterceptor implements HandlerInterceptor {  
    /**  
     * 目标方法执行之前  
     */  
    @Override  
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {  
        //登录检查逻辑  
        HttpSession session = request.getSession();  
        //检查是否已经登录  
        Object loginUser = session.getAttribute("loginUser");  
        //登录信息不为空，放行  
        if (loginUser != null) return true;  
        //拦截，未登录，跳转到登录页  
//        session.setAttribute("msg","请先登录!");  
        request.setAttribute("msg","请先登录!");  
        //重定向到登录页面  
//        response.sendRedirect("/");  
        //在session中存放数据，使用重定向，会导致前端接收不到存放的数据  
        //将数据存放到请求域中，使用转发，前端可以正常拿到数据  
        request.getRequestDispatcher("/").forward(request,response);  
        return false;    }  
  
    /**  
     * 目标方法执行完成之后  
     */  
    @Override  
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {  
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);  
    }  
  
    /**  
     * 页面渲染以后  
     */  
    @Override  
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {  
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);  
    }  
}

配置拦截器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**  
 * 1、编写一个拦截器实现HandlerInterceptor接口  
 * 2、拦截器注册到容器中，（实现WebMvcConfigurer接口的addInterceptors方法）  
 * 3、指定拦截规则【如果是拦截所有，静态资源也会被拦截】  
 */  
@Configuration  
public class AdminWebConfig implements WebMvcConfigurer {  
  
    @Override  
    public void addInterceptors(InterceptorRegistry registry) {  
        //添加自定义拦截器  
        registry.addInterceptor(new LoginHandlerInterceptor())  
                //指定拦截路径  
                .addPathPatterns("/**")//拦截所有请求，静态资源也会被拦截，需要在下面放过静态资源  
                //指定需要放行的路径  
                .excludePathPatterns("/","login","/css/**","/fonts/**","/images/**","/js/**");  
    }  
}

拦截器原理

  • 1、根据当前请求，找到 HandlerExecutionChain 【可以处理请求的handler以及handler的所有拦截器集合】
  • 2、先顺序执行所有拦截器的 preHandle 方法
    • 1、如果当前拦截器的 preHandle 方法返回true，则执行下一个拦截器的 preHandle
    • 2、如果当前拦截器preHandle 方法返回false，直接 倒序执行所有已经执行了的拦截器的 afterCompletion 方法
  • 3、如果任何一个拦截器返回false，则直接跳出不执行目标方法
  • 4、所有拦截器都返回true，执行目标方法
  • 5、倒序执行所有拦截器的postHandle方法，
  • 6、前面的步骤有任何异常都会直接倒序执行afterCompletion
  • 7、页面成功渲染完成以后，也会倒序触发 afterCompletion 方法

HandlerExecutionChain

springboot拦截器执行流程图示

文件上传

页面表单

1
2
3
4
5
6
7
<form th:action="@{/upload}" method="post" enctype="multipart/form-data">  
    邮箱:<input type="email" name="email"/><br><br>  
    名字:<input type="text" name="username"/><br><br>  
    头像:<input type="file" name="file"/><br><br>  
    生活照:<input type="file" name="photos" multiple><br><br>  
    <input type="submit" value="提交"/>  
</form>

文件上传代码

1
2
3
4
5
6
7
8
9
@PostMapping("/upload")  
public String upload(@RequestParam String email,  
                     @RequestParam String username,  
                     @RequestPart MultipartFile file,  
                    @RequestPart MultipartFile[] photos ){  
    log.info("接收到的信息:email={},username={},file={},photos={}",  
            email,username,file.getSize(),photos.length);  
    return "main";  
}

自动配置原理

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

  • 自动配置好了 StandardServletMultipartResolver （文件上传解析器）
  • 原理步骤
    • 1、请求进来使用文件上传解析器判断（isMultipart）并封装（resolveMultipart，返回MultipartHttpServletRequest）文件上传请求
    • 2、参数解析器来解析请求中的文件内容，并封装成MultipartFile
    • 文件上传参数解析器图示
    • 3、将request中文件信息封装为Map；LinkedMultiValueMap<String,List\<MultipartFile>>
      FileCopyUtils，工具类，方便文件复制

异常处理

错误处理

默认规则

  • 默认情况下，SpringBoot提供/error处理所有的错误映射
  • 对于机器客户端，它将生成JSON响应，其中包含错误，HTTP状态和异常消息的详细信息，对于浏览器客户端，响应一个“whitelabel”错误视图，以HTML格式呈现相同的数据
  • springboot返回json错误信息图示
  • springboot返回html错误信息图示
  • 要对其进行自定义，添加View解析为error
  • 要完全替换默认行为，可以实现ErrorController并注册该类型的Bean定义，或添加ErrorAttributes类型的组件，以使用现有机制替换其内容
  • erro/下的4xx、5xx页面会被自动解析（当错误状态码为4开头的会自动找4xx页面，当错误状态码为5开头的会找5xx页面）

定制错误处理逻辑

  • 自定义错误页
    • error/404.html error/500.html；有精确错误状态页面就匹配精确，没有就找非精确，比如4xx.html，如果还没有，就展示默认错误页
    • @ControllerAdvice+@ExceptionHandler处理全局异常；底层是 ExceptionHandlerExceptionResolver 支持的
      • 启动时根据@ExceptionHandler注解判断哪个方法可以处理哪些异常，然后抓取到对应异常后就调用对应的方法，然后根据方法的返回值再进行处理
    • @ResponseStatus+自定义异常，底层是 ResponseStatusExceptionResolver支持
      • 把ResponseStatus注解中标注的信息，底层调用 response.sendError(statusCode, resolvedReason); tomcat发送的/error
    • spring底层的异常，如参数类型转换异常；DefaultHandlerExceptionResolver处理；
      • 判断异常属于什么类型，然后设置对应的状态码，调用 response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ex.getMessage());进行转发
    • 自定义实现 HandlerExceptionResolver 处理异常，可以作为默认的全局异常处理规则；（默认优先级最低，可以使用@Order注解调整优先级）
    • 自定义 ErrorViewResolver 实现异常处理
      • 默认寻找可以处理对应错误的视图，比如4xx.html
      • 如果该异常没有任何情况能够处理，就会调用tomcat底层的 response.sendError() 方法，然后就会再次发起一次/error的请求，请求就会被对应controller接收处理
      • BasicErrorController要去的页面地址是 ErrorViewResolver

异常处理自动配置原理

  • ErrorMvcAutoConfiguration自动配置异常处理规则
    • 容器中的组件：类型：DefaultErrorAttributes –> id：errorAttributes
      • public class DefaultErrorAttributes implements ErrorAttributes, HandlerExceptionResolver, Ordered
      • DefaultErrorAttributes：定义错误页面中可以包含哪些数据。
    • 容器中的组件：类型：BasicErrorController –> id：basicErrorController（json+白页 适配响应）
      • 默认处理 /error 路径的请求，页面响应 new ModelAndView("error", model)
      • 容器中有组件 View –> id是error；（默认响应错误页）
      • 容器中放组件 BeanNameViewResolver （视图解析器）；按照返回的视图名作为组件的id去容器中找view对象
    • 容器中的组件：类型：DefaultErrorViewResolver –> id：conventionErrorViewResolver
      • 如果发生错误，会以HTTP的状态码作为视图地址（viewName），找到真正的页面
      • error/4xx、5xx.html

BasicErrorController类上的@RequestMapping("${server.error.path:${error.path:/error}}")表示如果设置了server.error.path，就使用这个设置，如果没有设置就使用error.path，如果这个也没有设置，就默认使用/error;
类中有两个方法，第一个方法上标注了注解@RequestMapping(produces = MediaType.TEXT_HTML_VALUE)，表示处理html类型的请求，返回值是ModelAndView，视图名称是error，最终会找到设置好的错误视图页面；
类中另一个方法，没有做特殊配置，返回json类型数据，也是json类型的请求.

异常处理步骤流程

  • 1、执行目标方法，目标方法运行期间有任何异常都会被catch，而且标志当前请求结束，并且用dispatchException将异常信息进行封装
  • 2、进入视图解析流程（页面渲染？）
    • processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    • 会把视图和错误信息都传递进去，视图只有在方法正确执行的情况下才会有值
  • 3、mv = processHandlerException(request, response, handler, exception); 处理handler发生的异常，处理完成返回 ModelAndView；
    • 遍历所有的 handlerExceptionResolvers，看谁能处理当前异常【HandlerExceptionResolver处理器异常解析器】
    • 2、系统默认的异常解析器：
    • 系统默认的异常解析器图示
      • DefaultErrorAttributes先类处理异常，会把异常信息保存到request请求域中，并且返回null；
      • 默认没有任何处理器能处理异常，所以异常会被抛出
        • 1、如果没有任何处理器能够处理异常，本次请求就会结束，然后底层会再次发起 /error 请求，该请求会被 BasicErrorController 处理
        • 2、解析错误视图，遍历所有的 ErrorViewResolver 看谁能够解析（默认情况下只有一个）
        • ErrorViewResolver图示
        • 3、默认的 DefaultErrorViewResolver ，作用是把响应状态码作为错误页面的地址，error/500.html
        • 4、模板引擎最终响应这个页面 error/500.html

Web原生组件注入（Servlet、Filter、Listenter）

使用Servlet API

  • 在启动类上标记 @ServletComponentScan 注解，表示扫描哪些包下的servlet组件，默认是当前类所在包及其子包，也可以通过注解参数指定
  • @WebServlet(urlPatterns = "/my") 创建一个Servlet，会直接响应结果，没有经过Spring的拦截器
    • 在类上标记对应注解，并继承HttpServlet类重写对应的方法即可实现
  • @WebFilter(urlPatterns = "/*") 创建一个Servlet过滤器
    • 在类上标记对应注解，并继承Filter接口重写相应的方法
  • @WebListener 创建一个servlet监听器
    • 在类上标记对应注解，并继承对应的监听接口实现相应方法即可

扩展：DispatcherServlet 是如何注册进来的

  • 在 DispatcherServletAutoConfiguration 中向容器注册了 DispatcherServlet 的Bean
  • 容器中自动配置了 DispatcherServlet，属性绑定到 WebMvcProperties；对应的配置文件配置项是 spring.mvc
  • 之后又将 DispatcherServlet 的bean作为入参做了二次封装，封装成 DispatcherServletRegistrationBean
  • DispatcherServlet 默认映射的是 / 路径

多个Servlet图示

Tomcat-Servlet
多个Servlet都能处理同一层路径时，精确优先原则

使用RegistrationBean

ServletRegistrationBean、FilterRegistrationBean、ServletListenerRegistrationBean
使用spring提供的三个类进行封装，然后注册成Bean

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Configuration  
public class MyRegistConfig {  
    @Bean  
    public ServletRegistrationBean<MyServlet> myServlet(){  
        MyServlet myServlet = new MyServlet();  
        return new ServletRegistrationBean<>(myServlet,"/my","my01");  
    }  
    @Bean  
    public FilterRegistrationBean<MyFilter> myFilter(){  
        MyFilter myFilter = new MyFilter();  
        FilterRegistrationBean<MyFilter> registrationBean = new FilterRegistrationBean<>(myFilter);  
        registrationBean.setUrlPatterns(Arrays.asList("/my","/my01"));  
        return registrationBean;  
    }  
    @Bean  
    public ServletListenerRegistrationBean<MyServletContextListener> myListener(){  
        MyServletContextListener myServletContextListener = new MyServletContextListener();  
        return new ServletListenerRegistrationBean<>(myServletContextListener);  
    }  
}

嵌入式Servlet容器

切换嵌入式Servlet

  • 默认支持的WebServer
    • Tomcat、Jetty 、Undertow
    • ServletWebServerApplicationContext容器启动自动寻找ServletWebServerFactory并引导创建服务
  • 切换服务器
    • springboot支持的WebServer图示
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      <!--    想要切换springboot的web服务器，只需要将默认的tomcat依赖从web中排除然后引入新的web服务器的依赖即可    -->
      <dependency>  
          <groupId>org.springframework.boot</groupId>  
          <artifactId>spring-boot-starter-web</artifactId>  
          <exclusions>  
              <exclusion>  
                  <groupId>org.springframework.boot</groupId>  
                  <artifactId>spring-boot-starter-tomcat</artifactId>  
              </exclusion>  
          </exclusions>  
      </dependency>  
      <dependency>  
          <groupId>org.springframework.boot</groupId>  
          <artifactId>spring-boot-starter-undertow</artifactId>  
      </dependency>
  • 原理
    • SpringBoot应用启动发现当前是Web应用。web场景包-默认导入tomcat
    • web应用会创建一个web版的ioc容器，ServletWebServerApplicationContext
    • ServletWebServerApplicationContext启动的时候寻找ServletWebServerFactory（Servlet的web服务器工厂—>Servlet的web服务器）
    • SpringBoot底层默认又很多的WebServer工厂；TomcatServletWebServerFactory、JettyServletWebServerFactory、UndertowServletWebServerFactory
    • 底层直接会又一个自动配置类。ServletWebServerFactoryAutoConfiguration
    • ServletWebServerFactoryAutoConfiguration导入了ServletWebServerFactoryConfiguration(配置类)
    • ServletWebServerFactoryConfiguration配置类 根据动态判断系统中到底导入了哪个web服务器的包来创建不同的工厂（默认web-starter导入的是tomcat包），容器中就有了 TomcatServletWebServerFactory
    • TomcatServletWebServerFactory创建出Tomcat服务器并启动；TomcatWebServer的构造器拥有初始化方法 initialize()，该方法中执行了this.tomcat.start();启动tomcat
    • 内嵌服务器，就是手动把启动服务器的代码调用（tomcat核心jar包存在）

定制Servlet容器

  • 实现WebServerFactoryCustomizer<ConfigurableServletWebServerFactory>
    • 把配置文件的值和 ServletWebServerFactory 进行绑定
  • 修改配置文件 server.xxx
  • 直接自定义 ConfigurableServletWebServerFactory

xxxxCustomizer: 定制化器，可以改变xxxx的默认规则

定制化原理

定制化的常见方式

  • 修改配置文件
  • xxxxCustomizer
  • 编写自定义配置类，xxxConfiguration；@Bean替换、增加容器中默认组件；视图解析器
  • web应用编写一个配置类实现 WebMvcConfigurer 接口即可定制化web功能；@Bean给容器中再扩展一些组件
    • WebMvcConfigurer接口中定义了大多数场景的扩展方法，只需要实现该接口的某些方法即可实现相应功能的定制
  • @EnableWebMvc + WebMvcConfigurer 可以全面接管SpringMVC，所有规则全部自己重新配置；实现定制和扩展功能（高度自定义化）
  • 原理
    • 1、WebMvcAutoConfiguration 是默认的SpringMVC的自动配置功能类，（静态资源访问、欢迎页…）
    • 2、一旦使用 @EnableWebMvc 注解，会 @Import(DelegatingWebMvcConfiguration.class)
    • 3、DelegatingWebMvcConfiguration 的作用，只包装SpringMVC最基本的使用
      • 注入系统所有WebMvcConfigurer类型的Bean,把所有功能定制的这些 WebMvcConfigurer 合起来一起生效
      • 只默认配置了一些非常底层的组件，比如RequestMappingHandlerMapping等，这些组件依赖的组件都是直接从容器中获取的
      • public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport{}
    • 4、@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
      • WebMvcAutoConfiguration 配置要想生效，需要容器中不存在WebMvcConfigurationSupport类型的Bean才行，而@EnableWebMvc注解引入的DelegatingWebMvcConfiguration类就是WebMvcConfigurationSupport的子类
    • @EnableWebMvc导致WebMvcAutoConfiguration没有生效

原理分析套路

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

数据访问

SQL

数据源的自动配置-HikariDataSource

导入JDBC场景

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

springbootdatajdbc依赖示意图

数据库驱动？
为什么导入jdbc场景，官方不导入驱动？
官方不知道我们接下来要操作什么数据库。
数据库版本和驱动版本对应。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<!--  默认版本：  -->
<mysql.version>8.0.22</mysql.version>

    <dependency>  
      <groupId>mysql</groupId>  
      <artifactId>mysql-connector-java</artifactId>  
<!--      <version>8.0.27</version>-->  
    </dependency>
<!--   
想要修改版本：
1、直接依赖引入具体版本（maven的就近依赖原则）
2、重新声明版本（maven的属性的就近优先原则）
<properties>  
    <mysql.version>8.0.27</mysql.version>  
</properties>
springboot2.7.8之后，引入的mysql依赖变成以下格式（mysql8.0.31）：
-->  
<dependency>  
    <groupId>com.mysql</groupId>  
    <artifactId>mysql-connector-j</artifactId>  
</dependency>

分析自动配置

自动配置的类

  • DataSourceAutoConfiguration：数据源的自动配置

    • 修改数据源相关的配置：spring.datasource
    • 数据库连接池的配置，是容器中没有 DataSource 的时候才会自动配置
    • 底层配置好好的连接池是：HikariDataSource
      • springboot检查到我们没有配置数据源后会尝试引入其他的多个数据源，默认情况下，只有HikariDataSource的配置会符合条件，其余均不符合条件
        1
        2
        3
        4
        5
        6
        7
        @Configuration(proxyBeanMethods = false)  
        @Conditional(PooledDataSourceCondition.class)  
        @ConditionalOnMissingBean({ DataSource.class, XADataSource.class })  
        @Import({ DataSourceConfiguration.Hikari.class, DataSourceConfiguration.Tomcat.class,  
               DataSourceConfiguration.Dbcp2.class, DataSourceConfiguration.OracleUcp.class,  
               DataSourceConfiguration.Generic.class, DataSourceJmxConfiguration.class })  
        protected static class PooledDataSourceConfiguration {}

  • DataSourceTransactionManagerAutoConfiguration：事务管理器的自动配置

  • JdbcTemplateAutoConfiguration：JdbcTemplate的自动配置，可以用来对数据进行crud

    • 通过修改spring.jdbc相关的配置来修改JdbcTemplate
    • 容器中已经默认放了一个JdbcTemplate组件，可以直接注入使用

  • JndiDataSourceAutoConfiguration：jndi的自动配置

  • XADataSourceAutoConfiguration：分布式事务相关的自动配置

修改配置项

1
2
3
4
5
6
spring:  
  datasource:  
    url: jdbc:mysql://192.168.96.131:3306/yin  
    username: root  
    password: 123456  
    driver-class-name: com.mysql.cj.jdbc.Driver

测试

1
2
3
4
5
6
7
@Autowired  
private JdbcTemplate jdbcTemplate;  
@Test  
public void JdbcTemplateTest() {  
    Long aLong = jdbcTemplate.queryForObject("SELECT COUNT(*) FROM jd_cloud", Long.class);  
    log.info("记录数是:{}", aLong);  
}

使用Druid数据源

druid官方github地址

https://github.com/alibaba/druid

整合三方技术的两种方式

  • 自定义
  • 找starter

自定义方式

创建数据源
1
2
3
4
5
<dependency>  
    <groupId>com.alibaba</groupId>  
    <artifactId>druid</artifactId>  
    <version>1.2.17</version>  
</dependency>

手动写相关配置实现对应的功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
@Configuration  
public class DataSourceConfig {  
    @ConfigurationProperties("spring.datasource")  
    @Bean  
    public DataSource dataSource() throws SQLException {  
        DruidDataSource druidDataSource = new DruidDataSource();  
        //stat开启sql监控，wall开启防火墙监控  
        druidDataSource.setFilters("stat,wall");  
        return druidDataSource;  
    }  
    @Bean  
    public ServletRegistrationBean<StatViewServlet> statViewServlet(){  
        StatViewServlet statViewServlet = new StatViewServlet();  
        //配置Servlet的地址  
        ServletRegistrationBean<StatViewServlet> registrationBean = new ServletRegistrationBean<>(statViewServlet, "/druid/*");  
        //配置Servlet的初始化参数  
        //loginUsername: druid监控页面登录用户名，loginPassword：监控页面登录密码，不配置则可以不用登录直接访问  
        registrationBean.addInitParameter("loginUsername","admin");  
        registrationBean.addInitParameter("loginPassword","123456");  
        return registrationBean;  
    }  
    @Bean  
    public FilterRegistrationBean<WebStatFilter> webStatFilter(){  
        WebStatFilter webStatFilter = new WebStatFilter();  
        FilterRegistrationBean<WebStatFilter> registrationBean = new FilterRegistrationBean<>(webStatFilter);  
        //配置web监控  
        registrationBean.setUrlPatterns(Collections.singleton("/*"));  
        registrationBean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");  
        return registrationBean;  
    }  
}
StatViewServlet

StatViewServlet 的用途包括：
1、提供监控信息展示的html页面
2、提供监控信息的JSON API

StatFilter

用于统计监控信息；如SQL监控，URL监控

系统中所有的filter:

别名 Filter类名
default com.alibaba.druid.filter.stat.StatFilter
stat com.alibaba.druid.filter.stat.StatFilter
mergeStat com.alibaba.druid.filter.stat.MergeStatFilter
encoding com.alibaba.druid.filter.encoding.EncodingConvertFilter
log4j com.alibaba.druid.filter.logging.Log4jFilter
log4j2 com.alibaba.druid.filter.logging.Log4j2Filter
slf4j com.alibaba.druid.filter.logging.Slf4jLogFilter
commonlogging com.alibaba.druid.filter.logging.CommonsLogFilter

慢SQL记录配置：

1
2
3
4
5
6
7
@Bean  
public StatFilter statFilter(){  
    StatFilter statFilter = new StatFilter();  
    statFilter.setSlowSqlMillis(10000);  
    statFilter.setLogSlowSql(true);  
    return statFilter;  
}

使用官方starter方式

引入druid-starter
1
2
3
4
5
<dependency>  
    <groupId>com.alibaba</groupId>  
    <artifactId>druid-spring-boot-starter</artifactId>  
    <version>1.2.17</version>  
</dependency>
分析自动配置
  • 扩展配置项 spring.datasource.druid
  • DruidSpringAopConfiguration: 监控SpringBean的，配置项：spring.datasource.druid.aop-patterns
  • DruidStatViewServletConfiguration: 监控页面的配置，spring.datasource.druid.stat-view-servlet
    • enabled缺失的时候会自动认定为true（默认开启），但是enabled为基本类型，有默认值false，所以默认情况下是不开启的
  • DruidWebStatFilterConfiguration: web监控配置，spring.datasource.druid.web-stat-filter
  • DruidFilterConfiguration: 所有Druid自己filter的配置
    1
    2
    3
    4
    5
    6
    7
    8
    private static final String FILTER_STAT_PREFIX = "spring.datasource.druid.filter.stat";  
    private static final String FILTER_CONFIG_PREFIX = "spring.datasource.druid.filter.config";  
    private static final String FILTER_ENCODING_PREFIX = "spring.datasource.druid.filter.encoding";  
    private static final String FILTER_SLF4J_PREFIX = "spring.datasource.druid.filter.slf4j";  
    private static final String FILTER_LOG4J_PREFIX = "spring.datasource.druid.filter.log4j";  
    private static final String FILTER_LOG4J2_PREFIX = "spring.datasource.druid.filter.log4j2";  
    private static final String FILTER_COMMONS_LOG_PREFIX = "spring.datasource.druid.filter.commons-log";  
    private static final String FILTER_WALL_PREFIX = "spring.datasource.druid.filter.wall";
配置示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
spring:  
  datasource:  
    url: jdbc:mysql://192.168.96.131:3306/test  
    username: root  
    password: 123456  
    driver-class-name: com.mysql.cj.jdbc.Driver  
    druid:  
      stat-view-servlet:  # 配置监控页
        enabled: true  
        login-password: 123456  
        login-username: admin  
        reset-enable: false  
      web-stat-filter:  # web监控
        enabled: true  
        url-pattern: /*  
        exclusions: '*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*'  
      filters: stat,wall  # 开启功能，stat sql监控，sall 防火墙
      filter:  
        stat:  # 对filters中stat的详细配置
          enabled: true  
          slow-sql-millis: 1000  
          log-slow-sql: true  
        wall:  # 对filters中wall的详细配置
          config:  
            drop-table-allow: false  
      aop-patterns: com.ys.boot.*
      # 配置springBean的监控，不过最新版(1.2.17)想要开启需要将spring.aop.auto的值设置为false

整合Mybatis操作

https://github.com/mybatis
starter

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

mybatisStarter引入依赖图示

配置模式

  • 全局配置文件
  • SqlSessionFactory ： 自动配置好了
  • SqlSession：自动配置了SqlSessionTemplate，组合了SqlSession
  • @Import(AutoConfiguredMapperScannerRegistrar.class)
  • Mapper：只要我们写的操作mybatis的接口标记了 @Mapper 注解，就会自动被扫描进来
1
2
3
4
5
6
7
8
9
10
11
@org.springframework.context.annotation.Configuration  
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })  
@ConditionalOnSingleCandidate(DataSource.class)  
//Mybatis配置项绑定类
@EnableConfigurationProperties(MybatisProperties.class)  
@AutoConfigureAfter({ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class })  
public class MybatisAutoConfiguration implements InitializingBean {}

//可以修改配置文件中mybatis开头的配置项
@ConfigurationProperties(prefix = "mybatis")  
public class MybatisProperties {}
1
2
3
4
5
6
7
8
mybatis:  
# mybatis 全局配置文件
  # config-location: classpath:mybatis/mybatis-config.xml  
  # mybatis sql映射文件位置
  mapper-locations: classpath:mybatis/mapper/*.xml  
  # 该配置项可以替代mybatis全局配置文件，可以直接在这里写配置，不用再xml文件
  configuration:  
    map-underscore-to-camel-case: true
  • 编写Mapper接口，标记@Mapper注解
  • 编写sql映射文件并绑定mapper接口
  • 在application.yml中指定mapper映射文件的位置，以及指定全局配置文件的信息（建议使用mybais.configuration）

注解模式

1
2
3
4
5
@Mapper
public interface CityMapper {
    @Select("select * from city where id=#{id}")
    public City getById(Long id);
}

混合模式

1
2
3
4
5
6
7
@Mapper
public interface CityMapper {
    @Select("select * from city where id=#{id}")
    public City getById(Long id);
	//使用xml来实现该方法的sql映射
    public void insert(City city);
}

最佳实战：

  • 引入mybatis-starter
  • 配置application.yml中，指定mapper-locations位置即可
  • 编写Mapper接口，并标注@Mapper注解
  • 简单方法直接注解方式
  • 复杂方法编写mapper.xml进行绑定映射
  • @MapperScan("com.ys.mapper")简化，mapper接口可以不再标注@Mapper注解

整合Mybatis-plus 完成CRUD

什么是Mybatis-plus

MyBatis-Plus（简称 MP）是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

MyBatis-Plus官网

整合Mybatis-plus

1
2
3
4
5
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>最新版本</version>
</dependency>

自动配置：

  • MybatisPlusAutoConfiguration：配置类，MybatisPlusProperties配置绑定，mybatis-plus.xxx 就是对mybatis-plus的定制
  • SqlSessionFactory 自动配置好了，默认从spring容器中获取数据源
  • mapperLocations 自动配置好的，有默认值，classpath*:/mapper/**/*.xml 任意包的类路径下的所有mapper文件夹下的任意路径下的所有xml都是sql映射文件
  • @Mapper 标注 的接口也会被自动扫描

优点：

  • 只需要我们的Mapper继承BaseMapper就可以拥有crud的能力

NoSQL

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

Redis自动配置

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

springbootredis依赖图示

自动配置：

  • RedisAutoConfiguration 自动配置类，RedisProperties 属性类，spring.redis.xxx是对redis的配置
  • 连接工厂是准备好的，LettuceConnectionConfiguration、JedisConnectionConfiguration，（默认使用Lettuce，可以进行切换）
  • 自动注入了RedisTemplate<Object, Object>
  • 自动注入了StringRedisTemplate k v都是string
  • 我们只要使用StringRedisTemplate和RedisTemplate就可以操作redis了

RedisTemplate与Lettice

默认是使用的Lettice客户端

1
2
3
4
5
6
7
8
9
10
@Autowired  
private StringRedisTemplate stringRedisTemplate;  
  
@Test  
public void redisTest(){  
    ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();  
    operations.set("hello","world");  
    String hello = operations.get("hello");  
    System.out.println(hello);  
}

切换至jedis

增加jedis的依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<dependency>  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-data-redis</artifactId>  
    <exclusions>  
        <exclusion>  
            <groupId>io.lettuce</groupId>  
            <artifactId>lettuce-core</artifactId>  
        </exclusion>  
    </exclusions>  
</dependency>  
<dependency>  
    <groupId>redis.clients</groupId>  
    <artifactId>jedis</artifactId>  
</dependency>

如果是直接排除lettuce的依赖，然后引入jedis的依赖，那么不用写切换配置，spring会自动切换到jedis，如果没有排除lettuce，那么可以在yml中进行如下配置切换客户端工具。

1
2
3
spring:
	redis:  
	  client-type: jedis

单元测试

Junit5的变化

Spring Boot 2.2.0 版本开始引入 JUnit 5 作为单元测试默认库

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

JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage

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

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

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

junit5结构示意图

注意：
SpringBoot 2.4 以上版本移除了默认对 Vintage 的依赖。如果需要兼容junit4需要自行引入（不能使用junit4的功能 @Test）
JUnit 5’s Vintage Engine Removed from spring-boot-starter-test,如果需要继续兼容junit4需要自行引入vintage

1
2
3
4
5
6
7
8
9
10
11
<dependency>
    <groupId>org.junit.vintage</groupId>
    <artifactId>junit-vintage-engine</artifactId>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.hamcrest</groupId>
            <artifactId>hamcrest-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

springboot对Junit的支持：

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

SpringBoot整合Junit以后。

  • 编写测试方法：@Test标注（注意需要使用junit5版本的注解）
  • Junit类具有Spring的功能，@Autowired、比如 @Transactional 标注测试方法，测试完成后自动回滚

Junit5常用的注解

JUnit5的注解与JUnit4的注解有所变化
https://junit.org/junit5/docs/current/user-guide/#writing-tests-annotations

  • @Test : 表示方法是测试方法。但是与JUnit4的@Test不同，他的职责非常单一不能声明任何属性，拓展的测试将会由Jupiter提供额外测试
  • @ParameterizedTest : 表示方法是参数化测试，下方会有详细介绍
  • @RepeatedTest : 表示方法可重复执行，下方会有详细介绍
  • @DisplayName : 为测试类或者测试方法设置展示名称
  • @BeforeEach : 表示在每个单元测试之前执行
  • @AfterEach : 表示在每个单元测试之后执行
  • @BeforeAll : 表示在所有单元测试之前执行
  • @AfterAll : 表示在所有单元测试之后执行
  • @Tag : 表示单元测试类别，类似于JUnit4中的@Categories
  • @Disabled : 表示测试类或测试方法不执行，类似于JUnit4中的@Ignore
  • @Timeout : 表示测试方法运行如果超过了指定时间将会返回错误
  • @ExtendWith : 为测试类或测试方法提供扩展类引用

断言（assertions）

断言（assertions）是测试方法中的核心部分，用来对测试需要满足的条件进行验证。这些断言方法都是 org.junit.jupiter.api.Assertions 的静态方法。JUnit 5 内置的断言可以分成如下几个类别：
检查业务逻辑返回的数据是否合理。
所有的测试运行结束以后，会有一个详细的测试报告；

简单断言

用来对单个值进行简单的验证。如：

方法 说明
assertEquals 判断两个对象或两个原始类型是否相等
assertNotEquals 判断两个对象或两个原始类型是否不相等
assertSame 判断两个对象引用是否指向同一个对象
assertNotSame 判断两个对象引用是否指向不同的对象
assertTrue 判断给定的布尔值是否为 true
assertFalse 判断给定的布尔值是否为 false
assertNull 判断给定的对象引用是否为 null
assertNotNull 判断给定的对象引用是否不为 null 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Test
@DisplayName("simple assertion")
public void simple() {
     assertEquals(3, 1 + 2, "simple math");
     assertNotEquals(3, 1 + 1);

     assertNotSame(new Object(), new Object());
     Object obj = new Object();
     assertSame(obj, obj);

     assertFalse(1 > 2);
     assertTrue(1 < 2);

     assertNull(null);
     assertNotNull(new Object());
}

数组断言

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

1
2
3
4
5
@Test
@DisplayName("array assertion")
public void array() {
 assertArrayEquals(new int[]{1, 2}, new int[] {1, 2});
}

组合断言

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

1
2
3
4
5
6
7
8
@Test
@DisplayName("assert all")
public void all() {
 assertAll("Math",
    () -> assertEquals(2, 1 + 1),
    () -> assertTrue(1 > 0)
 );
}

异常断言

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

1
2
3
4
5
6
7
@Test
@DisplayName("异常测试")
public void exceptionTest() {
    ArithmeticException exception = Assertions.assertThrows(
           //扔出断言异常
            ArithmeticException.class, () -> System.out.println(1 % 0));
}

超时断言

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

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

快速失败

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

1
2
3
4
5
@Test
@DisplayName("fail")
public void shouldFail() {
 fail("This should fail");
}

前置条件（assumptions）

JUnit 5 中的前置条件（assumptions【假设】）类似于断言，不同之处在于 不满足的断言会使得测试方法失败 ，而不满足的 前置条件只会使得测试方法的执行终止 。前置条件可以看成是测试方法执行的前提，当该前提不满足时，就没有继续执行的必要。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@DisplayName("前置条件")
public class AssumptionsTest {
 private final String environment = "DEV";
 
 @Test
 @DisplayName("simple")
 public void simpleAssume() {
    assumeTrue(Objects.equals(this.environment, "DEV"));
    assumeFalse(() -> Objects.equals(this.environment, "PROD"));
 }
 
 @Test
 @DisplayName("assume then do")
 public void assumeThenDo() {
    assumingThat(
       Objects.equals(this.environment, "DEV"),
       () -> System.out.println("In DEV")
    );
 }
}

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

嵌套测试

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
@DisplayName("A stack")
class TestingAStackDemo {

    Stack<Object> stack;

    @Test
    @DisplayName("is instantiated with new Stack()")
    void isInstantiatedWithNew() {
        new Stack<>();
    }

    @Nested
    @DisplayName("when new")
    class WhenNew {

        @BeforeEach
        void createNewStack() {
            stack = new Stack<>();
        }

        @Test
        @DisplayName("is empty")
        void isEmpty() {
            assertTrue(stack.isEmpty());
        }

        @Test
        @DisplayName("throws EmptyStackException when popped")
        void throwsExceptionWhenPopped() {
            assertThrows(EmptyStackException.class, stack::pop);
        }

        @Test
        @DisplayName("throws EmptyStackException when peeked")
        void throwsExceptionWhenPeeked() {
            assertThrows(EmptyStackException.class, stack::peek);
        }

        @Nested
        @DisplayName("after pushing an element")
        class AfterPushing {

            String anElement = "an element";

            @BeforeEach
            void pushAnElement() {
                stack.push(anElement);
            }

            @Test
            @DisplayName("it is no longer empty")
            void isNotEmpty() {
                assertFalse(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when popped and is empty")
            void returnElementWhenPopped() {
                assertEquals(anElement, stack.pop());
                assertTrue(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when peeked but remains not empty")
            void returnElementWhenPeeked() {
                assertEquals(anElement, stack.peek());
                assertFalse(stack.isEmpty());
            }
        }
    }
}

参数化测试

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

利用 @ValueSource 等注解，指定入参，我们将可以使用不同的参数进行多次单元测试，而不需要每新增一个参数就新增一个单元测试，省去了很多冗余代码。
@ValueSource : 为参数化测试指定入参来源，支持八大基础类以及String类型,Class类型
@NullSource : 表示为参数化测试提供一个null的入参
@EnumSource : 表示为参数化测试提供一个枚举入参
@CsvFileSource：表示读取指定CSV文件内容作为参数化测试入参
@MethodSource：表示读取指定方法的返回值作为参数化测试入参(注意方法返回需要是一个流)

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@ParameterizedTest
@ValueSource(strings = {"one", "two", "three"})
@DisplayName("参数化测试1")
public void parameterizedTest1(String string) {
    System.out.println(string);
    Assertions.assertTrue(StringUtils.isNotBlank(string));
}

@ParameterizedTest
@MethodSource("method")    //指定方法名
@DisplayName("方法来源参数")
public void testWithExplicitLocalMethodSource(String name) {
    System.out.println(name);
    Assertions.assertNotNull(name);
}

static Stream<String> method() {
    return Stream.of("apple", "banana");
}

迁移指南

在进行迁移的时候需要注意如下的变化：

  • 注解在 org.junit.jupiter.api 包中，断言在 org.junit.jupiter.api.Assertions 类中，前置条件在 org.junit.jupiter.api.Assumptions 类中。
  • 把@Before 和@After 替换成@BeforeEach 和@AfterEach。
  • 把@BeforeClass 和@AfterClass 替换成@BeforeAll 和@AfterAll。
  • 把@Ignore 替换成@Disabled。
  • 把@Category 替换成@Tag。
  • 把@RunWith、@Rule 和@ClassRule 替换成@ExtendWith。

指标监控

SpringBoot Actuator

简介

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

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

springboot-actuator依赖图示

1.x和2.x的不同

actuator1和2的区别图示

如何使用

1
2
3
4
5
6
management:
  endpoints:
    enabled-by-default: true #暴露所有端点信息
    web:
      exposure:
        include: '*'  #以web方式暴露

可视化

https://github.com/codecentric/spring-boot-admin

Actuator Endpoint

最常使用的端点

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 integrationgraph 。需要依赖spring-integration-core。
loggers 显示和修改应用程序中日志的配置。
liquibase 显示已应用的所有Liquibase数据库迁移。需要一个或多个Liquibase组件。
metrics 显示当前应用程序的“指标”信息。
mappings 显示所有@RequestMapping路径列表。
scheduledtasks 显示应用程序中的计划任务。
sessions 允许从Spring Session支持的会话存储中检索和删除用户会话。需要使用Spring Session的基于Servlet的Web应用程序。
shutdown 使应用程序正常关闭。默认禁用。
startup 显示由ApplicationStartup收集的启动步骤数据。需要使用SpringApplication进行配置BufferingApplicationStartup。
threaddump 执行线程转储。

如果您的应用程序是Web应用程序（Spring MVC，Spring WebFlux或Jersey），则可以使用以下附加端点：

ID 描述
heapdump 返回hprof堆转储文件。
jolokia 通过HTTP暴露JMX bean（需要引入Jolokia，不适用于WebFlux）。需要引入依赖jolokia-core。
logfile 返回日志文件的内容（如果已设置logging.file.name或logging.file.path属性）。支持使用HTTPRange标头来检索部分日志文件的内容。
prometheus 以Prometheus服务器可以抓取的格式公开指标。需要依赖micrometer-registry-prometheus。

最常用的Endpoint

  • Health：监控状况
  • Metrics：运行时指标
  • Loggers：日志记录

Health Endpoint

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

重要的几点：

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

Metrics Endpoint

提供详细的、层级的、空间指标信息，这些信息可以被pull（主动推送）或者push（被动获取）方式得到；

  • 通过Metrics对接多种监控系统
  • 简化核心Metrics开发
  • 添加自定义Metrics或者扩展已有Metrics

管理Endpoints

开启与禁用Endpoints

  • 默认所有的Endpoint除过shutdown都是开启的。
  • 需要开启或者禁用某个Endpoint。配置模式为 *management.endpoint.<endpointName>.enabled = true*
1
2
3
4
management:
  endpoint:
    beans:
      enabled: true
  • 或者禁用所有的Endpoint然后手动开启指定的Endpoint
    1
    2
    3
    4
    5
    6
    7
    8
    management:
      endpoints:
        enabled-by-default: false
      endpoint:
        beans:
          enabled: true
        health:
          enabled: true

暴露Endpoints

支持的暴露方式

  • HTTP：默认只暴露health 和info Endpoint
  • JMX：默认暴露所有Endpoint
  • 除过health和info，剩下的Endpoint都应该进行保护访问。如果引入SpringSecurity，则会默认配置安全访问规则
ID JMX Web
auditevents Yes No
beans Yes No
caches Yes No
conditions Yes No
configprops Yes No
env Yes No
flyway Yes No
health Yes Yes
heapdump N/A No
httptrace Yes No
info Yes Yes
integrationgraph Yes No
jolokia N/A No
logfile N/A No
loggers Yes No
liquibase Yes No
metrics Yes No
mappings Yes No
prometheus N/A No
scheduledtasks Yes No
sessions Yes No
shutdown Yes No
startup Yes No
threaddump Yes No

定制Endpoint

定制Health信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;

@Component
public class MyHealthIndicator implements HealthIndicator {

    @Override
    public Health health() {
        int errorCode = check(); // perform some specific health check
        if (errorCode != 0) {
            return Health.down().withDetail("Error Code", errorCode).build();
        }
        return Health.up().build();
    }

}

//构建Health
Health build = Health.down()
                .withDetail("msg", "error service")
                .withDetail("code", "500")
                .withException(new RuntimeException())
                .build();
1
2
3
4
management:
    health:
      enabled: true
      show-details: always #总是显示详细信息。可显示每个模块的状态信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Component
public class MyComHealthIndicator extends AbstractHealthIndicator {
    /**
     * 真实的检查方法
     * @param builder
     * @throws Exception
     */
    @Override
    protected void doHealthCheck(Health.Builder builder) throws Exception {
        //mongodb。  获取连接进行测试
        Map<String,Object> map = new HashMap<>();
        // 检查完成
        if(1 == 2){
//            builder.up(); //健康
            builder.status(Status.UP);
            map.put("count",1);
            map.put("ms",100);
        }else {
//            builder.down();
            builder.status(Status.OUT_OF_SERVICE);
            map.put("err","连接超时");
            map.put("ms",3000);
        }
        builder.withDetail("code",100)
                .withDetails(map);
    }
}

定制info信息

常用两种方式

1、编写配置文件

1
2
3
4
5
info:
  appName: boot-admin
  version: 2.0.1
  mavenProjectName: @project.artifactId@  #使用@@可以获取maven的pom文件值
  mavenProjectVersion: @project.version@

2、编写InfoContributor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.Collections;

import org.springframework.boot.actuate.info.Info;
import org.springframework.boot.actuate.info.InfoContributor;
import org.springframework.stereotype.Component;

@Component
public class ExampleInfoContributor implements InfoContributor {
    @Override
    public void contribute(Info.Builder builder) {
        builder.withDetail("example",
                Collections.singletonMap("key", "value"));
    }
}

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

定制Metrics信息

SpringBoot支持自动适配的Metrics

  • JVM metrics, report utilization of:
  • Various memory and buffer pools
  • Statistics related to garbage collection
  • Threads utilization
  • Number of classes loaded/unloaded
  • CPU metrics
  • File descriptor metrics
  • Kafka consumer and producer metrics
  • Log4j2 metrics: record the number of events logged to Log4j2 at each level
  • Logback metrics: record the number of events logged to Logback at each level
  • Uptime metrics: report a gauge for uptime and a fixed gauge representing the application’s absolute start time
  • Tomcat metrics (server.tomcat.mbeanregistry.enabled must be set to true for all Tomcat metrics to be registered)
  • Spring Integration metrics

增加定制Metrics

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class MyService{
    Counter counter;
    public MyService(MeterRegistry meterRegistry){
         counter = meterRegistry.counter("myservice.method.running.counter");
    }

    public void hello() {
        counter.increment();
    }
}


//也可以使用下面的方式
@Bean
MeterBinder queueSize(Queue queue) {
    return (registry) -> Gauge.builder("queueSize", queue::size).register(registry);
}

定制Endpoint

1
2
3
4
5
6
7
8
9
10
11
12
@Component
@Endpoint(id = "container")
public class DockerEndpoint {
    @ReadOperation
    public Map getDockerInfo(){
        return Collections.singletonMap("info","docker started...");
    }
    @WriteOperation
    private void restartDocker(){
        System.out.println("docker restarted....");
    }
}

场景：开发ReadinessEndpoint来管理程序是否就绪，或者LivenessEndpoint来管理程序是否存活；
当然，这个也可以直接使用 https://docs.spring.io/spring-boot/docs/current/reference/html/production-ready-features.html#production-ready-kubernetes-probes

原理解析

Profile功能

为了方便多环境适配，springboot简化了prefile功能

application-profile功能

  • 默认配置文件，application.yml，任何时候都会加载
  • 指定环境配置文件，application-{env}.yml
  • 激活指定环境
    • 配置文件激活
    • 命令行激活：java -jar xxx.jar --spring.profiles.active=prod
      • 修改配置文件的任意值，命令行优先
  • 默认配置与环境配置同时生效
  • 同名项，profile配置优先（后面加载的会替换前面的）

@Profile条件装配功能

1
2
3
4
//当前bean只有在环境为 production 的时候才会被加载
@Configuration(proxyBeanMethods = false)
@Profile("production")
public class ProductionConfiguration {}

profile分组

1
2
3
4
spring.profiles.group.production[0]=proddb
spring.profiles.group.production[1]=prodmq

# 使用：--spring.profiles.active=production  激活

外部化配置

https://docs.spring.io/spring-boot/docs/current/reference/html/features.html#features.external-config

springboot可以使用以下14中方式添加配置项（按顺序）
如果存在同名项，后面的会覆盖前面的

  1. Default properties (specified by setting SpringApplication.setDefaultProperties).
  2. @PropertySource annotations on your @Configuration classes. Please note that such property sources are not added to the Environment until the application context is being refreshed. This is too late to configure certain properties such as logging.* and spring.main.* which are read before refresh begins.
  3. Config data (such as application.properties files).
  4. A RandomValuePropertySource that has properties only in random.*.
  5. OS environment variables.
  6. Java System properties (System.getProperties()).
  7. JNDI attributes from java:comp/env.
  8. ServletContext init parameters.
  9. ServletConfig init parameters.
  10. Properties from SPRING_APPLICATION_JSON (inline JSON embedded in an environment variable or system property).
  11. Command line arguments.
  12. properties attribute on your tests. Available on @SpringBootTest and the test annotations for testing a particular slice of your application.
  13. @DynamicPropertySource annotations in your tests.
  14. @TestPropertySource annotations on your tests.
  15. Devtools global settings properties in the $HOME/.config/spring-boot directory when devtools is active.

外部配置源

常用：Java属性文件、YML文件、环境变量、命令行参数

配置文件查找位置

  • classpath 根路径
  • classpath 根路径下config目录
  • java包当前目录
  • java当前目录的config目录
  • /config子目录的直接子目录（/config表示是linux环境根目录下）
    注意：springboot启动会按照上面的顺序进行加载，如果有同名项，后面的会覆盖前面的

配置文件加载顺序

1、当前jar包内部的application.properties和application.yml
2、当前jar包内部的application-{profile}.properties和application-{profile}.yml
3、引用的外部jar包的application.properties和application.yml
4、引用的外部jar包的application-{profile}.properties和application-{profile}.yml

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

自定义starter

starter启动原理

  • starter-pom 引入autoconigurer
  • autoconigurer包中配置使用 META-INF/spring.factories 中的 EnableAutoConfiguration 的值，使得项目启动记载指定的配置类
  • 编写自动配置类 xxxAutoConfiguration -> xxxProperties
    • @Configuration
    • @Conditional
    • @EnableConfigurationProperties
    • @Bean
    • ……

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

自定义starter

hello-spring-boot-starter（启动器）
hello-spring-boot-starter-autoconfigure（自动配置包）

SpringBoot原理

Spring原理【Spring注解】、SpringMVC原理、自动配置原理、SpringBoot原理

SpringBoot启动过程

  • 创建 SpringApplication
    • 保存一些信息。
    • 判定当前应用的类型。ClassUtils。Servlet
    • bootstrappers：初始启动引导器（List<Bootstrapper>）：去spring.factories文件中找 org.springframework.boot.Bootstrapper
    • 找 ApplicationContextInitializer；去spring.factories找 ApplicationContextInitializer
      • List<ApplicationContextInitializer<?>> initializers
    • 找 ApplicationListener ；应用监听器。去spring.factories找 ApplicationListener
      • List<ApplicationListener<?>> 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

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

ApplicationRunner 与 CommandLineRunner