5、SpringMVC自动配置概览

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页面

2、静态资源访问前缀和静态资源目录

默认无前缀: **/****.

我们可如下配置static-path-pattern修改其前缀:

spring:
  mvc:
    static-path-pattern: /res/**

访问路径:当前项目 + static-path-pattern + 静态资源名

我们可通过static-locations改变默认的静态资源路径(目录)

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

这样我们访问静态资源将从 resources/haha/ 下进行查找.

3、webjar

SpringBoot 中将一些静态资源达成了Jar包,通过导入依赖,我们可以使用相关的静态资源.

自动映射 /​​webjars​​/**

可通过https://www.webjars.org/选取需要的静态资源jar包.

举例:

<dependency>
            <groupId>org.webjars</groupId>
            <artifactId>jquery</artifactId>
            <version>3.5.1</version>
        </dependency>

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

2.2、欢迎页支持

• 静态资源路径下 index.html

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

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

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

• controller能处理/index

2.3、自定义 Favicon

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

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

Ctrl+shift+r/Ctrl+F5:强制刷新页面

2.4、静态资源配置原理

• SpringBoot启动默认加载 xxxAutoConfiguration 类（自动配置类）
• SpringMVC功能的自动配置类 WebMvcAutoConfiguration，生效

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class})
@ConditionalOnMissingBean({WebMvcConfigurationSupport.class})
@AutoConfigureOrder(-2147483638)
@AutoConfigureAfter({DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class, ValidationAutoConfiguration.class})
public class WebMvcAutoConfiguration {
}

• 给容器中配了什么。

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

• 配置文件的相关属性和xxx进行了绑定。WebMvcProperties==spring.mvc、ResourceProperties==spring.resources

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

//有参构造器所有参数的值都会从容器中确定
//ResourceProperties resourceProperties；获取和spring.resources绑定的所有的值的对象
//WebMvcProperties mvcProperties 获取和spring.mvc绑定的所有的值的对象
//ListableBeanFactory beanFactory Spring的beanFactory
//HttpMessageConverters 找到所有的HttpMessageConverters
//ResourceHandlerRegistrationCustomizer 找到 资源处理器的自定义器。=========
//DispatcherServletPath  
//ServletRegistrationBean   给应用注册Servlet、Filter....
  public WebMvcAutoConfigurationAdapter(ResourceProperties resourceProperties, WebMvcProperties mvcProperties,
        ListableBeanFactory beanFactory, ObjectProvider<HttpMessageConverters> messageConvertersProvider,
        ObjectProvider<ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider,
        ObjectProvider<DispatcherServletPath> dispatcherServletPath,
        ObjectProvider<ServletRegistrationBean<?>> servletRegistrations) {
      this.resourceProperties = resourceProperties;
      this.mvcProperties = mvcProperties;
      this.beanFactory = beanFactory;
      this.messageConvertersProvider = messageConvertersProvider;
      this.resourceHandlerRegistrationCustomizer = resourceHandlerRegistrationCustomizerProvider.getIfAvailable();
      this.dispatcherServletPath = dispatcherServletPath;
      this.servletRegistrations = servletRegistrations;
    }

2、资源处理的默认规则

#########################addResourceHandlers()方法#################################  
@Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
      if (!this.resourceProperties.isAddMappings()) {//判断是否禁用静态资源
        logger.debug("Default resource handling disabled");//如果禁用则到此结束.
        return;
      }
      Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
      CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
      //访问webjars的规则
            if (!registry.hasMappingForPattern("/webjars/**")) {
                //如果是,则从/META-INF/resources/webjars/进行寻找静态资源.
    customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**")
            .addResourceLocations("classpath:/META-INF/resources/webjars/")
            .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));//按照设置的时间缓存
      } 
            
            //其他静态资源的规则
      String staticPathPattern = this.mvcProperties.getStaticPathPattern();//获取获取静态资源路径static-path-pattern的值.
      if (!registry.hasMappingForPattern(staticPathPattern)) {
        customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern)
            .addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
            .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
      }//调用getResourceLocations(),从staticLocations下找静态资源
    }

#########################################################################################
spring:
  resources:
    add-mappings: false   false:禁用所有静态资源规则
    cache:1100        静态资源可以存活多长时间   
        
@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties {

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

3、欢迎页的处理规则

//HandlerMapping：处理器映射。保存了每一个Handler能处理哪些请求。  
  @Bean
    public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext,
        FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
      WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(
          new TemplateAvailabilityProviders(applicationContext), applicationContext, getWelcomePage(),
          this.mvcProperties.getStaticPathPattern());
      welcomePageHandlerMapping.setInterceptors(getInterceptors(mvcConversionService, mvcResourceUrlProvider));
      welcomePageHandlerMapping.setCorsConfigurations(getCorsConfigurations());
      return welcomePageHandlerMapping;
    }
#######################WelcomePageHandlerMapping()构造方法.#############################
  WelcomePageHandlerMapping(TemplateAvailabilityProviders templateAvailabilityProviders,
      ApplicationContext applicationContext, Optional<Resource> welcomePage, String staticPathPattern) {
      //如果欢迎页存在,并且staticPathPattern是默认的,则进行转发.
    if (welcomePage.isPresent() && "/**".equals(staticPathPattern)) {
            //要用欢迎页功能，必须是/**
      logger.info("Adding welcome page: " + welcomePage.get());
      setRootViewName("forward:index.html");
    }
    else if (welcomeTemplateExists(templateAvailabilityProviders, applicationContext)) {
            // 否则调用Controller,看谁能处理,就作为一个欢迎页.  /index
      logger.info("Adding welcome page template: index");
      setRootViewName("index");  
    }
  }

4、favicon

如果并且staticPathPattern是默认的/**,则取资源路径下寻找favicon.jpg,如果有则使用.如果不是默认的配置,则该规则失效.

3、请求参数处理

0、请求映射

1、rest使用与原理

• Rest风格支持（使用HTTP请求方式动词来表示对资源的操作）

• 以前：/getUser获取用户/deleteUser删除用户/editUser修改用户/saveUser保存用户
• 现在： /userGET- 获取用户DELETE-删除用户PUT-修改用户POST-保存用户
• 核心Filter:HiddenHttpMethodFilter

• 用法： 表单method=post，隐藏域_method=put
• SpringBoot中手动开启:spring.mvc.formcontent.filter.enable=true

MethodController################################## @RestController
public class MethodController {
    @RequestMapping(value = "/user",method = RequestMethod.GET)
    public String getUser(){
        return "GET-张三";
    }

    @RequestMapping(value = "/user",method = RequestMethod.POST)
    public String saveUser(){
        return "POST-张三";
    }


    @RequestMapping(value = "/user",method = RequestMethod.PUT)
    public String putUser(){
        return "PUT-张三";
    }

    @RequestMapping(value = "/user",method = RequestMethod.DELETE)
    public String deleteUser(){
        return "DELETE-张三";
    }
}

#######################################yaml配置###########################################
spring:
  mvc:
    hiddenmethod:
      filter:
        enabled: true   #开启页面表单的Rest功能

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

• 表单提交会带上**_method=PUT**
• 请求过来被HiddenHttpMethodFilter拦截

• 请求是否正常，并且是POST

• 获取到**_method**的值。
• 兼容以下请求；PUT.DELETE.PATCH
• 原生request（post），包装模式requesWrapper重写了getMethod方法，返回的是传入的值。
• 过滤器链放行的时候用wrapper(被包装后的request)。以后的方法调用getMethod是调用 requestWrapper的。

###############################原理#####################################################
################SpringMvcAutoConfiguration#############################################    
    @Bean
    @ConditionalOnMissingBean(FormContentFilter.class)//OrderedFormContentFilter继承FormContentFilter    没有FormContentFilter 就创建一个.
    @ConditionalOnProperty(prefix = "spring.mvc.formcontent.filter", name = "enabled", matchIfMissing = true)
    public OrderedFormContentFilter formContentFilter() {
        return new OrderedFormContentFilter();
    }
    

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        HttpServletRequest requestToUse = request;
//判断类型是否为post类型
        if ("POST".equals(request.getMethod()) && request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) == null) {
        //获取_method的值.
            String paramValue = request.getParameter(this.methodParam);
            if (StringUtils.hasLength(paramValue)) {
                String method = paramValue.toUpperCase(Locale.ENGLISH);
                if (ALLOWED_METHODS.contains(method)) {
                    requestToUse = new HttpMethodRequestWrapper(request, method);
                }
            }
        }

        filterChain.doFilter(requestToUse, response);
    }

扩展：如何把_method 这个名字换成我们自己喜欢的。

@Configuration
public class WebConfig {
    //自定义Bean
    @Bean
    public HiddenHttpMethodFilter hiddenHttpMethodFilter(){
        HiddenHttpMethodFilter methodFilter = new HiddenHttpMethodFilter();//默认methodParam为_method
        methodFilter.setMethodParam("_m");//我们调用set方法,起名进行覆盖.
        return methodFilter;
    }
}

Rest使用客户端工具

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

注:我们还可以使用@PostMapping,@DeleteMapping,@PutMapping直接发送对应的注解.

2、请求映射原理

SpringMVC功能分析都从 org.springframework.web.servlet.DispatcherServlet-》doDispatch()

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);
                
                //HandlerMapping：处理器映射。/xxx->>xxxx
                }
                ...
 }               
 ##########################################getHandler################################               
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    if (this.handlerMappings != null) {//handlerMappings:处理器映射,一共五个.
      for (HandlerMapping mapping : this.handlerMappings) {
        HandlerExecutionChain handler = mapping.getHandler(request);
        if (handler != null) {
          return handler;
        }
      }
    }
    return null;
  }

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

总结:

• 所有的请求映射都在HandlerMapping中。
• SpringBoot自动配置欢迎页的 WelcomePageHandlerMapping 。访问 /能访问到index.html；
• SpringBoot自动配置了默认 的 RequestMappingHandlerMapping
• 请求进来，挨个尝试所有的HandlerMapping看是否有请求信息。

• 如果有就找到这个请求对应的handler
• 如果没有就是下一个 HandlerMapping

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

1、普通参数与基本注解

1.1、注解：

@PathVariable

• 如果有参数,获取请求路径中参数的值.
• 如果无参数,且后面跟Map<String,String>类型的.将获取路径中所有参数的值并存放到该Map中.

@GetMapping("/car/{id}/owner/{username}")
    public Map<String,Object> getCar(@PathVariable("id") Integer id,@PathVariable("username") String name,@PathVariable Map<String,String> pv){
        Map <String, Object> map = new HashMap <>();
        map.put("id", id);
        map.put("name", name);
        map.put("pv", pv);
        return  map;
    }
##########################运行结果############################################
 {"pv":{"id":"3","username":"zhangsan"},"name":"zhangsan","id":3}

@RequestHeader

• 如果有参数,获取的是指定请求头的值.
• 无参数,且后跟类型为Map<String,String>,获取所有请求头的键和值.

@GetMapping("/car")
    public Map<String,Object> getCar(@RequestHeader("User-Agent") String userAgent,@RequestHeader Map<String,String> headers){

        Map <String, Object> map = new HashMap <>();
        map.put("userAgent", userAgent);
        map.put("headers", headers);
        return  map;
    }

@RequestParam

@GetMapping("/car")
    public Map<String,Object> getCar(@RequestParam("age") Integer age, @RequestParam("inters") List<String> inters,
                                     @RequestParam Map<String,String> params){
        Map <String, String> map = new HashMap <>();
        map.put("age",age);
        map.put("inters", inters);
        map.put("params", params);
        return  map;
    }
##############################################################################
 {"inters":["football","game"],"params":{"age":"18","inters":"football"},"age":18}

@CookieValue

• 如果有参数,获取的是指定Cookie的值.
• 有参数,后面跟的是一个Cookie类型, 将Cookie值保存到另外一个Cookie中.

@RequestBody

获取Post请求的请求体.

@PostMapping("/save")
    public Map<String,Object> postMethod(@RequestBody String content){
        Map <String, Object> map = new HashMap <>();
        map.put("content", content);
        return map;
    }

#################################################################################
{"content":"userName=zhagnsan&email=1456"}

@RequestAttribute

@Controller
public class RequestController {
    @GetMapping("/goto")
    public String goToPage(HttpServletRequest request){
        request.setAttribute("msg","成功了...");
        request.setAttribute("code",200);
        return "forward:/success"; //转发到success的请求
    }

    @ResponseBody
    @GetMapping("/success")
    public Map success(@RequestAttribute("msg")String msg,@RequestAttribute("code") Integer code,HttpServletRequest request){
        Map <String, Object> map = new HashMap <>();
        Object msg1 = request.getAttribute("msg");
        map.put("reqMathod_msg", msg1);
        map.put("anno_msg", msg);
        map.put("code", code);
        return map;
    }


}
####################################################################################
{"reqMathod_msg":"成功了...","code":200,"anno_msg":"成功了..."}

@MatrixVariable

传统方式获取​​/cars/{path}?xxx=xxx&aaa=ccc queryString​​ 中请求参数的数据使用@RequestParam；

在页面开发，cookie禁用了，session里面的内容怎么使用?

未被禁用时:

• 正向:每次请求时携带cookie,cookie中存放着jsessionid ,通过它这样可以找到指定的session.
• 逆向**:session.set(a,b)—> jsessionid —> cookie ----> 每次发请求携带**。
  所以一旦cookie被禁用,session便无法找到了.

矩阵变量 😗*/cars/sell;low=34;brand=byd,audi,yd ; ** /cars/sell;low=34;brand=byd;brand=audi;brand=yd；

解决办法:url重写：/abc;jsesssionid=xxxx 把cookie的值使用矩阵变量的方式进行传递.

,实现WebMvcConfigurer接口#########
@Configuration
public class WebConfig implements WebMvcConfigurer {
   
    //其实就是重写该方法,然后该方法里面的方法就会生效代替默认的.
    //JDK8及其之后接口方法有了默认实现,所以我们只需要重写自己想要的即可.
    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        UrlPathHelper urlPathHelper = new UrlPathHelper();
        //设置成false:不移除;后面的内容,矩阵变量功能开始生效.
        urlPathHelper.setRemoveSemicolonContent(false);
        configurer.setUrlPathHelper(urlPathHelper);
    }
}

############################################第二种方式,注册一个WebMvcConfigurer#############
@Configuration
public class WebConfig2 {
    @Bean
    public WebMvcConfigurer webMvcConfigurer(){
        return new WebMvcConfigurer() {
            @Override
            public void configurePathMatch(PathMatchConfigurer configurer) {
                UrlPathHelper urlPathHelper = new UrlPathHelper();
                urlPathHelper.setRemoveSemicolonContent(false);
                configurer.setUrlPathHelper(urlPathHelper);
            }
        };
    }
}
############################################Controller###################################
  //1、语法：请求路径：/cars/sell;low=34;brand=byd,audi,yd;     
       //          或/cars/sell;low=34;brand=byd;brand=audi;brand=yd;
    //2、SpringBoot默认是禁用了矩阵变量的功能
    //      手动开启：原理:
    //      对于路径的处理,UrlPathHelper进行解析。
    //      removeSemicolonContent（true移除分号后面的内容）:flase ,使用矩阵变量.
    //3.矩阵变量必须绑定在路径变量上才可以被解析,所以要写@GetMapping("cars/{path}"),而非@GetMapping("cars/sell")   
   

    @GetMapping("cars/{path}")
    public Map carsSell(@MatrixVariable("low") Integer low,@MatrixVariable("brand") List<String> brand,@PathVariable("path") String path){//path:真正的访问路径
        Map <Object, Object> map = new HashMap <>();
        map.put("low",low);
        map.put("brand", brand);
        map.put("path", path);
        return map;
    }


######################################运行结果1#######################################
{"path":"sell","low":34,"brand":["byd","audi","yd"]} 
可以看出真正的路径仍然是sell,不包括后面的矩阵变量.
    
  //当矩阵变量重复时,如何获取.
    // /boss/1;age=20/2;age=10
    @GetMapping("/boss/{bossId}/{empId}")
    public Map boss(@MatrixVariable(value = "age",pathVar = "bossId") Integer bossAge,@MatrixVariable(value = "age",pathVar = "empId") Integer empAge){
        Map <Object, Object> map = new HashMap <>();
        map.put("bossAge", bossAge);
        map.put("empAge", empAge);
        return map;
    }    

####################################运行结果2############################################
  {"bossAge":20,"empAge":10}

1.2、Servlet API：

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

ServletRequestMethodArgumentResolver 以上的部分参数

@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) ||
        InputStream.class.isAssignableFrom(paramType) ||
        Reader.class.isAssignableFrom(paramType) ||
        HttpMethod.class == paramType ||
        Locale.class == paramType ||
        TimeZone.class == paramType ||
        ZoneId.class == paramType);
  }

1.3、复杂参数：

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

TestController#######################
 @GetMapping("/params")
    public String testParame(Map<String,Object> map, Model model,
                             HttpServletRequest request,
                             HttpServletResponse response){
        map.put("hello", "world666");
        model.addAttribute("wordl", "hello666");
        request.setAttribute("message","HelloWorld");
        Cookie cookie = new Cookie("c1", "v1");
        response.addCookie(cookie);
        return "forward:/success";
    }

    @ResponseBody
    @GetMapping("/success")
    public Map success(@RequestAttribute(value = "msg",required = false)String msg,@RequestAttribute(value = "code",required = false) Integer code,HttpServletRequest request){
        Map <String, Object> map = new HashMap <>();
        Object msg1 = request.getAttribute("msg");
        Object hello = request.getAttribute("hello");
        Object world = request.getAttribute("world");
        Object message = request.getAttribute("message");
        map.put("reqMathod_msg", msg1);
        map.put("anno_msg", msg);
        map.put("code", code);
        map.put("hello", hello);
        map.put("world", world);
        map.put("message", message);
        return map;
    }
###############################################运行结果################################
{"reqMathod_msg":null,"code":null,"world":null,"hello":"world666","message":"HelloWorld","anno_msg":null}

结果分析:Map<String,Object> map, Model model, HttpServletRequest request 都是可以给request域中放数据，
**最终可通过request.getAttribute()**来获取

• 当参数是Map时,HandlerMethodArgumentResolver为MapMethodProcessor;当参数是Model时,HMAResolver为ModelMethodProcessor;
• 通过Debug5.2 可知,Map、Model类型的参数都会通过 mavContainer.getModel()==>>BindingAwareModelMap 既 是Model 也是Map

###############################ModelAndViewContainer#####################################
public class ModelAndViewContainer {

   private boolean ignoreDefaultModelOnRedirect = false;

   @Nullable
   private Object view;

   private final ModelMap defaultModel = new BindingAwareModelMap();
   public ModelMap getModel() {
      if (useDefaultModel()) {
         return this.defaultModel;
      }
      else {
         if (this.redirectModel == null) {
            this.redirectModel = new ModelMap();
         }
         return this.redirectModel;
      }
   }
###########################################BindingAwareModelMap体系#######################   
public class BindingAwareModelMap extends ExtendedModelMap {}
public class ExtendedModelMap extends ModelMap implements Model {}

第一个和第二个参数是一样的.本质上是一个对象.

Model 和Map被放在ModelAndViewContainer中.

2、自定义对象参数

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

##################################index.html###########################################
/**
 *     姓名： <input name="userName"/> <br/>
 *     年龄： <input name="age"/> <br/>
 *     生日： <input name="birth"/> <br/>
 *     宠物姓名：<input name="pet.name"/><br/>
 *     宠物年龄：<input name="pet.age"/>
 */
###################################################Person和Pet########################    
@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;

}
###########################################ParameterTestController#######################
    /**
     * 数据绑定:页面提交的请求数据(GET/POST)都可以和对象属性进行绑定.
     * @param person
     * @return
     */
    @PostMapping("/saveuser")
    public Person saveuser(Person person){
        return person;
    }
######################################################运行结果#######################
    {"userName":"zhangsan","birth":"2019-12-09T16:00:00.000+00:00","age":18,"pet":{"name":"啊猫","age":"5"}

POJO封装过程

依赖于ServletModelAttributeMethodProcessor

3、参数处理原理

• HandlerMapping中找到能处理请求的Handler（里面保存了浏览器的请求路径与Controller中对应method的信息.）==============>getHandler()
• 为当前Handler 找一个适配器 HandlerAdapter:RequestMappingHandlerAdapter
  适配器作用:执行目标方法并确定方法参数的每一个值

0 - 支持方法上标注@RequestMapping (咱们使用的就是这个)

1 - 支持函数式编程的

…

1、HandlerAdapter

public interface HandlerAdapter {
  //支持哪些方法.
  boolean supports(Object handler);

  //如果支持进行处理的方法.
  @Nullable
  ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;


  @Deprecated
  long getLastModified(HttpServletRequest request, Object handler);

}

2、执行目标方法

// Actually invoke the handler.
//DispatcherServlet -- doDispatch()
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
//==>进入RequestMappingHandler的handleInternal()方法. 里面也出现了 参数解析器和返回值解析器...
    
mav = invokeHandlerMethod(request, response, handlerMethod); //执行目标方法

invocableMethod.invokeAndHandle(webRequest, mavContainer);//执行..
//再次进入ServletInvocableHandlerMethod的invokeAndHandle
//  真正的执行目标方法.
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
//获取方法的参数值  原理在下面...
Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);

doInvoke(args);//开始执行..底层就是反射技术

3、参数解析器-HandlerMethodArgumentResolver

-----------------------------------------------------------------------位于RequestMappingHandler的handleInternal中

作用:确定将要执行的目标方法的每一个参数的值是什么;

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

HandlerMethodArgumentResolver本质:— 一个接口

• 当前解析器是否支持解析这种参数
• 支持就调用 resolveArgument

4、返回值处理器

-----------------------------------------------------------------------位于RequestMappingHandler的handleInternal中

作用:确定方法可以写的返回值类型.比如:ModelAndView、Model、View、ResponseBody…

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

============InvocableHandlerMethod==========================
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++) {
            //获取第i个参数..
            MethodParameter parameter = parameters[i];
            parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
            args[i] = findProvidedArgument(parameter, providedArgs);
            if (args[i] != null) {
                continue;
            }
            //判断当前解析器是否支持这个参数类型.  底层原理 5.1
            if (!this.resolvers.supportsParameter(parameter)) {
                throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
            }
            try {
                // 利用上面的参数解析器进行解析并存入 args数组中.  底层原理5.2 
                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;
    }

5.1、挨个判断所有参数解析器那个支持解析这个参数

@Nullable
    private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) 
    {
        //从参数解析缓存中找到该参数的 解析器.
        HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
        if (result == null) {//如果没找到
            //遍历所有的参数解析器25种
            for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
                if (resolver.supportsParameter(parameter)) {//如果该解析器支持该参数.
                    result = resolver;
                    this.argumentResolverCache.put(parameter, result);//将其存入到缓存中,这样下次可以直接从缓存中获取, 不用再进行循环获取了.  牛掰了..这操作. 所以通常第一次访问会比较慢,之后就很快了.
                    break;
                }
            }
        }
        return result;
    }

5.2、利用参数解析器解析这个参数的值

调用各自 HandlerMethodArgumentResolver 的 resolveArgument 方法即可

底层原理

args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);==>进入resolveArgument()
resolveArgument(parameter, mavContainer, webRequest, binderFactory);==>在进入
mavContainer.getModel()

5.3、自定义类型参数 封装POJO

ServletModelAttributeMethodProcessor 这个参数处理器支持

是否为简单类型。

############################################当参数处理器是:ServletModelAttributeMethodProcessor时,  resolvers.supportsParameter(parameter)的底层判断原理########
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) || //是不是Number类型
        Date.class.isAssignableFrom(type) ||
        Temporal.class.isAssignableFrom(type) ||
        URI.class == type ||
        URL.class == type ||
        Locale.class == type ||
        Class.class == type));
  }
##########################################resolveArgument###############################  
@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 {
      //创建一个空的person对象..
        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.
      //数据绑定器
      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;
  }

WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);

WebDataBinder :web数据绑定器，将请求参数的值绑定到指定的JavaBean里面

原理:WebDataBinder 利用它里面的转换器 Converters 将请求数据转成指定的数据类型。再次封装到JavaBean中 ,如String->Integer,String0->Date的转换器…

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

Converter的总接口: @FunctionalInterface public interface Converter<S, T>

WebDataBinder

数据类型转换器Converters

未来我们可以给WebDataBinder里面放自己的Converter；

private static final class StringToNumber<T extends Number> implements Converter<String, T>

自定义 Converter

//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>() {

                    @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;
                    }
                });
            }
        };
    }

6、目标方法执行完成

将所有的数据都放在 ModelAndViewContainer；包含要去的页面地址View。还包含Model数据。

7、处理派发结果

processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);

InternalResourceView：
@Override
  protected void renderMergedOutputModel(
      Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {

    // Expose the model object as request attributes.
    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);
    }
  }

暴露模型作为请求域属性

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);
            }
        });
    }

4. 自定义类型转换器

当提交的参数和要封装的属性名称一致时,SpringBoot回为我们自动封装,但当不一致时,我们应该自己定义类型转换器.Converter <String, T>

##################################index.html###########################################
/**
 *     姓名： <input name="userName"/> <br/>
 *     年龄： <input name="age"/> <br/>
 *     生日： <input name="birth"/> <br/>
 *     宠物： <input name="pet" value="啊猫,3"/>
 */
###################################################Person和Pet########################    
@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;

}
###########################################ParameterTestController#######################
    /**
     * 数据绑定:页面提交的请求数据(GET/POST)都可以和对象属性进行绑定.
     * @param person
     * @return
     */
    @PostMapping("/saveuser")
    public Person saveuser(Person person){
        return person;
    }
######################################WebConfig########################################
    @Configuration
public class WebConfig3 {
    @Bean
    public WebMvcConfigurer webMvcConfigurer(){
        return new WebMvcConfigurer() {
            //添加格式转换器
            @Override
            public void addFormatters(FormatterRegistry registry) {
                registry.addConverter(new Converter <String, Pet>() {

                    @SuppressWarnings("deprecation")
                    @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(split[1]);
                            return pet;
                        }
                        return null;
                    }
                });
            }
        };
    }
}
######################################################运行结果#######################
{"userName":"zhangsan","birth":"2019-12-09T16:00:00.000+00:00","age":18,"pet":{"name":"啊猫","age":"3"}}

这样在数据进行转换时会用125个转换器…在转换时会使用我们定义的那个…

4、数据响应与内容协商

1、响应JSON

1.1、jackson.jar+@ResponseBody

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
<!--web场景自动引入了json场景-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-json</artifactId>
      <version>2.3.4.RELEASE</version>
      <scope>compile</scope>
    </dependency>

<!--底层主要依赖这些jar-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.12.4</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.datatype</groupId>
      <artifactId>jackson-datatype-jdk8</artifactId>
      <version>2.12.4</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.datatype</groupId>
      <artifactId>jackson-datatype-jsr310</artifactId>
      <version>2.12.4</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.module</groupId>
      <artifactId>jackson-module-parameter-names</artifactId>
      <version>2.12.4</version>
      <scope>compile</scope>
    </dependency>

测试代码:

@Controller
public class ResponseTestController {
    @ResponseBody //利用返回值处理器里面的消息转换器进行处理
    @GetMapping(value = "test/person")
    public Person getPerson(){
        Person person = new Person();
        person.setAge(28);
        person.setBirth(new Date());
        person.setUserName("zhangsan");
        return person;
    }
}

给前端自动返回json数据；

1、返回值解析器

######################################invokeAndHandle()方法############################
// 真正的执行方法  returnValue:返回的Person类型/Object类型
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);

// 处理返回值.
this.returnValueHandlers.handleReturnValue(
            returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
##############################进入handleReturnValue()####################################
    @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);
    }
#######################selectHandler()############################################
@Nullable
    private HandlerMethodReturnValueHandler selectHandler(@Nullable Object value, MethodParameter returnType) {
        // 判断是不是异步返回值.. false
        boolean isAsyncValue = isAsyncReturnValue(value, returnType);
        // 最终找到RequestResponseBodyMethodProcessor可以进行处理
        for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) {
            if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) {
                continue;
            }
            if (handler.supportsReturnType(returnType)) {
                return handler;
            }
        }
        return null;
    }

##########################该返回值处理器对应的handleReturnValue()###########################
@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);
    }

2、返回值解析器原理

• 1、返回值处理器判断是否支持这种类型返回值supportsReturnType
• 2、返回值处理器调用handleReturnValue 进行处理
• 3、RequestResponseBodyMethodProcessor 可以处理返回值标了@ResponseBody 注解的。

1. 利用 MessageConverters 进行处理 将数据写为json

• 1、内容协商（浏览器默认会以请求头的方式告诉服务器他能接受什么样的内容类型）
• 2、服务器最终根据自己自身的能力，决定服务器能生产出什么样内容类型的数据，最终确定一种两者都可以处理的类型.
• 3、SpringMVC会挨个遍历所有容器底层的HttpMessageConverter，看谁能处理？

• 1、得到MappingJackson2HttpMessageConverter可以将对象写为json
• 2、利用MappingJackson2HttpMessageConverter将对象转为json再写出去。

浏览器的请求头

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

ModelAndView
Model
View
ResponseEntity 
ResponseBodyEmitter
StreamingResponseBody
HttpEntity
HttpHeaders
Callable
DeferredResult
支持     ListenableFuture
         CompletionStage
         WebAsyncTask
有 @ModelAttribute 且为对象类型的
@ResponseBody 注解 ---> RequestResponseBodyMethodProcessor；
    ...

1.3、HTTPMessageConverter原理

1、MessageConverter规范

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

例子：当写的时候支不支持Person对象转为JSON。或者读的时候支不支持 JSON转为Person

2、默认的MessageConverter

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 utf-8

8 - true ISO-8859-1

9 - 支持注解方式xml处理的。

注:其中1和2,7和8都是字符编码不同,一个数utf-8一个数IOS8859-1

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

2、内容协商

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

1、引入xml依赖

<dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
</dependency>

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

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

3、内容协商原理

• 1、判断当前响应头中是否已经有确定的媒体类型--MediaType
• 2、获取客户端（PostMan、浏览器）支持接收的内容类型。（默认获取客户端Accept请求头字段）【application/xml】

• contentNegotiationManager 内容协商管理器 默认使用基于请求头的策略

• 

• HeaderContentNegotiationStrategy 确定客户端可以接收的内容类型

• 

• 3、遍历循环所有当前系统的MessageConverter，看谁支持操作这个对象（Person）
• 4、找到支持操作Person的converter，把converter支持的媒体类型统计出来。
• 5、客户端需要【application/xml】。服务端能够【10种、json、xml】

• 

• 6、进行内容协商的最佳匹配媒体类型
• 7、用 支持 将对象转为 最佳匹配媒体类型 的converter。调用它进行转化 。
  现在咱们客户端需要的是xml,只有后两种满足条件.

底层原理

#############################writeWithMessageConverters##############################

        MediaType selectedMediaType = null;
        //1.判断当前响应头中是否已经有确定的媒体类型。MediaType
        MediaType contentType = outputMessage.getHeaders().getContentType();
        boolean isContentTypePreset = contentType != null && contentType.isConcrete();
        if (isContentTypePreset) {
            if (logger.isDebugEnabled()) {
                logger.debug("Found 'Content-Type:" + contentType + "' in response");
            }
             //如果有,就使用之前确定的MediaType 
            selectedMediaType = contentType;
        }
        else {
        //2.获取客户端（PostMan、浏览器）支持接收的内容类型。application/xml ==>  底层原理 在下面
            List<MediaType> acceptableTypes = getAcceptableMediaTypes(request);
                //5.获取服务器端能产生的媒体类型.(10种) ==>底层原理 在下面
            List<MediaType> producibleTypes = getProducibleMediaTypes(request, valueType, targetType);
            //最终要使用的媒体类型
            List<MediaType> mediaTypesToUse = new ArrayList<>();
            //6.进行内容协商的最佳匹配媒体类型,即浏览器能接收的类型有没有和服务器能产生的类型相匹配.
            for (MediaType requestedType : acceptableTypes) {//浏览器能接收的类型
                for (MediaType producibleType : producibleTypes) {//服务器能产生的类型
                    if (requestedType.isCompatibleWith(producibleType)) {
                        mediaTypesToUse.add(getMostSpecificMediaType(requestedType, producibleType));
                    }
                }
            }
        }
if (selectedMediaType != null) {
            selectedMediaType = selectedMediaType.removeQualityValue();
            //7.用 支持 将对象转为 最佳匹配媒体类型 的converter。调用它进行转化 。
            for (HttpMessageConverter<?> converter : this.messageConverters) {
                GenericHttpMessageConverter genericConverter = (converter instanceof GenericHttpMessageConverter ?
                        (GenericHttpMessageConverter<?>) converter : null);
                if (genericConverter != null ?
                        ((GenericHttpMessageConverter) converter).canWrite(targetType, valueType, selectedMediaType) ://判断是否能写
                        converter.canWrite(valueType, selectedMediaType)) {//进行转换
            
################################################getProducibleMediaTypes()##############
    List<MediaType> result = new ArrayList<>();
//3、遍历循环所有当前系统的 **MessageConverter**，看谁支持操作这个对象（Person）
        for (HttpMessageConverter<?> converter : this.messageConverters) {
            if (converter instanceof GenericHttpMessageConverter && targetType != null) {
                if (((GenericHttpMessageConverter<?>) converter).canWrite(targetType, valueClass, null)) {
                //4.找到支持操作Person的converter，把converter支持的媒体类型统计出来。
                    result.addAll(converter.getSupportedMediaTypes(valueClass));
                }
            }
            else if (converter.canWrite(valueClass, null)) {
                result.addAll(converter.getSupportedMediaTypes(valueClass));
            }
        }
 ######################################getAcceptableMediaTypes()#######################
private List<MediaType> getAcceptableMediaTypes(HttpServletRequest request){

        return this.contentNegotiationManager.resolveMediaTypes(new ServletWebRequest(request));//contentNegotiationManager 内容协商管理器
    }   
==================================================================================>>>>   @Override
    public List<MediaType> resolveMediaTypes(NativeWebRequest request) throws HttpMediaTypeNotAcceptableException {
    //      默认使用HeaderContentNegotiationStrategy  
        for (ContentNegotiationStrategy strategy : this.strategies) {
        //本质上获取请求头的底层:AcceptString[] headerValueArray=request.getHeaderValues(HttpHeaders.ACCEPT);
            List<MediaType> mediaTypes = strategy.resolveMediaTypes(request);
            if (mediaTypes.equals(MEDIA_TYPE_ALL_LIST)) {// 如果得到的是 */*,则继续进行遍历寻找
                continue;
            }
            return mediaTypes;
        }
        return MEDIA_TYPE_ALL_LIST;//如果最后还是 */*,则直接返回这个.
    } 
============================================resolveMediaTypes=========================                    
String[] headerValueArray = request.getHeaderValues(HttpHeaders.ACCEPT);
        if (headerValueArray == null) {
            return MEDIA_TYPE_ALL_LIST;
    }

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

WebMvcConfigurationSupport
jackson2XmlPresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.xml.XmlMapper", classLoader);//判断该类是否存在

if (jackson2XmlPresent) {//如果存在
      Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.xml();
      if (this.applicationContext != null) {
        builder.applicationContext(this.applicationContext);
      }
      messageConverters.add(new MappingJackson2XmlHttpMessageConverter(builder.build()));//添加一个MappingJackson2XmlHttpMessageConverter()
    }

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

浏览器除了可以通过AJAX可以指定返回值类型,同时进行为了方便内容协商，还可以开启基于请求参数的内容协商功能。

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

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

​​http://localhost:8080/test/person?format=​​xml,将根据format后面的参数不同,显示对应类型的返回值.

**内容协商管理器中有两个策略, 一个是基于请求参数的参数协商策略,另一个是默认的请求头协商策略. **

当使用第一种请求时,内容协商管理器情况如下:

确定客户端接收什么样的内容类型:

1、根据Parameter策略优先确定是要返回json数据（获取请求头中的format的值）

return request.getParameter(getParameterName())//getParameterName():format 根据请求参数得值返回需要的数据类型

2、最终进行内容协商返回给客户端json即可。

5、自定义 MessageConverter

如果需要以其他格式如PDF,Word,进行内容的返回,则需要自定义MessageConverter

实现多协议数据兼容:json、xml、x-guigu的原理分析:

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

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

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

3、内容协商找到最终的 messageConverter；

如果需要给SpringMVC自定义什么功能。只需要在入口给容器中添加一个 WebMvcConfigurer

如自定义messageConverter

@Bean
    public WebMvcConfigurer webMvcConfigurer(){
        return new WebMvcConfigurer() {

            //扩展MessageConverter,默认的依旧保留,只是进行扩展.
            @Override
            public void extendMessageConverters(List<HttpMessageConverter<?>> converters)                {

            }
            //配置MessageConverter 会覆盖掉默认的
            @Override
            public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
                
            }
        }
    }

5.1 使用PostMan进行内容协商

案例需求以及实现步骤分析:

/**
     * 1、浏览器发请求直接返回 xml    [application/xml]        jacksonXmlConverter
     * 2、如果是ajax请求 返回 json   [application/json]      jacksonJsonConverter
     * 3、如果硅谷app发请求，返回自定义协议数据  [appliaction/x-guigu]   xxxxConverter
     *       需要的返回结果格式:属性值1;属性值2;
     *
     * 步骤：
     * 1、添加自定义的MessageConverter进系统底层
     * 2、系统底层就会统计出所有MessageConverter能操作哪些类型
     * 3、客户端内容协商 [guigu--->guigu]
     *
     * 作业：如何以参数的方式进行内容协商(下一部分..)
     * @return
     */

实现代码:

#######################################GuiguMessageConverter############################
public class GuiguMessageConverter implements HttpMessageConverter<Person> {
    //咱们现在不关心读
    @Override
    public boolean canRead(Class <?> clazz, MediaType mediaType) {
        return false;
    }

    @Override
    public boolean canWrite(Class <?> clazz, MediaType mediaType) {
        return clazz.isAssignableFrom(Person.class);//如果是Person类型则可以写操作..
    }

    /**
     * 服务器要统计所有的MessageConverter都能写哪些内容类型
     *
     * application/x-guigu
     * @return
     */
    @Override
    public List <MediaType> getSupportedMediaTypes() {
        return MediaType.parseMediaTypes("application/x-guigu");
    }

    @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());
    }
}
#####################################WebConfig4#########################################
 @Configuration
public class WebConfig4 {
    @Bean
    public WebMvcConfigurer webMvcConfigurer(){
        return new WebMvcConfigurer() {
            //扩展MessageConverter
            @Override
            public void extendMessageConverters(List <HttpMessageConverter <?>> converters) {
                converters.add(new GuiguMessageConverter());
            }
        };
    }
}

原理分析:

源码中messageConverters:

5.2 如何以参数的形式进行内容协商

默认的基于参数的内容协商的MediaType只有xml和json两种类型.

基于参数的自定义MessageConverter

@Configuration
public class WebConfig4 {
    @Bean
    public WebMvcConfigurer webMvcConfigurer(){
        return new WebMvcConfigurer() {
            //扩展MessageConverter
            @Override
            public void extendMessageConverters(List <HttpMessageConverter <?>> converters) {
                converters.add(new GuiguMessageConverter());
            }

            /**
             * 自定义内容协商策略
             * @param configurer
             */
            @Override
            public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
                Map <String, MediaType> mediaTypes = new HashMap <>();
                mediaTypes.put("json", MediaType.APPLICATION_JSON);
                mediaTypes.put("xml", MediaType.APPLICATION_XML);
                mediaTypes.put("gg", MediaType.parseMediaType("application/x-guigu"));
                
                ParameterContentNegotiationStrategy parameterStrategy = new ParameterContentNegotiationStrategy(mediaTypes);
               // 设置请求参数的名称,默认是format
                // parameterStrategy.setParameterName("ff");
                //因为自定义参数的内容协商策略后,默认的请求头方式的会失效.所以可以手动曾加一个默认的headerContentNegotiationStrategy.
                HeaderContentNegotiationStrategy headerContentNegotiationStrategy = new HeaderContentNegotiationStrategy();
                configurer.strategies(Arrays.asList(parameterStrategy,headerContentNegotiationStrategy));
            }
        };
    }
}

Debug内容协商管理器情况如下:

注:如果使用了 基于参数的自定义MessageConverter,会使基于请求头的那种失效.无论传递哪种参数,最终返回的都是json. 处理:在进行实现时,增加一个HeaderContentNegotiationStrategy(实际上就是系统默认的一些内容协商策略…)

总结:**有时候我们添加的自定义的功能会覆盖默认很多功能，导致一些默认的功能失效。**这时候,我们可以通过Debug进行观察核心部分,然后进行处理.

大家考虑，上述功能除了我们完全自定义外？SpringBoot有没有为我们提供基于配置文件的快速修改媒体类型功能？怎么配置呢？【提示：参照SpringBoot官方文档web开发内容协商章节】

5、视图解析与模板引擎

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

1、视图解析

1、视图解析原理流程

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

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

3、任何目标方法执行完成以后都会返回 ModelAndView（数据和视图地址-------->原来是放在mavContainer中的,之后在getModelAndView()被重新抽取了出来.）。

4、processDispatchResult 处理派发结果（页面改如何响应）

• 1、render(mv, request, response); 进行页面渲染逻辑

• 1、根据方法的String返回值得到View对象【定义了页面的渲染逻辑】 ====>resolveViewName()

• 1、所有的视图解析器尝试是否能根据当前返回值得到View对象
• 2、ContentNegotiationViewResolver里面包含了下面所有的视图解析器，内部还是利用下面所有视图解析器得到视图对象。( 实际上内部使用的是ThymeleafViewResolver)
• 3、根据返回值redirect:/main.html–> Thymeleaf解析器内部通过newRedirectView() 进行返回.

• 2、view.render(mv.getModelInternal(), request, response);

• RedirectView 如何渲染【重定向到一个页面】
• 1、获取目标url地址
• 2、response.sendRedirect(encodedURL);

2.总结: 视图解析：

• 返回值以 forward: 开始： new InternalResourceView(forwardUrl);--> render就是转发request.getRequestDispatcher(path).forward(request, response);
• 返回值以redirect: 开始：new RedirectView() --》 render就是重定向 response.sendRedirect(encodedURL);
• 返回值是普通字符串： new ThymeleafView（）—> 该模板底层按照自己的规则进行解析渲染.

扩展:自定义视图解析器+自定义视图；比如可以把数据渲染成Exel表格/Word文档…

遍历所有的视图解析器,根据返回值寻找可以处理的解析器

ContentNegotiationManager内部包含所有的视图解析器. 所以只需要遍历这一个视图解析器就OK了.

3.底层代码分析:

1.ViewNameMethodReturnValueHandler

###################返回值类型为String的返回值处理器ViewNameMethodReturnValueHandler##########
    //判断是否支持该返回值类型
    @Override
    public boolean supportsReturnType(MethodParameter returnType) {
        Class<?> paramType = returnType.getParameterType();
        return (void.class == paramType || CharSequence.class.isAssignableFrom(paramType));// 如果是空类型 或者是字符串类型,则支持
    }

// 如果支持,则进行处理
@Override
    public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
            ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
        // mavContainer 本质上是一个ModelAndView
        if (returnValue instanceof CharSequence) {
            String viewName = returnValue.toString();//返回值转为String
            mavContainer.setViewName(viewName);//设置进去
            if (isRedirectViewName(viewName)) {//判断是否是重定向的视图 =>
                                            //底层原理:viewName.startsWith("redirect:")
                mavContainer.setRedirectModelScenario(true); // 如果是,则设置一个重定向的传感器..
            }
        }
        else if (returnValue != null) {
            // should not happen
            throw new UnsupportedOperationException("Unexpected return type: " +
                    returnType.getParameterType().getName() + " in method: " + returnType.getMethod());
        }
    }