image.png

1、SpringMVC自动配置概览

Spring Boot provides auto-configuration for Spring MVC that works well with most applications.(大多场景我们都无需自定义配置)
The auto-configuration adds the following features on top of Spring’s defaults:

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

      If you want to keep those Spring Boot MVC customizations and make more MVC customizations (interceptors, formatters, view controllers, and other features), you can add your own @Configuration class of type WebMvcConfigurer but without @EnableWebMvc. 不用@EnableWebMvc注解。使用 **@Configuration** + **WebMvcConfigurer** 自定义规则

If you want to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter, or ExceptionHandlerExceptionResolver, and still keep the Spring Boot MVC customizations, you can declare a bean of type WebMvcRegistrations and use it to provide custom instances of those components. 声明 **WebMvcRegistrations** 改变默认底层组件

If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc, or alternatively add your own @Configuration-annotated DelegatingWebMvcConfiguration as described in the Javadoc of @EnableWebMvc. 使用 **@EnableWebMvc+@Configuration+DelegatingWebMvcConfiguration 全面接管SpringMVC**

2、简单功能分析

2.1、静态资源访问

1、静态资源目录

只要静态资源放在类路径下： called /static (or /public or /resources or /META-INF/resources
访问 ： 当前项目根路径/ + 静态资源名

原理： 静态映射/**。
请求进来，先去找Controller看能不能处理。不能处理的所有请求又都交给静态资源处理器。静态资源也找不到则响应404页面

改变默认的静态资源路径

  1. spring:
  2.   mvc:
  3.   ##静态资源访问前缀
  4.     static-path-pattern: /res/**   
  6.   resources:
  7.   ##静态资源路径（文件夹）
  8.     static-locations: [classpath:/haha/]

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

2、webjar
自动映射 /webjars/**
https://www.webjars.org/

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

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

2.2、欢迎页index支持

  • 方式一：静态资源路径下 index.html

    • 可以配置静态资源路径
    • 但是不可以配置静态资源的访问前缀。否则导致 index.html不能被默认访问 ```yaml spring:

      mvc:

      static-path-pattern: /res/** 这个会导致welcome page功能失效

    resources: static-locations: [classpath:/haha/] ```

  • 方式二：controller能处理/index请求的，李彤模板引擎，和其他页面一样

2.3、自定义网站图标 Favicon

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

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

2.4、静态资源配置原理

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

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

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

  • 给容器中配了什么。

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

  • 见到@EnableConfigurationProperties({ WebMvcProperties.class, ResourceProperties.class })就知道配置文件的相关属性和某些配置类xxx进行了绑定。WebMvcProperties==spring.mvc、ResourceProperties==spring.resources


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

有参构造器所有参数的值都会从容器中确定

  1.     //有参构造器所有参数的值都会从容器中确定
  2. //ResourceProperties resourceProperties；获取和spring.resources绑定的所有的值的对象
  3. //WebMvcProperties mvcProperties 获取和spring.mvc绑定的所有的值的对象
  4. //ListableBeanFactory beanFactory Spring的beanFactory
  5. //HttpMessageConverters 找到所有的HttpMessageConverters
  6. //ResourceHandlerRegistrationCustomizer 找到 资源处理器的自定义器。=========
  7. //DispatcherServletPath  
  8. //ServletRegistrationBean   给应用注册Servlet、Filter....
  9.     public WebMvcAutoConfigurationAdapter(ResourceProperties resourceProperties, WebMvcProperties mvcProperties,
  10.                 ListableBeanFactory beanFactory, ObjectProvider<HttpMessageConverters> messageConvertersProvider,
  11.                 ObjectProvider<ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider,
  12.                 ObjectProvider<DispatcherServletPath> dispatcherServletPath,
  13.                 ObjectProvider<ServletRegistrationBean<?>> servletRegistrations) {
  14.             this.resourceProperties = resourceProperties;
  15.             this.mvcProperties = mvcProperties;
  16.             this.beanFactory = beanFactory;
  17.             this.messageConvertersProvider = messageConvertersProvider;
  18.             this.resourceHandlerRegistrationCustomizer = resourceHandlerRegistrationCustomizerProvider.getIfAvailable();
  19.             this.dispatcherServletPath = dispatcherServletPath;
  20.             this.servletRegistrations = servletRegistrations;
  21.         }

2.4.2、资源处理的默认规则

  1. @Override
  2.         public void addResourceHandlers(ResourceHandlerRegistry registry) {
  3.             if (!this.resourceProperties.isAddMappings()) {
  4.                 logger.debug("Default resource handling disabled");
  5.                 return;
  6.             }
  7.             Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
  8.             CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
  9.             //webjars的规则
  10.             if (!registry.hasMappingForPattern("/webjars/**")) {
  11.                 customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**")
  12.                         .addResourceLocations("classpath:/META-INF/resources/webjars/")
  13.                         .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
  14.             }
  16.             //
  17.             String staticPathPattern = this.mvcProperties.getStaticPathPattern();
  18.             if (!registry.hasMappingForPattern(staticPathPattern)) {
  19.                 customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern)
  20.                         .addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
  21.                         .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
  22.             }
  23.         }
  1. spring:
  2. #  mvc:
  3. #    static-path-pattern: /res/**
  5.   resources:
  6.     add-mappings: false   禁用所有静态资源规则
  1. @ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
  2. public class ResourceProperties {
  4.     private static final String[] CLASSPATH_RESOURCE_LOCATIONS = { "classpath:/META-INF/resources/",
  5.             "classpath:/resources/", "classpath:/static/", "classpath:/public/" };
  7.     /**
  8.      * Locations of static resources. Defaults to classpath:[/META-INF/resources/,
  9.      * /resources/, /static/, /public/].
  10.      */
  11.     private String[] staticLocations = CLASSPATH_RESOURCE_LOCATIONS;

2.4.3 欢迎页的处理

  1.     HandlerMapping：处理器映射。保存了每一个Handler能处理哪些请求。    
  3.     @Bean
  4.         public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext,
  5.                 FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
  6.             WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(
  7.                     new TemplateAvailabilityProviders(applicationContext), applicationContext, getWelcomePage(),
  8.                     this.mvcProperties.getStaticPathPattern());
  9.             welcomePageHandlerMapping.setInterceptors(getInterceptors(mvcConversionService, mvcResourceUrlProvider));
  10.             welcomePageHandlerMapping.setCorsConfigurations(getCorsConfigurations());
  11.             return welcomePageHandlerMapping;
  12.         }
  14.     WelcomePageHandlerMapping(TemplateAvailabilityProviders templateAvailabilityProviders,
  15.             ApplicationContext applicationContext, Optional<Resource> welcomePage, String staticPathPattern) {
  16.         if (welcomePage.isPresent() && "/**".equals(staticPathPattern)) {
  17.             //要用欢迎页功能，必须是/**
  18.             logger.info("Adding welcome page: " + welcomePage.get());
  19.             setRootViewName("forward:index.html");
  20.         }
  21.         else if (welcomeTemplateExists(templateAvailabilityProviders, applicationContext)) {
  22.             // 调用Controller  /index
  23.             logger.info("Adding welcome page template: index");
  24.             setRootViewName("index");
  25.         }
  26.     }

3、请求参数处理

3.1、请求映射

image.png

3.1.1、rest使用与原理

  • @xxxMapping；
  • Rest风格支持（使用HTTP请求方式动词来表示对资源的操作）
    • 以前：/getUser 获取用户 /deleteUser 删除用户 /editUser 修改用户 /saveUser 保存用户
    • 现在： /user GET-获取用户 DELETE-删除用户 PUT-修改用户 POST-保存用户
    • 核心Filter；HiddenHttpMethodFilter
      • 用法： 表单method=post，隐藏域 _method=put
      • SpringBoot中手动开启
    • 扩展：如何把_method 这个名字换成我们自己喜欢的。
      1. spring:
      2. mvc:
      3. hiddenmethod:
      4.  filter:
      5.    enabled: true   #开启页面表单的Rest功能
      ```html

、 //value值小写也可以 

  1. ```java
  2.     //@RequestMapping(value = "/user",method = RequestMethod.GET)
  3.     @GetMapping
  4.     public String getUser(){
  5.         return "GET-张三";
  6.     }
  8.     //@RequestMapping(value = "/user",method = RequestMethod.POST)
  9.     @PostMapping
  10.     public String saveUser(){
  11.         return "POST-张三";
  12.     }
  14.     //@RequestMapping(value = "/user",method = RequestMethod.PUT)
  15.     @PutMapping
  16.     public String putUser(){
  17.         return "PUT-张三";
  18.     }
  20.     //@RequestMapping(value = "/user",method = RequestMethod.DELETE)
  21.     @DeleteMapping
  22.     public String deleteUser(){
  23.         return "DELETE-张三";
  24.     }
  27.     @Bean
  28.     @ConditionalOnMissingBean(HiddenHttpMethodFilter.class)
  29.     @ConditionalOnProperty(prefix = "spring.mvc.hiddenmethod.filter", name = "enabled", matchIfMissing = false)
  30.     public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
  31.         return new OrderedHiddenHttpMethodFilter();
  32.     }
  35. //自定义filter，将默认的_method改为自己喜欢的_m
  36.     @Bean
  37.     public HiddenHttpMethodFilter hiddenHttpMethodFilter(){
  38.         HiddenHttpMethodFilter methodFilter = new HiddenHttpMethodFilter();
  39.         methodFilter.setMethodParam("_m");
  40.         return methodFilter;
  41.     }

Rest原理（表单提交要使用REST的时候）

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

Rest使用客户端工具，

  • 如PostMan直接发送Put、delete等方式请求，无需Filter。

3.1.2、请求映射原理

3、Web开发 - 图3
SpringMVC功能分析都从 org.springframework.web.servlet.DispatcherServlet-》doDispatch（）

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

3、Web开发 - 图4
RequestMappingHandlerMapping：保存了所有@RequestMapping 和handler的映射规则。
3、Web开发 - 图5
所有的请求映射都在HandlerMapping中。

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

3.2、普通参数与基本注解

3.2.1、注解

@PathVariable：获得请求路径上的参数，rest风格
@RequestHeader：获得请求头中的参数
@ModelAttribute：方法注释，被其注释的方法会在每个controller方法执行前被执行
参数注释，从前面的Model中提取对应名称的属性。
详见https://www.jianshu.com/p/0ec4e7afb7ed
@RequestParam：获得请求参数，一般为？后面的
@MatrixVariable：矩阵变量，需要开启该功能才能使用
image.png
@CookieValue：获得cookie中的值
@RequestBody：获取请求体中的值，仅仅针对Post表单提交请求
当然，也可以使用一个Vo对象接收多参数，系统自动帮你映射
@RequestAttribute：获得请求域中的数据。 在请求域中放置数据（后端代码）：request.setAttribute(“msg”,”请求域中的数据”)，或者直接用原生HttpServletRequest获取数据

  1. @RestController
  2. public class ParameterTestController {
  5.     //  car/2/owner/zhangsan
  6.     @GetMapping("/car/{id}/owner/{username}")
  7.     public Map<String,Object> getCar(@PathVariable("id") Integer id,
  8.                                      @PathVariable("username") String name,
  9.                                      @PathVariable Map<String,String> pv,
  10.                                      @RequestHeader("User-Agent") String userAgent,
  11.                                      @RequestHeader Map<String,String> header,
  12.                                      @RequestParam("age") Integer age,
  13.                                      @RequestParam("inters") List<String> inters,
  14.                                      @RequestParam Map<String,String> params,
  15.                                      @CookieValue("_ga") String _ga,
  16.                                      @CookieValue("_ga") Cookie cookie){
  19.         Map<String,Object> map = new HashMap<>();
  21. //        map.put("id",id);
  22. //        map.put("name",name);
  23. //        map.put("pv",pv);
  24. //        map.put("userAgent",userAgent);
  25. //        map.put("headers",header);
  26.         map.put("age",age);
  27.         map.put("inters",inters);
  28.         map.put("params",params);
  29.         map.put("_ga",_ga);
  30.         System.out.println(cookie.getName()+"===>"+cookie.getValue());
  31.         return map;
  32.     }
  35.     @PostMapping("/save")
  36.     public Map postMethod(@RequestBody String content){
  37.         Map<String,Object> map = new HashMap<>();
  38.         map.put("content",content);
  39.         return map;
  40.     }
  43.     //1、语法： 请求路径：/cars/sell;low=34;brand=byd,audi,yd
  44.     //2、SpringBoot默认是禁用了矩阵变量的功能
  45.     //      手动开启：原理。对于路径的处理。UrlPathHelper进行解析。
  46.     //              removeSemicolonContent（移除分号内容）支持矩阵变量的
  47.     //3、矩阵变量必须有url路径变量才能被解析
  48.     @GetMapping("/cars/{path}")
  49.     public Map carsSell(@MatrixVariable("low") Integer low,
  50.                         @MatrixVariable("brand") List<String> brand,
  51.                         @PathVariable("path") String path){
  52.         Map<String,Object> map = new HashMap<>();
  54.         map.put("low",low);
  55.         map.put("brand",brand);
  56.         map.put("path",path);
  57.         return map;
  58.     }
  60.     // /boss/1;age=20/2;age=10
  62.     @GetMapping("/boss/{bossId}/{empId}")
  63.     public Map boss(@MatrixVariable(value = "age",pathVar = "bossId") Integer bossAge,
  64.                     @MatrixVariable(value = "age",pathVar = "empId") Integer empAge){
  65.         Map<String,Object> map = new HashMap<>();
  67.         map.put("bossAge",bossAge);
  68.         map.put("empAge",empAge);
  69.         return map;
  71.     }
  73. }

@PathVariable(“id”) Integer id, @PathVariable(“username”) String name,
等同于@PathVariable Map pv,即可以直接用map一起接收
同样的 @RequestParam(“age”) Integer age, @RequestParam(“inters”) List inters,
等同于@RequestParam Map params,即可以直接用map一起接收

3.2.2、Servlet API：

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

ServletRequestMethodArgumentResolver 以上的部分参数

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

3.2.3、复杂参数：

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

Map map, Model model , HttpServletRequest request都是可以给request域中放数据，
request.getAttribute();

Map、Model类型的参数，会返回 mavContainer.getModel（）；—-> BindingAwareModelMap 是Model 也是Map
mavContainer.getModel(); 获取到值的
3、Web开发 - 图7
3、Web开发 - 图8
3、Web开发 - 图9

3.2.4、自定义参数对象

可以自动类型转换与格式化，可以级联封装。即采用Vo的方式封装请求体

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

3.3、参数处理原理

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

详见收藏https://www.yuque.com/atguigu/springboot/vgzmgh#ltqcb

4、数据响应与内容协商

image.png

4.1、响应JSON

4.1.1、jackson.jar+@ResponseBody

Web开发场景会自动引入Json场景，其底层引入的是JackSon依赖
3、Web开发 - 图11

这边利用返回值解析器

返回值解析器

共15个返回值解析器
3、Web开发 - 图12

  2. try {
  3.             this.returnValueHandlers.handleReturnValue(
  4.                     returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
  5.         }
  1.     @Override
  2.     public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
  3.             ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
  5.         //寻找能够处理返回值的handler
  6.         HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
  7.         if (handler == null) {
  8.             throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
  9.         }
  10.         handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
  11.     }
  1. RequestResponseBodyMethodProcessor      
  2. @Override
  3.     public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
  4.             ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
  5.             throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
  7.         mavContainer.setRequestHandled(true);
  8.         ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
  9.         ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);
  11.         // Try even with null return value. ResponseBodyAdvice could get involved.
  12.         // 使用消息转换器进行写出操作
  13.         writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
  14.     }

返回值解析器原理

3、Web开发 - 图13

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

          4.1.2、SpringMVC到底支持哪些返回值

          1. ModelAndView
          2. Model
          3. View
          4. ResponseEntity 
          5. ResponseBodyEmitter
          6. StreamingResponseBody
          7. HttpEntity
          8. HttpHeaders
          9. Callable
          10. DeferredResult
          11. ListenableFuture
          12. CompletionStage
          13. WebAsyncTask
          14. 方法有 @ModelAttribute 且为对象类型的
          15. @ResponseBody 注解 ---> RequestResponseBodyMethodProcessor；

          4.1.3、HTTPMessageConverter原理

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

3、Web开发 - 图14、
共10种Converter
0 - 只支持Byte类型的
1 - String
2 - String
3 - Resource
4 - ResourceRegion
5 - DOMSource.class \ SAXSource.class) \ StAXSource.class \StreamSource.class \Source.class
6 - MultiValueMap
7 - true
8 - true
9 - 支持注解方式xml处理的。

最终 MappingJackson2HttpMessageConverter 把对象转为JSON（利用底层的jackson的objectMapper转换的）

4.2、内容协商

根据客户端接收能力不同，返回不同媒体类型的数据。如浏览器和安卓

4.2.1、引入XML依赖

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

4.2.2、postman分别测试返回json和xml

只需要改变请求头中Accept字段。Http协议中规定的，告诉服务器本客户端可以接收的数据类型。
3、Web开发 - 图15

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

对于浏览器无法改变其请求头，ajax可以修改请求头参数。
为了方便浏览器内容协商，开启基于请求参数的内容协商功能。

  1. spring:
  2.     contentnegotiation:
  3.       favor-parameter: true  #开启请求参数内容协商模式

发请求： http://localhost:8080/test/person?format=json
http://localhost:8080/test/person?format=xml

4.2.4、内容协商原理

  • 1、判断当前响应头中是否已经有确定的媒体类型。MediaType
  • 2、获取客户端（PostMan、浏览器）支持接收的内容类型。（获取客户端Accept请求头字段）【application/xml】
    • contentNegotiationManager 内容协商管理器 默认使用基于请求头的策略
    • image.png
    • HeaderContentNegotiationStrategy 确定客户端可以接收的内容类型
    • image.png
  • 3、遍历循环所有当前系统的 MessageConverter，看谁支持操作这个对象（Person）
  • 4、找到支持操作Person的converter，把converter支持的媒体类型统计出来。
  • 5、客户端需要【application/xml】。服务端能力【10种、json、xml】
  • image.png
  • 6、进行内容协商的最佳匹配媒体类型
  • 7、用 支持 将对象转为 最佳匹配媒体类型 的converter。调用它进行转化 。

image.png

4.2.5、自定义 MessageConverter

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

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

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

5、视图解析与模板引擎

视图解析：SpringBoot默认不支持 JSP，需要引入第三方模板引擎技术实现页面渲染。
image.png
缺点：高并发情况下不适合

5.1、视图解析流程

1、目标方法处理的过程中，所有数据都会被放在 ModelAndViewContainer 里面。包括数据和视图地址
2、方法的参数是一个自定义类型对象（从请求参数中确定的），把他重新放在 ModelAndViewContainer
3、任何目标方法执行完成以后都会返回 ModelAndView（数据和视图地址）。
4、processDispatchResult 处理派发结果（页面改如何响应）

  • 1、render(mv, request, response); 进行页面渲染逻辑
    • 1、根据方法的String返回值得到 View 对象【定义了页面的渲染逻辑】
      • 1、所有的视图解析器尝试是否能根据当前返回值得到View对象
      • 2、得到了 redirect:/main.html —> Thymeleaf new RedirectView()
      • 3、ContentNegotiationViewResolver 里面包含了下面所有的视图解析器，内部还是利用下面所有视图解析器得到视图对象。
      • 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（）—->

自定义视图解析器+自定义视图； 大厂学院。

image.png
image.png

image.png

image.png

5.2、模板引擎-Thymeleaf

5.2.1、thymeleaf简介

Thymeleaf is a modern server-side Java template engine for both web and standalone environments, capable of processing HTML, XML, JavaScript, CSS and even plain text.
现代化、服务端Java模板引擎

5.2.2、基本语法

1、表达式

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

2、字面量

文本值: ‘one text’ , ‘Another one!’ ,…数字: 0 , 34 , 3.0 , 12.3 ,…布尔值: true , false
空值: null
变量： one，two，…. 变量不能有空格

3、文本操作

字符串拼接: +
变量替换: |The name is ${name}|

4、数学运算

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

5、布尔运算

运算符: and , or
一元运算: ! , not

6、比较运算

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

7、条件运算

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

8、特殊操作

无操作： _

5.2.3、设置属性值-th:attr

设置单个值

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

设置多个值

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

上面两个的替代写法

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

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

5.2.4、迭代

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

5.2.5、条件运算

  1. <a href="comments.html"
  2. th:href="@{/product/comments(prodId=${prod.id})}"
  3. th:if="${not #lists.isEmpty(prod.comments)}">view</a>1、HandlerInterceptor 接口
  1. <a href="comments.html"
  2. th:href="@{/product/comments(prodId=${prod.id})}"
  3. th:if="${not #lists.isEmpty(prod.comments)}">view</a>

6、拦截器

/
 登录检查
 1、配置好拦截器要拦截哪些请求
 2、把这些配置放在容器中**
/

6.1、编写拦截器实现HandlerInterceptor 接口

  1. public class LoginInterceptor implements HandlerInterceptor {
  3.     /**
  4.      * 目标方法执行之前
  5.      */
  6.     @Override
  7.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  9.         String requestURI = request.getRequestURI();
  10.         log.info("preHandle拦截的请求路径是{}",requestURI);
  12.         //登录检查逻辑
  13.         HttpSession session = request.getSession();
  15.         Object loginUser = session.getAttribute("loginUser");
  17.         if(loginUser != null){
  18.             //放行
  19.             return true;
  20.         }
  22.         //拦截住。未登录。跳转到登录页
  23.         request.setAttribute("msg","请先登录");
  24. //        re.sendRedirect("/");
  25.         request.getRequestDispatcher("/").forward(request,response);
  26.         return false;
  27.     }
  29.     /**
  30.      * 目标方法执行完成以后
  31.      */
  32.     @Override
  33.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
  34.         log.info("postHandle执行{}",modelAndView);
  35.     }
  37.     /**
  38.      * 页面渲染以后
  39.      */
  40.     @Override
  41.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  42.         log.info("afterCompletion执行异常{}",ex);
  43.     }
  44. }

6.2、配置拦截器

  1. 编写一个拦截器实现HandlerInterceptor接口
  2. 拦截器注册到容器中（实现WebMvcConfigurer的addInterceptors）

  3. 指定拦截规则【如果是拦截所有，静态资源也会被拦截】

    1. @Configuration
    2. public class AdminWebConfig implements WebMvcConfigurer {
    4.  @Override
    5.  public void addInterceptors(InterceptorRegistry registry) {
    6.      registry.addInterceptor(new LoginInterceptor())
    7.              .addPathPatterns("/**")  //所有请求都被拦截包括静态资源
    8.              .excludePathPatterns("/","/login","/css/**","/fonts/**","/images/**","/js/**"); //放行的请求
    9.  }
    10. }

    6.3、拦截器原理

  4. 根据当前请求，找到HandlerExecutionChain【可以处理请求的handler以及handler的所有 拦截器】

  5. 先来顺序执行 所有拦截器的 preHandle方法
    1. 如果当前拦截器prehandler返回为true。则执行下一个拦截器的preHandle
    2. 如果当前拦截器返回为false。直接 倒序执行所有已经执行了的拦截器的 afterCompletion；
  6. 如果任何一个拦截器返回false。直接跳出不执行目标方法
  7. 所有拦截器都返回True。执行目标方法
  8. 倒序执行所有拦截器的postHandle方法。
  9. 前面的步骤有任何异常都会直接倒序触发 afterCompletion
  10. 页面成功渲染完成以后，也会倒序触发 afterCompletion

3、Web开发 - 图25

7、文件上传

7.1、页面表单

  1. <form method="post" action="/upload" enctype="multipart/form-data">
  2.    //单文件上传
  3.     <input type="file" name="file"><br>
  4.     //多文件
  5.      <input type="file" name="photos" multiple><br>
  6.     <input type="submit" value="提交">
  7. </form>

7.2、文件上传代码

  1.     /**
  2.      * MultipartFile 自动封装上传过来的文件
  3.      */
  4.     @PostMapping("/upload")
  5.     public String upload(@RequestParam("email") String email,
  6.                          @RequestParam("username") String username,
  7.                          @RequestPart("headerImg") MultipartFile headerImg,
  8.                          @RequestPart("photos") MultipartFile[] photos) throws IOException {
  10.         log.info("上传的信息：email={}，username={}，headerImg={}，photos={}",
  11.                 email,username,headerImg.getSize(),photos.length);
  13.         if(!headerImg.isEmpty()){
  14.             //保存到文件服务器，OSS服务器
  15.             String originalFilename = headerImg.getOriginalFilename();
  16.             headerImg.transferTo(new File("H:\\cache\\"+originalFilename));
  17.         }
  19.         if(photos.length > 0){
  20.             for (MultipartFile photo : photos) {
  21.                 if(!photo.isEmpty()){
  22.                     String originalFilename = photo.getOriginalFilename();
  23.                     photo.transferTo(new File("H:\\cache\\"+originalFilename));
  24.                 }
  25.             }
  26.         }
  29.         return "main";
  30.     }

7.3、自动配置原理

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

  • 自动配置好了 StandardServletMultipartResolver 【文件上传解析器】
  • 原理步骤
    • 1、请求进来使用文件上传解析器判断（isMultipart）并封装（resolveMultipart，返回MultipartHttpServletRequest）文件上传请求
    • 2、参数解析器来解析请求中的文件内容封装成MultipartFile
    • 3、将request中文件信息封装为一个Map；MultiValueMap

FileCopyUtils。实现文件流的拷贝

7.4、文件上传进度实时获取显示

建议参考下面两篇文章：

  1. springboot带有进度条的上传 (特别全，分为springboot原生和commons-upload)
  2. SpringBoot 文件上传(带进度条)与下载 （考虑了性能问题）

1、导入jar包

  1.      <!-- commons-fileupload 文件上传进度条显示用-->
  2.         <dependency>
  3.             <groupId>commons-fileupload</groupId>
  4.             <artifactId>commons-fileupload</artifactId>
  5.             <version>1.4</version>
  6.         </dependency>

2、修改文件上传大小显示，默认为1MB太小

  1.   #文件上传和请求大小设置
  2.   servlet:
  3.     multipart:
  4.       max-file-size: 1024MB
  5.       max-request-size: 1024MB

3、进度包装类Progress

  1. @Data
  2. public class Progress {
  3.     private long readBytes = 0L; //到目前为止读取文件的比特数
  4.     private long allBytes = 0L;    //文件总大小
  5.     private Integer currentIndex;      //目前正在读取第几个文件
  7. }

4、多文件上传进度监听器

  1. /**文件上传进度监听*/
  2. @Component
  3. public class FileUploadProgressListener implements ProgressListener {
  5.     private HttpSession session;
  7.     public void setSession(HttpSession session){
  8.         this.session = session;
  9.         Progress p = new Progress();
  10.         session.setAttribute("uploadStatus", p);
  11.     }
  13.     /**
  14.      * 设置当前已读取文件的进度
  15.      * @param readBytes 已读的文件大小（单位byte）
  16.      * @param allBytes 文件总大小（单位byte）
  17.      * @param index 正在读取的文件序列
  18.      */
  19.     @Override
  20.     public void update(long readBytes, long allBytes, int index) {
  21.         Progress p = (Progress) session.getAttribute("uploadStatus");
  22.         p.setReadBytes(readBytes);
  23.         p.setAllBytes(allBytes);
  24.         p.setCurrentIndex(index);
  25.     }
  26. }

5、自定义文件删上传解析器，不断将文件上传进度写到session中

  1. @Component
  2. public class FileUploadProcessResolver extends CommonsMultipartResolver {
  4.     @Autowired
  5.     private FileUploadProgressListener progressListener;
  7.     @Override
  8.     protected MultipartParsingResult parseRequest(HttpServletRequest request) throws MultipartException {
  9.         String encoding = determineEncoding(request);
  10.         FileUpload fileUpload = prepareFileUpload(encoding);
  12.         progressListener.setSession(request.getSession());
  13.         fileUpload.setProgressListener(progressListener);
  14.         try {
  15.             List<FileItem> fileItemList =  ((ServletFileUpload)fileUpload).parseRequest(request);
  16.             return super.parseFileItems(fileItemList, encoding);
  17.         } catch (FileUploadException e) {
  18.             throw new MultipartException("Failed to parse multipart servlet request", e);
  19.         }
  20.     }
  21. }

6、文件上传controller

  1.     @PostMapping("/upload/progress")
  2.     @ResponseBody
  3.     public String upload(@RequestPart("file") MultipartFile file) throws IOException {
  5.         if(!file.isEmpty()){
  6.             //保存到文件服务器，OSS服务器
  7.             String originalFilename = file.getOriginalFilename();
  8.             file.transferTo(new File("D:\\desktop\\新建文件夹\\"+originalFilename));
  9.             return "success";
  10.         }
  11.         return "false";
  12.     }
  14.     /**
  15.      * 获取文件上传进度
  16.      * @param request
  17.      * @return
  18.      */
  19.     @RequestMapping("getFileUploadProgress")
  20.     @ResponseBody
  21.     public Progress getDeviceUploadProgress(HttpServletRequest request){
  22.         Progress progress = (Progress) request.getSession().getAttribute("uploadStatus");
  23.         //容易出现空指针异常，然后前端就停止了
  24.         log.info("正在上传第{}个文件，进度={}%",progress.getCurrentIndex(),100*progress.getReadBytes()/progress.getAllBytes());
  26.         return progress;
  27.     }

7、前端页面

  1.  <span>文件上传实时进度显示</span>
  2.     <!--上传成功后悔自动跳转页面，修改为用ajax上传-->
  3.     <form method="post" action="/upload/progress" enctype="multipart/form-data"
  4.           onsubmit="return uploadFile()" id="upload">
  5.         <input type="file" name="file"  id="multifile" multiple><br>
  6.         <input type="submit" value="提交">
  7.         <hr>
  8.     </form>
  1. <script src="https://cdn.bootcss.com/jquery/3.4.1/jquery.min.js"></script>
  2. <script src="https://cdn.bootcss.com/jquery.form/4.2.2/jquery.form.min.js"></script>
  4. <script>
  5.     function uploadFile() {
  6.         var fileLength = document.getElementById("multifile").files.length
  7.         console.log(fileLength)
  8.         if (fileLength === 0 )
  9.             return false;
  10.         $("#upload").ajaxSubmit(function (res){
  11.             console.log(res)
  12.         })
  14.         var interval = setInterval(function (){
  15.             $.ajax({
  16.                     url:"/getFileUploadProgress",
  17.                     context:"",
  18.                     method:"GET",//默认为GET
  19.                     sync:false, //false代表同步。默认为TRUE异步
  20.                     success:function (res) {
  21.                         console.log(100*res.readBytes/res.allBytes+"%")
  22.                         if (res.readBytes === res.allBytes && res.currentIndex === fileLength){
  23.                             clearInterval(interval)
  24.                         }
  25.                     },
  26.                     error:function (res) {
  27.                         clearInterval(interval)
  28.                     }
  29.                 }
  30.             )
  31.         },500)
  32.         return false;
  33.     }
  34. </script>

8、异常处理

8.1、默认规则

  • 默认情况下，Spring Boot提供/error处理所有错误的映射
  • 对于机器客户端，它将生成JSON响应，其中包含错误，HTTP状态和异常消息的详细信息。对于浏览器客户端，响应一个“ whitelabel”错误视图，以HTML格式呈现相同的数据
  • image.pngimage.png
  • 要对其进行自定义，添加**View**解析为**error**
  • 要完全替换默认行为，可以实现 ErrorController并注册该类型的Bean定义，或添加ErrorAttributes类型的组件以使用现有机制但替换其内容。

  • templates/error/下的4xx，5xx页面会被自动解析；

    • image.png

      8.2、定制错误处理逻辑

  • 自定义错误页

    • error/404.html error/5xx.html；有精确的错误状态码页面就匹配精确，没有就找 4xx.html；如果都没有就触发白页
  • @ControllerAdvice+@ExceptionHandler处理全局异常；底层是 ExceptionHandlerExceptionResolver 支持的
  • @ResponseStatus+自定义异常 ；底层是 ResponseStatusExceptionResolver ，把responsestatus注解的信息底层调用 response.sendError(statusCode, resolvedReason)；tomcat发送的/error
  • Spring底层的异常，如 参数类型转换异常；DefaultHandlerExceptionResolver 处理框架底层的异常。
    • response.sendError(HttpServletResponse.SC_BAD_REQUEST, ex.getMessage());
    • image.png
  • 自定义实现 HandlerExceptionResolver 处理异常；可以作为默认的全局异常处理规则
    • image.png

  • ErrorViewResolver 实现自定义处理异常；

    • response.sendError 。error请求就会转给controller
    • 你的异常没有任何人能处理。tomcat底层 response.sendError。error请求就会转给controller
    • basicErrorController 要去的页面地址是 ErrorViewResolver ；

      8.3、异常处理自动配置原理

  • ErrorMvcAutoConfiguration 自动配置异常处理规则

    • 容器中的组件：类型：DefaultErrorAttributes -> id：errorAttributes
      • public class DefaultErrorAttributes implements ErrorAttributes, HandlerExceptionResolver
      • DefaultErrorAttributes：定义错误页面中可以包含哪些数据。

image.png
image.png

  • 容器中的组件：类型：BasicErrorController —> id：basicErrorController（json+白页 适配响应）
    • 处理默认 /error 路径的请求；页面响应 new ModelAndView(“error”, model)；
    • 容器中有组件 View->id是error；（响应默认错误页）
    • 容器中放组件 BeanNameViewResolver（视图解析器）；按照返回的视图名作为组件的id去容器中找View对象。
  • 容器中的组件：类型：DefaultErrorViewResolver -> id：conventionErrorViewResolver
    • 如果发生错误，会以HTTP的状态码 作为视图页地址（viewName），找到真正的页面
    • error/404、5xx.html

如果想要返回页面；就会找error视图【StaticView】。(默认是一个白页)

image.png
写出去json
image.png
错误页

8.4、异常处理步骤流程

  1. 执行目标方法，目标方法运行期间有任何异常都会被catch、而且标志当前请求结束；并且用 dispatchException 封装异常
  2. 进入视图解析流程（页面渲染？）
  3. processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
  4. mv = processHandlerException；处理handler发生的异常，处理完成返回ModelAndView；
  • 1、遍历所有的 handlerExceptionResolvers，看谁能处理当前异常【HandlerExceptionResolver处理器异常解析器】
  • image.png
  • 2、系统默认的 异常解析器；
  • image.png
    • 1、DefaultErrorAttributes先来处理异常。把异常信息保存到rrequest域，并且返回null；
    • 2、默认没有任何人能处理异常，所以异常会被抛出
      • 1、如果没有任何人能处理最终底层就会发送 /error 请求。会被底层的BasicErrorController处理
      • 2、解析错误视图；遍历所有的 ErrorViewResolver 看谁能解析。
      • image.png
      • 3、默认的 DefaultErrorViewResolver ,作用是把响应状态码作为错误页的地址，error/500.html
      • 4、模板引擎最终响应这个页面 error/500.html

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

        概念上讲，Filter是Servlet的，Intercepter是SpringBoot的

        1、使用Servlet API

        @ServletComponentScan(basePackages = “com.atguigu.admin”) :指定原生Servlet组件都放在那里
        加载配置类上，最好是启动类上

@WebServlet(urlPatterns = “/my”)：效果：直接响应，没有经过Spring的拦截器？
加在Servlet类上，该类实现了HttpServlet

@WebFilter(urlPatterns={“/css/*”,“/images/*”}) 用来拦截Servlet
加在Filter类上，该类实现了Filter

@WebListener 监听器，可监听项目初始化和结束事件，进而执行某些操作
加在监听器类上，该类实现了 ServletContextListener

推荐可以这种方式；

扩展：DispatchServlet 如何注册进来

  • 容器中自动配置了 DispatcherServlet 属性绑定到 WebMvcProperties；对应的配置文件配置项是 spring.mvc。
  • 通过 ServletRegistrationBean 把 DispatcherServlet 配置进来。
  • 默认映射的是 / 路径。

image.png
Tomcat-Servlet；
多个Servlet都能处理到同一层路径，精确优选原则
A： /my/
B： /my/1

2、使用RegistrationBean

Servle tRegistrationBean, FilterRegistrationBean, and ServletListenerRegistrationBean

  1. @Configuration
  2. public class MyRegistConfig {
  4.     @Bean
  5.     public ServletRegistrationBean myServlet(){
  6.         MyServlet myServlet = new MyServlet();
  8.         return new ServletRegistrationBean(myServlet,"/my","/my02");
  9.     }
  12.     @Bean
  13.     public FilterRegistrationBean myFilter(){
  15.         MyFilter myFilter = new MyFilter();
  16. //        return new FilterRegistrationBean(myFilter,myServlet());
  17.         FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(myFilter);
  18.         filterRegistrationBean.setUrlPatterns(Arrays.asList("/my","/css/*"));
  19.         return filterRegistrationBean;
  20.     }
  22.     @Bean
  23.     public ServletListenerRegistrationBean myListener(){
  24.         MySwervletContextListener mySwervletContextListener = new MySwervletContextListener();
  25.         return new ServletListenerRegistrationBean(mySwervletContextListener);
  26.     }
  27. }


10、嵌入式Web 容器

10.1、切换嵌入式Servlet容器

  • 默认支持的webServer
    • Tomcat, Jetty, or Undertow
    • ServletWebServerApplicationContext 容器启动寻找ServletWebServerFactory 并引导创建服务器
  • 切换服务器

image.png

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-web</artifactId>
  4.     <exclusions>
  5.         <exclusion>
  6.             <groupId>org.springframework.boot</groupId>
  7.             <artifactId>spring-boot-starter-tomcat</artifactId>
  8.         </exclusion>
  9.     </exclusions>
  10. </dependency>
  • 原理
    • SpringBoot应用启动发现当前是Web应用。web场景包-导入tomcat
    • web应用会创建一个web版的ioc容器 ServletWebServerApplicationContext
    • ServletWebServerApplicationContext 启动的时候寻找 **ServletWebServerFactory**``（Servlet 的web服务器工厂---> Servlet 的web服务器）
    • SpringBoot底层默认有很多的WebServer工厂；TomcatServletWebServerFactory, JettyServletWebServerFactory, or UndertowServletWebServerFactory
    • 底层直接会有一个自动配置类。ServletWebServerFactoryAutoConfiguration
    • ServletWebServerFactoryAutoConfiguration导入了ServletWebServerFactoryConfiguration（配置类）
    • ServletWebServerFactoryConfiguration 配置类 根据动态判断系统中到底导入了那个Web服务器的包。（默认是web-starter导入tomcat包），容器中就有 TomcatServletWebServerFactory
    • TomcatServletWebServerFactory 创建出Tomcat服务器并启动；TomcatWebServer 的构造器拥有初始化方法initialize---this.tomcat.start();
    • 内嵌服务器，就是手动把启动服务器的代码调用（tomcat核心jar包存在）

10.2、定制Servlet容器

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

xxxxxCustomizer：定制化器，可以改变xxxx的默认规则

  1. @Component
  2. public class CustomizationBean implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
  4.     @Override
  5.     public void customize(ConfigurableServletWebServerFactory server) {
  6.         server.setPort(9000);
  7.     }
  8. }

11、定制化原理

11.1、定制化的常见方式

  • 修改配置文件；
  • xxxxxCustomizer；
  • 编写自定义的配置类 xxxConfiguration；+ @Bean替换、增加容器中默认组件；视图解析器

  • Web应用 编写一个配置类实现 WebMvcConfigurer 即可定制化web功能；+ @Bean给容器中再扩展一些组件

    1. @Configuration
    2. public class AdminWebConfig implements WebMvcConfigurer

  • @EnableWebMvc + WebMvcConfigurer —— @Bean 可以全面接管SpringMVC，所有规则全部自己重新配置； 实现定制和扩展功能

    • 原理
    • 1、WebMvcAutoConfiguration 默认的SpringMVC的自动配置功能类。静态资源、欢迎页…..
    • 2、一旦使用 @EnableWebMvc 、。会 @Import(DelegatingWebMvcConfiguration.class)
    • 3、DelegatingWebMvcConfiguration 的 作用，只保证SpringMVC最基本的使用
      • 把所有系统中的 WebMvcConfigurer 拿过来。所有功能的定制都是这些 WebMvcConfigurer 合起来一起生效
      • 自动配置了一些非常底层的组件。RequestMappingHandlerMapping、这些组件依赖的组件都是从容器中获取
      • public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport
    • 4、WebMvcAutoConfiguration 里面的配置要能生效 必须 @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
    • 5、@EnableWebMvc 导致了 WebMvcAutoConfiguration 没有生效。

      11.2、原理分析套路

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