【springboot】web资源与参数

系统管理员 2024-03-25 17:52 9阅读 0赞

## 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][later in this document 1]).

> 支持 `HttpMessageConverters` （后来我们配合内容协商理解原理）

*  Automatic registration of `MessageCodesResolver` (covered [later in this document][later in this document 2]).

> 自动注册 `MessageCodesResolver` （国际化用）

*  Static `index.html` support.

> 静态index.html 页支持

*  Custom `Favicon` support (covered [later in this document][later in this document 3]).

> 自定义 `Favicon`

*  Automatic use of a `ConfigurableWebBindingInitializer` bean (covered [later in this document][later in this document 4]).

> 自动使用 `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、静态资源目录 ####

只要静态资源放在类路径下： `/static` or `/public` or `/resources` or `/META-INF/resources`

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

--------------------

原理： 静态映射/\*\*。

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

为了不和后端请求冲突，我们可以改变默认的静态资源路径,都加一个统一的前缀

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

默认无前缀

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

#### 3、webjar ####

(不常用)  
自动映射 /[webjars][]/\*\*

[https://www.webjars.org/][https_www.webjars.org]

提供一些前端框架的依赖

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

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

### 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 功能失效

### 2.4、静态资源配置原理 ###

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

@Configuration(proxyBeanMethods = false)
    @ConditionalOnWebApplication(type = Type.SERVLET)
    @ConditionalOnClass({
         Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
    @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
    @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
    @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、资源处理的默认规则 #####

@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/**")) {
        
    				customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**")
    						.addResourceLocations("classpath:/META-INF/resources/webjars/")
    						.setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
    			}
                
                //
    			String staticPathPattern = this.mvcProperties.getStaticPathPattern();
    			if (!registry.hasMappingForPattern(staticPathPattern)) {
        
    				customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern)
    						.addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
    						.setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
    			}
    		}
    spring:
    #  mvc:
    #    static-path-pattern: /res/**
    
      resources:
        add-mappings: false   禁用所有静态资源规则
    @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/" };
    
    	/**
    	 * Locations of static resources. Defaults to classpath:[/META-INF/resources/,
    	 * /resources/, /static/, /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(TemplateAvailabilityProviders templateAvailabilityProviders,
    			ApplicationContext applicationContext, Optional<Resource> welcomePage, String 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 #####

## 3、请求参数处理 ##

### 0、请求映射 ###

#### 1、rest使用与原理 ####

*  @xxxMapping；
 *  Rest风格支持（*使用**HTTP**请求方式动词来表示对资源的操作*）
 *   *  *以前：\*\*/getUser* *获取用户* */deleteUser* *删除用户* */editUser* *修改用户* */saveUser* *保存用户*
     *  *现在： /user* \*GET-\**获取用户* \*DELETE-\**删除用户* \*PUT-\**修改用户* \*POST-\**保存用户*
     *  核心Filter；HiddenHttpMethodFilter
 *   *   *  用法： 表单method=post，隐藏域 \_method=put
         *  SpringBoot中手动开启
 *   *  扩展：如何把\_method 这个名字换成我们自己喜欢的。

@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-张三";
        }
    
    
    	@Bean
    	@ConditionalOnMissingBean(HiddenHttpMethodFilter.class)
    	@ConditionalOnProperty(prefix = "spring.mvc.hiddenmethod.filter", name = "enabled", matchIfMissing = false)
    	public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
        
    		return new OrderedHiddenHttpMethodFilter();
    	}
    
    
    //自定义filter
        @Bean
        public HiddenHttpMethodFilter hiddenHttpMethodFilter(){
        
            HiddenHttpMethodFilter methodFilter = new HiddenHttpMethodFilter();
            methodFilter.setMethodParam("_m");
            return methodFilter;
        }

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

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

**Rest使用客户端工具，**

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

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

#### 2、请求映射原理 ####

![img][]

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

![img][img 1]

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

![img][img 2]

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

*  SpringBoot自动配置欢迎页的 WelcomePageHandlerMapping 。访问 /能访问到index.html；
 *  SpringBoot自动配置了默认 的 RequestMappingHandlerMapping
 *  请求进来，挨个尝试所有的HandlerMapping看是否有请求信息。
 *   *  如果有就找到这个请求对应的handler
     *  如果没有就是下一个 HandlerMapping
 *  我们需要一些自定义的映射处理，我们也可以自己给容器中放**HandlerMapping**。自定义 **HandlerMapping**

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        
    		if (this.handlerMappings != null) {
        
    			for (HandlerMapping mapping : this.handlerMappings) {
        
    				HandlerExecutionChain handler = mapping.getHandler(request);
    				if (handler != null) {
        
    					return handler;
    				}
    			}
    		}
    		return null;
    	}

### 1、普通参数与基本注解 ###

#### 1.1、注解： ####

@PathVariable、@RequestHeader、@ModelAttribute、@RequestParam、@MatrixVariable、@CookieValue、@RequestBody

@RestController
    public class ParameterTestController {
        
    
    
        //  car/2/owner/zhangsan
        @GetMapping("/car/{id}/owner/{username}")
        public Map<String,Object> getCar(@PathVariable("id") Integer id,
                                         @PathVariable("username") String name,
                                         @PathVariable Map<String,String> pv,
                                         @RequestHeader("User-Agent") String userAgent,
                                         @RequestHeader Map<String,String> header,
                                         @RequestParam("age") Integer age,
                                         @RequestParam("inters") List<String> inters,
                                         @RequestParam Map<String,String> params,
                                         @CookieValue("_ga") String _ga,
                                         @CookieValue("_ga") Cookie cookie){
        
    
    
            Map<String,Object> map = new HashMap<>();
    
    //        map.put("id",id);
    //        map.put("name",name);
    //        map.put("pv",pv);
    //        map.put("userAgent",userAgent);
    //        map.put("headers",header);
            map.put("age",age);
            map.put("inters",inters);
            map.put("params",params);
            map.put("_ga",_ga);
            System.out.println(cookie.getName()+"===>"+cookie.getValue());
            return map;
        }
    
    
        @PostMapping("/save")
        public Map postMethod(@RequestBody String content){
        
            Map<String,Object> map = new HashMap<>();
            map.put("content",content);
            return map;
        }
    
        
    
        //1、语法： 请求路径：/cars/sell;low=34;brand=byd,audi,yd
        //2、SpringBoot默认是禁用了矩阵变量的功能
        //      手动开启：原理。对于路径的处理。UrlPathHelper进行解析。
        //              removeSemicolonContent（移除分号内容）支持矩阵变量的
        //3、矩阵变量必须有url路径变量才能被解析
        @GetMapping("/cars/{path}")
        public Map carsSell(@MatrixVariable("low") Integer low,
                            @MatrixVariable("brand") List<String> brand,
                            @PathVariable("path") String path){
        
            Map<String,Object> map = new HashMap<>();
    
            map.put("low",low);
            map.put("brand",brand);
            map.put("path",path);
            return map;
        }
    
        // /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<String,Object> map = new HashMap<>();
    
            map.put("bossAge",bossAge);
            map.put("empAge",empAge);
            return map;
    
        }
    
    }

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

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

**Map、Model类型的参数**，会返回 mavContainer.getModel（）；—> BindingAwareModelMap 是Model 也是Map

**mavContainer**.getModel(); 获取到值的

![img][img 3]

![img][img 4]  
![img][img 5]

#### 1.4、自定义对象参数： ####

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

/**
     *     姓名： <input name="userName"/> <br/>
     *     年龄： <input name="age"/> <br/>
     *     生日： <input name="birth"/> <br/>
     *     宠物姓名：<input name="pet.name"/><br/>
     *     宠物年龄：<input name="pet.age"/>
     */
    @Data
    public class Person {
        
        
        private String userName;
        private Integer age;
        private Date birth;
        private Pet pet;
        
    }
    
    @Data
    public class Pet {
        
    
        private String name;
        private String age;
    
    }
    
    result

### 2、POJO封装过程 ###

*  **ServletModelAttributeMethodProcessor**

### 3、参数处理原理 ###

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

#### 1、HandlerAdapter ####

![img][img 6]

0 - 支持方法上标注@RequestMapping

1 - 支持函数式编程的

xxxxxx

#### 2、执行目标方法 ####

// Actually invoke the handler.
    //DispatcherServlet -- doDispatch
    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    mav = invokeHandlerMethod(request, response, handlerMethod); //执行目标方法
    
    
    //ServletInvocableHandlerMethod
    Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
    //获取方法的参数值
    Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);

#### 3、参数解析器-HandlerMethodArgumentResolver ####

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

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

![img][img 7]

![img][img 8]

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

#### 4、返回值处理器 ####

![img][img 9]

#### 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++) {
        
    			MethodParameter parameter = parameters[i];
    			parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
    			args[i] = findProvidedArgument(parameter, providedArgs);
    			if (args[i] != null) {
        
    				continue;
    			}
    			if (!this.resolvers.supportsParameter(parameter)) {
        
    				throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
    			}
    			try {
        
    				args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
    			}
    			catch (Exception ex) {
        
    				// Leave stack trace for later, exception may actually be resolved and handled...
    				if (logger.isDebugEnabled()) {
        
    					String exMsg = ex.getMessage();
    					if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
        
    						logger.debug(formatArgumentError(parameter, exMsg));
    					}
    				}
    				throw ex;
    			}
    		}
    		return args;
    	}

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

@Nullable
    	private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
        
    		HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
    		if (result == null) {
        
    			for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
        
    				if (resolver.supportsParameter(parameter)) {
        
    					result = resolver;
    					this.argumentResolverCache.put(parameter, result);
    					break;
    				}
    			}
    		}
    		return result;
    	}

##### 5.2、解析这个参数的值 #####

调用各自 HandlerMethodArgumentResolver 的 resolveArgument 方法即可

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

**ServletModelAttributeMethodProcessor 这个参数处理器支持**

**是否为简单类型。**

public static boolean isSimpleValueType(Class<?> type) {
        
    		return (Void.class != type && void.class != type &&
    				(ClassUtils.isPrimitiveOrWrapper(type) ||
    				Enum.class.isAssignableFrom(type) ||
    				CharSequence.class.isAssignableFrom(type) ||
    				Number.class.isAssignableFrom(type) ||
    				Date.class.isAssignableFrom(type) ||
    				Temporal.class.isAssignableFrom(type) ||
    				URI.class == type ||
    				URL.class == type ||
    				Locale.class == type ||
    				Class.class == type));
    	}
    @Override
    	@Nullable
    	public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
    			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
        
    
    		Assert.state(mavContainer != null, "ModelAttributeMethodProcessor requires ModelAndViewContainer");
    		Assert.state(binderFactory != null, "ModelAttributeMethodProcessor requires WebDataBinderFactory");
    
    		String name = ModelFactory.getNameForParameter(parameter);
    		ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.class);
    		if (ann != null) {
        
    			mavContainer.setBinding(name, ann.binding());
    		}
    
    		Object attribute = null;
    		BindingResult bindingResult = null;
    
    		if (mavContainer.containsAttribute(name)) {
        
    			attribute = mavContainer.getModel().get(name);
    		}
    		else {
        
    			// Create attribute instance
    			try {
        
    				attribute = createAttribute(name, parameter, binderFactory, webRequest);
    			}
    			catch (BindException ex) {
        
    				if (isBindExceptionRequired(parameter)) {
        
    					// No BindingResult parameter -> fail with BindException
    					throw ex;
    				}
    				// Otherwise, expose null/empty value and associated BindingResult
    				if (parameter.getParameterType() == Optional.class) {
        
    					attribute = Optional.empty();
    				}
    				bindingResult = ex.getBindingResult();
    			}
    		}
    
    		if (bindingResult == null) {
        
    			// Bean property binding and validation;
    			// skipped in case of binding failure on construction.
    			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中**

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

**byte – > file**

@FunctionalInterface**public interface** Converter<S, T>

![img][img 10]

![img][img 11]

未来我们可以给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数据。

![img][img 12]

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

##  ##

暴露模型作为请求域属性
    // Expose the model object as request attributes.
    		exposeModelAsRequestAttributes(model, request);

##  ##

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、数据响应与内容协商 ##

![img][img 13]

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

![img][img 14]

给前端自动返回json数据；

##### 1、返回值解析器 #####

![img][img 15]

try {
        
    			this.returnValueHandlers.handleReturnValue(
    					returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
    		}
    	@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);
    	}
    RequestResponseBodyMethodProcessor  	
    @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、返回值解析器原理 #####

![img][img 16]

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

![img][img 17]

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

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

#### 1.3、HTTPMessageConverter原理 ####

##### 1、MessageConverter规范 #####

![img][img 18]

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

例子：Person对象转为JSON。或者 JSON转为Person

##### 2、默认的MessageConverter #####

![img][img 19]

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转换的）

![img][img 20]

### 2、内容协商 ###

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

#### 1、引入xml依赖 ####

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

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

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

![img][img 21]

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

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

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

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

[http://localhost:8080/test/person?format=][http_localhost_8080_test_person_format]xml

![img][img 22]

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

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

![img][img 23]

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

#### 4、内容协商原理 ####

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

[later in this document]: https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-spring-mvc-static-content
[later in this document 1]: https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-spring-mvc-message-converters
[later in this document 2]: https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-spring-message-codes
[later in this document 3]: https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-spring-mvc-favicon
[later in this document 4]: https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-spring-mvc-web-binding-initializer
[MVC customizations]: https://docs.spring.io/spring/docs/5.2.9.RELEASE/spring-framework-reference/web.html#mvc
[webjars]: http://localhost:8080/webjars/jquery/3.5.1/jquery.js
[https_www.webjars.org]: https://www.webjars.org/
[img]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f9d1ed3efee44d4a9b4daa0e101a8be2.png
[img 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/7664c31a453b414683990cc4331c1f1d.png
[img 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/658c949726654aa6bcef7ee1cc740ffc.png
[img 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/dbd0ac8b89f34854abba8391dc28ceb4.png
[img 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/fbd7add3147245d086851f051e59154a.png
[img 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/986bf1d26bfa4440b0317a531d4d94c7.png
[img 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0aecf287a29d4212a5e30954c65c28b7.png
[img 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/7bfea54f39384d6683ee4fefbbfc4afb.png
[img 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8afc63e3a72d40db890296fef4042462.png
[img 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ca2ebcb2e3f9472d9d132c578f794bdc.png
[img 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/eb963dae0c6841eab36d1e7074a80ec0.png
[img 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/7d1b85163ba24fd2a302e79c9aca4a70.png
[img 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e64ee0cf1aa94e70842f6e444eda415f.png
[img 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/30a24712124842d2b3309a25271bc312.png
[img 14]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/1acc1288da104737839afa3db8a541cc.png
[img 15]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/59698bb87d19485cb3ffebb028d8908f.png
[img 16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ccb28529fe1b44ecb933d8b85e83abdb.png
[img 17]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e6601e38ab244768a50b081752cd06a8.png
[img 18]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/93b60adfa76c4663b398ec72a8588eae.png
[img 19]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0cfa1efbdbd348988cde0092cbf844f3.png
[img 20]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/368a704d971a48819a9e38d28627eacf.png
[img 21]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/7c774d39043a4ff893034cc5e5464530.png
[http_localhost_8080_test_person_format]: http://localhost:8080/test/person?format=json
[img 22]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3bffc246788b40e1898ceafa1d5f9810.png
[img 23]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3a508250aec749a98a7c41d2fc18c2c4.png
[img 24]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/7d82f6faf36b46a58d2aeb04e3aab0d4.png
[img 25]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e463d2825c1646ac83f804039fa7ca91.png
[img 26]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e16ec8bd8977473fad3352934dabb0c0.png