《SpringMVC系列》第三章：请求处理

为人师表好少年

已于 2022-05-10 23:40:54 修改

阅读量539

点赞数

分类专栏：《兵临城下SpringMVC》文章标签： java

于 2022-05-10 23:19:24 首次发布

本文链接：https://blog.csdn.net/weixin_44051038/article/details/124700163

版权

《兵临城下SpringMVC》专栏收录该内容

8 篇文章 3 订阅

订阅专栏

重点：

Controller层支持的各种注解以及负责处理这个注解参数解析器
Servert Api 默认注入的参数
参数是如何自动绑定的，包括单个参数和对象参数

一、参数解析器

1.方法参数处理解析器

在SpringMVC中请求调用目标方法需要处理参数，那么不同的参数肯定处理方式不同，SpringMVC提供了一个接口HandlerMethodArgumentResolver，然后多个子类重写，用于处理不同的参数

这个接口提供了两个方法，也很好理解，第1个判断是否为该类型的参数，第2个负责接续

public interface HandlerMethodArgumentResolver {

    // 判断是否可以用于这个参数解析器
	boolean supportsParameter(MethodParameter parameter);

    // 解析参数
	@Nullable
	Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception;

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k4TRf17O-1652195877781)(E:\Gitee\spingboot\HandlerMethodArgumentResolver.png)]

2.参数解析器初始化

上面用到的参数解析器，是如何初始化的呢？

我们用到的适配器 RequestMappingHandlerAdapter 这个类实现了 InitializingBean接口，当SpringMVC容器启动的适合，就会调用afterPropertiesSet()

	public void afterPropertiesSet() {
		// Do this first, it may add ResponseBody advice beans
  		//初始化 @ControllerAdvice 注解需要的东西，后面写篇博客介绍下这个注解
		initControllerAdviceCache();

  		// 获取方法参数处理解析器
		if (this.argumentResolvers == null) {
        	//Spring提供的一系列的HandlerMethodArgumentResolver，同时这儿也会调用用户自己添加的HandlerMethodArgumentResolver
			List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
			this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
		}
  		// 获取桥接方法的参数
		if (this.initBinderArgumentResolvers == null) {
      		//Spring提供的一系列的HandlerMethodArgumentResolver，同时这儿也会调用用户自己添加的HandlerMethodArgumentResolver
			List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
			this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
		}
  		// 获取方法返回值处理器
		if (this.returnValueHandlers == null) {
      		//Spring提供的一系列的HandlerMethodReturnValueHandler，同时这儿也会调用用户自己添加的HandlerMethodReturnValueHandler
			List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
			this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
		}
	}

我们上面用到的参数解析器和返回值处理器就是在这里被初始化的。

	private List<HandlerMethodArgumentResolver> getDefaultInitBinderArgumentResolvers() {
		List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(20);

		// Annotation-based argument resolution
         // 注意看这里添加第一次RequestParamMethodArgumentResolver
		resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
		resolvers.add(new RequestParamMapMethodArgumentResolver());
		resolvers.add(new PathVariableMethodArgumentResolver());
		resolvers.add(new PathVariableMapMethodArgumentResolver());
		resolvers.add(new MatrixVariableMethodArgumentResolver());
		resolvers.add(new MatrixVariableMapMethodArgumentResolver());
		resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new SessionAttributeMethodArgumentResolver());
		resolvers.add(new RequestAttributeMethodArgumentResolver());

		// Type-based argument resolution
		resolvers.add(new ServletRequestMethodArgumentResolver());
		resolvers.add(new ServletResponseMethodArgumentResolver());

		// Custom arguments
		if (getCustomArgumentResolvers() != null) {
			resolvers.addAll(getCustomArgumentResolvers());
		}

		// Catch-all
		resolvers.add(new PrincipalMethodArgumentResolver());
         // // 注意看这里添加第二次RequestParamMethodArgumentResolver
		resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));

		return resolvers;
	}

注意上面是加了两个RequestParamMethodArgumentResolver对象，只不过第一次的参数的值是false，第二次参数的值为true。那么这个两个值的区别是啥？我们还需要看 RequestParamMethodArgumentResolver 类的supportsParameter方法，具体的代码如下：

public boolean supportsParameter(MethodParameter parameter) {
     // 是否存在 RequestParam 注解
	if (parameter.hasParameterAnnotation(RequestParam.class)) {
		if (Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType())) {
			RequestParam requestParam = parameter.getParameterAnnotation(RequestParam.class);
			return (requestParam != null && StringUtils.hasText(requestParam.name()));
		}
		else {
			return true;
		}
	}
	else {
         // 是否存在RequestPart注解 该注解用于复杂的请求域
		if (parameter.hasParameterAnnotation(RequestPart.class)) {
			return false;
		}
		parameter = parameter.nestedIfOptional();
         // 是否是请求的参数
		if (MultipartResolutionDelegate.isMultipartArgument(parameter)) {
			return true;
		}
        // 区别在这，如果是true的话，基本的类型是会返回true 否则直接返回false
		else if (this.useDefaultResolution) {
			return BeanUtils.isSimpleProperty(parameter.getNestedParameterType());
		}
		else {
			return false;
		}
	}
}

上面两个RequestParamMethodArgumentResolver的区别就在于如果是true的话，基本的类型是会返回true，如果不是true，就直接跳过，代表我们匹配参数的时候，基本数据类型放到最后在匹配，优先匹配引用类型去匹配，也就是包装类的优先级高于基本数据类

二、参数注解

@RequestParam

获取请求参数

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestParam {

	@AliasFor("name")
	String value() default "";

	@AliasFor("value")
	String name() default "";
	
    // 是否必须提交
	boolean required() default true;

    // 不存在时默认值
	String defaultValue() default ValueConstants.DEFAULT_NONE;
}

RequestParamMethodArgumentResolver

该类负责

public class RequestParamMethodArgumentResolver extends AbstractNamedValueMethodArgumentResolver implements UriComponentsContributor {
     
    
    @Override
	public boolean supportsParameter(MethodParameter parameter) {
         // 判断参数是否存在 @RequestParam 注解
		if (parameter.hasParameterAnnotation(RequestParam.class)) {
             // 判断嵌套参数类型 Optional
			if (Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType())) {
				RequestParam requestParam = parameter.getParameterAnnotation(RequestParam.class);
				return (requestParam != null && StringUtils.hasText(requestParam.name()));
			}
			else {
				return true;
			}
		}
		else {
			if (parameter.hasParameterAnnotation(RequestPart.class)) {
				return false;
			}
			parameter = parameter.nestedIfOptional();
			if (MultipartResolutionDelegate.isMultipartArgument(parameter)) {
				return true;
			}
			else if (this.useDefaultResolution) {
				return BeanUtils.isSimpleProperty(parameter.getNestedParameterType());
			}
			else {
				return false;
			}
		}
	}

    // reloveName是父类的抽象方法
    @Override
	@Nullable
	protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
		HttpServletRequest servletRequest = request.getNativeRequest(HttpServletRequest.class);
		
          
		if (servletRequest != null) {
             // 调用方法,获取到文件参数，如果没有，则返回一个new Object
			Object mpArg = MultipartResolutionDelegate.resolveMultipartArgument(name, parameter, servletRequest);
             // 不相等，则代表存在文件参数，直接返回
			if (mpArg != MultipartResolutionDelegate.UNRESOLVABLE) {
				return mpArg;
			}
		}

		Object arg = null;
         // 获取文件参数
		MultipartRequest multipartRequest = request.getNativeRequest(MultipartRequest.class);
		if (multipartRequest != null) {
			List<MultipartFile> files = multipartRequest.getFiles(name);
			if (!files.isEmpty()) {
				arg = (files.size() == 1 ? files.get(0) : files);
			}
		}
		if (arg == null) {
             // 从请求里面获取参数值 name在父类已经解析好了
			String[] paramValues = request.getParameterValues(name);
			if (paramValues != null) {
                 // 长度为1 返回1个 否则返回数组
				arg = (paramValues.length == 1 ? paramValues[0] : paramValues);
			}
		}
		return arg;
	}
    
     // 省略其它代码...
}

@RequestPart

上传文件的时候可以使用该注解

RequestPartMethodArgumentResolver

public class RequestPartMethodArgumentResolver extends AbstractMessageConverterMethodArgumentResolver {

	// 判断是否可以应用此参数处理器
	@Override
	public boolean supportsParameter(MethodParameter parameter) {
		if (parameter.hasParameterAnnotation(RequestPart.class)) {
			return true;
		}
		else {
			if (parameter.hasParameterAnnotation(RequestParam.class)) {
				return false;
			}
			return MultipartResolutionDelegate.isMultipartArgument(parameter.nestedIfOptional());
		}
	}

	@Override
	@Nullable
	public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
			NativeWebRequest request, @Nullable WebDataBinderFactory binderFactory) throws Exception {
         // 获取原生的请求
		HttpServletRequest servletRequest = request.getNativeRequest(HttpServletRequest.class);
		Assert.state(servletRequest != null, "No HttpServletRequest");
         
         // 获取注解信息
		RequestPart requestPart = parameter.getParameterAnnotation(RequestPart.class);
         // 是否必填
		boolean isRequired = ((requestPart == null || requestPart.required()) && !parameter.isOptional());

         // 参数名
		String name = getPartName(parameter, requestPart);
		parameter = parameter.nestedIfOptional();
		Object arg = null;

         // 解析上传参数
		Object mpArg = MultipartResolutionDelegate.resolveMultipartArgument(name, parameter, servletRequest);
         // 如果不相等  代表获取到了
		if (mpArg != MultipartResolutionDelegate.UNRESOLVABLE) {
			arg = mpArg;
		}
		else {
			try {
				HttpInputMessage inputMessage = new RequestPartServletServerHttpRequest(servletRequest, name);
				arg = readWithMessageConverters(inputMessage, parameter, parameter.getNestedGenericParameterType());
				if (binderFactory != null) {
					WebDataBinder binder = binderFactory.createBinder(request, arg, name);
					if (arg != null) {
						validateIfApplicable(binder, parameter);
						if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
							throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
						}
					}
					if (mavContainer != null) {
						mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
					}
				}
			}
			catch (MissingServletRequestPartException | MultipartException ex) {
				if (isRequired) {
					throw ex;
				}
			}
		}

         // 异常判断
		if (arg == null && isRequired) {
			if (!MultipartResolutionDelegate.isMultipartRequest(servletRequest)) {
				throw new MultipartException("Current request is not a multipart request");
			}
			else {
				throw new MissingServletRequestPartException(name);
			}
		}
         // 判断是否包装成Optional
		return adaptArgumentIfNecessary(arg, parameter);
	}
}

@RequestBody

获取前端传递的JSON字符串数据，可以和@RequestParam同时使用，@RequestBody 接收的是请求体里面的数据；@RequestParam接收的是key-value里面的参数
一个请求，@RequestBody只能存在一个，而@RequestParam可以使用多个，因为请求体只有1个
获取的是请求体的数据，所以使用POST请求
在参数上添加该注解，Spring就会将请求体中的json/xml对象解析成该参数类型的Javabean对象

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestBody {

	boolean required() default true;
}

RequestResponseBodyMethodProcessor

public class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMethodProcessor {

    // 判断该参数是否存在 @RequestBody 注解 很好理解
	@Override
	public boolean supportsParameter(MethodParameter parameter) {
		return parameter.hasParameterAnnotation(RequestBody.class);
	}

	// 解析参数
	@Override
	public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

         // 获取参数类型
		parameter = parameter.nestedIfOptional();
         // 解析请求体
		Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
		String name = Conventions.getVariableNameForParameter(parameter);

		if (binderFactory != null) {
			WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
			if (arg != null) {
				validateIfApplicable(binder, parameter);
				if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
					throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
				}
			}
			if (mavContainer != null) {
				mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
			}
		}
		// 判断参数是否需要包装成Optional
		return adaptArgumentIfNecessary(arg, parameter);
	}

	// 省略部分代码...
}

@PathVariable

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PathVariable {

	@AliasFor("name")
	String value() default "";

	@AliasFor("value")
	String name() default "";

	boolean required() default true;
}

路径变量，不仅可以把路径变量封装到单个参数内，也可以封装到一个Map里面

	@GetMapping("/car/{id}/owner/{username}")
    public Map<String,Object> getCar(@PathVariable("id") Integer id,
                                     @PathVariable("username") String name,
                                     @PathVariable Map<String,String> pv){

PathVariableMethodArgumentResolver

public class PathVariableMethodArgumentResolver extends AbstractNamedValueMethodArgumentResolver
		implements UriComponentsContributor {

	private static final TypeDescriptor STRING_TYPE_DESCRIPTOR = TypeDescriptor.valueOf(String.class);


    // 方法很简单 判断是否存在 @PathVariable 注解
	@Override
	public boolean supportsParameter(MethodParameter parameter) {
		if (!parameter.hasParameterAnnotation(PathVariable.class)) {
			return false;
		}
		if (Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType())) {
			PathVariable pathVariable = parameter.getParameterAnnotation(PathVariable.class);
			return (pathVariable != null && StringUtils.hasText(pathVariable.value()));
		}
		return true;
	}

	// 解析
	@Override
	@SuppressWarnings("unchecked")
	@Nullable
	protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
         // 这个是直接从 request里面获取,因为请求的时候会直接存进去
		Map<String, String> uriTemplateVars = (Map<String, String>) request.getAttribute(
				HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);
		return (uriTemplateVars != null ? uriTemplateVars.get(name) : null);
	}

 	// 省略部分代码...   
}

@RequestHeader

获取到请求头中的信息

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestHeader {

	@AliasFor("name")
	String value() default "";

	@AliasFor("value")
	String name() default "";

	boolean required() default true;

	String defaultValue() default ValueConstants.DEFAULT_NONE;
}

@RequestAttribute

@RequestAttribute可以获取到域中属性值

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestAttribute {

	@AliasFor("name")
	String value() default "";

	@AliasFor("value")
	String name() default "";

	boolean required() default true;
}

测试代码

// 下面要使用页面重定向 这里不是使用@RestController
@Controller
public class IndexController {

    @GetMapping(value = "/first")
    public String m1(HttpServletRequest request) {
        // 将参数添加到域中
        request.setAttribute("hello", "world");
        return "forward:/second";
    }

    @ResponseBody
    @GetMapping(value = "second")
    // 通过 @RequestAttribute 获取到域中的属性
    public String m2(@RequestAttribute("hello") String hello) {
        return hello;
    }
}

@CookieValue

获取Cookie值

	// 获取单个Cookie值  和 全部的Cookie
    @GetMapping("/car/{id}/owner/{username}")
    public Map<String,Object> getCar(@CookieValue("_ga") String _ga,
                                     @CookieValue("_ga") Cookie cookie){

@MatrixVariable

矩阵变量

默认我们通过请求体来发送参数，但是也可以通过矩阵变量将参数绑定在路径变量中传递到后台，后台根据此获取参数

// 矩阵变量路径使用实例
/boss/1/2        					 找到序号1中的序号2
/boss/1;age=23/2;age=45  			  找到序号1并且年龄=23中的序号2并且年龄=45
/boss/1;age=23;height=170/2;height=20  可以传递多个参数
/boss/1;age=24;height=170,175,180      传递的每个参数包含多个值

矩阵变量使用注意事项：

此功能默认关闭，需要开启
矩阵变量需要结合路径变量@PathVariable来使用
矩阵变量中的参数多个以分号隔开，每个参数的值可以是1个，也可以是多个

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MatrixVariable {

	@AliasFor("name")
	String value() default "";

	@AliasFor("value")
	String name() default "";

    // 规定解析的路径变量
	String pathVar() default ValueConstants.DEFAULT_NONE;

	boolean required() default true;

	String defaultValue() default ValueConstants.DEFAULT_NONE;
}

测试代码

1.需要使用矩阵变量，需要我们开启配置

@Configuration(proxyBeanMethods = false)
public class UserConfig {
    
    // 自定义一个WebMvcConfigurer,重写里面的configurePathMatch
    @Bean
    public WebMvcConfigurer webMvcConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void configurePathMatch(PathMatchConfigurer configurer) {
                UrlPathHelper urlPathHelper = new UrlPathHelper();
                // WebMvcAutoConfiguration自动配置的UrlPathHelper是删除分号后面的内容
                // 但是我们使用矩阵变量 肯定需要留着的 所以这里设置false
                urlPathHelper.setRemoveSemicolonContent(false);
                configurer.setUrlPathHelper(urlPathHelper);
            }
        };
    }
}

2.编写接口

	// 测试地址 /test5/food;eat=rice;drink=water,tea
    // @MatrixVariable 需要与 @PathVariable 结合使用
    // 获取矩阵变量
    @GetMapping(value = "/test5/{path}")
    public Object m5(@MatrixVariable("eat") String eat,
                     @MatrixVariable("drink") List<String> drink,
                     @PathVariable("path") String path) {
        // 将接收的参数返回,方便查看
        Map<String, Object> map = new HashMap<>(16);
        map.put("eat", eat);
        map.put("drink", drink);
        map.put("path",path);
        return map;
    }

    // 测试地址 /test6/path1;eat=rice/path2;drink=water,tea
    // 当存在多个矩阵变量的时候，@MatrixVariable提供了一个pathVar属性来规定获取哪个矩阵变量
    @GetMapping(value = "/test6/{path1}/{path2}")
    public Object m6(@MatrixVariable(value = "eat",pathVar = "path1") String eat,
                     @MatrixVariable(value = "drink",pathVar = "path2") List<String> drink,
                     @PathVariable("path1") String path1,
                     @PathVariable("path2") String path2) {
        Map<String, Object> map = new HashMap<>(16);
        map.put("eat", eat);
        map.put("drink", drink);
        map.put("path1",path1);
        map.put("path2",path2);
        return map;
    }

源码解析

同样这个关系到SpringMVC，自然就跟自动配置类WebMvcAutoConfiguration有关，在其中的静态内部类WebMvcAutoConfigurationAdapter继承了WebMvcConfigurer，根据SpringBoot官网给出的提示，继承WebMvcConfigurer则代表对SpringMVC进行自定义

我们看一下其中的路径匹配方法configurePathMatch，借用了UrlPathHelper

		@Override
		public void configurePathMatch(PathMatchConfigurer configurer) {
			if (this.mvcProperties.getPathmatch()
					.getMatchingStrategy() == WebMvcProperties.MatchingStrategy.PATH_PATTERN_PARSER) {
				configurer.setPatternParser(pathPatternParser);
			}
			configurer.setUseSuffixPatternMatch(this.mvcProperties.getPathmatch().isUseSuffixPattern());
			configurer.setUseRegisteredSuffixPatternMatch(
					this.mvcProperties.getPathmatch().isUseRegisteredSuffixPattern());
			this.dispatcherServletPath.ifAvailable((dispatcherPath) -> {
				String servletUrlMapping = dispatcherPath.getServletUrlMapping();
				if (servletUrlMapping.equals("/") && singleDispatcherServlet()) {
					UrlPathHelper urlPathHelper = new UrlPathHelper();
					urlPathHelper.setAlwaysUseFullPath(true);
					configurer.setUrlPathHelper(urlPathHelper);
				}
			});
		}

UrlPathHelper

该类属于Url地址的一个工具类，在其中有1个属性，来规定是否舍弃分号后面的内容，而我们的矩阵变量就正好是用分号后面的内容，所以就对应了上面的内容，创建一个新的UrlPathHelper设置该属性为false，然后自定义SpringMVC

public class UrlPathHelper {
    
    private boolean removeSemicolonContent = true;
    
    // 省略大量代码...
}

面试题

以前面试的时候，经常会问到这样一道题，页面开发，Cookie禁用了session里面的内容怎么使用？

正常我们做页面开发，会将用户信息存入 session.set(a,b)；每个用户对应一个 sessionid，这个发送到页面存储在cookie里面，但是cookie被禁用，每次请求的时候就无法发送sessionid，这个时候就可以使用矩阵变量把cookie的值传递过来

三、其它参数

Servlet API

例如我们在接口参数里面添加一个HttpServlerRequest ，这个在我们执行目标方法的时候就会自动赋值而不需要参数传递，这个是因为 ServletRequestMethodArgumentResolver的存在

ServletRequestMethodArgumentResolver

public class ServletRequestMethodArgumentResolver implements HandlerMethodArgumentResolver {

	@Nullable
	private static Class<?> pushBuilder;

    // 当参数是以下这些类型的时候，会自动赋值，里面就包含我们常用的 HttpServletRequest
	@Override
	public boolean supportsParameter(MethodParameter parameter) {
		Class<?> paramType = parameter.getParameterType();
		return (WebRequest.class.isAssignableFrom(paramType) ||
				ServletRequest.class.isAssignableFrom(paramType) ||
				MultipartRequest.class.isAssignableFrom(paramType) ||
				HttpSession.class.isAssignableFrom(paramType) ||
				(pushBuilder != null && pushBuilder.isAssignableFrom(paramType)) ||
				(Principal.class.isAssignableFrom(paramType) && !parameter.hasParameterAnnotations()) ||
				InputStream.class.isAssignableFrom(paramType) ||
				Reader.class.isAssignableFrom(paramType) ||
				HttpMethod.class == paramType ||
				Locale.class == paramType ||
				TimeZone.class == paramType ||
				ZoneId.class == paramType);
	}

    // 负责解析参数
	@Override
	public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

		Class<?> paramType = parameter.getParameterType();

		// WebRequest / NativeWebRequest / ServletWebRequest
		if (WebRequest.class.isAssignableFrom(paramType)) {
			if (!paramType.isInstance(webRequest)) {
				throw new IllegalStateException(
						"Current request is not of type [" + paramType.getName() + "]: " + webRequest);
			}
			return webRequest;
		}

		// ServletRequest / HttpServletRequest / MultipartRequest / MultipartHttpServletRequest
		if (ServletRequest.class.isAssignableFrom(paramType) || MultipartRequest.class.isAssignableFrom(paramType)) {
			return resolveNativeRequest(webRequest, paramType);
		}

		// HttpServletRequest required for all further argument types
         // 负责解析其它的参数，我这里省略了篇幅
		return resolveArgument(paramType, resolveNativeRequest(webRequest, HttpServletRequest.class));
	}

	// 省略部分代码...
}

复杂参数

Map、Model（map、model里面的数据会被放在request的请求域，相当于调用了request.setAttribute）、

HttpServlerRequest、Errors/BindingResult、RedirectAttributes（重定向携带数据）、ServletResponse（response）、SessionStatus、UriComponentsBuilder、ServletUriComponentsBuilder

测试代码

在一个请求里面，接收了Map，Model，Request，这个时候后台会把Model、Map里面的数据存入Request，然后页面重定向，在另1个请求里面获取这些数据

	@GetMapping("/test1")
    public String m1(Map<String,Object> map,
                     Model model,
                     HttpServletRequest request,
                     HttpServletResponse response){
        
        // 将信息添加到 Map 和 Model 里面
        map.put("zhang","san");
        model.addAttribute("li","si");
        request.setAttribute("wang","wu");
        Cookie cookie = new Cookie("zhao","liu");
        response.addCookie(cookie);
        return "forward:/test2";
    }

    @ResponseBody
    @GetMapping("/test2")
    public Map m2(HttpServletRequest request,HttpServletResponse response){
        // 上面重定向以后, Map 和 Model里面的数据 在request里面都能获取到
        Map<String,Object> map = new HashMap<>();
        map.put("zhang",request.getAttribute("zhang"));
        map.put("li",request.getAttribute("li"));
        map.put("wang",request.getAttribute("wang"));
        return map;
    }

Map和Model是同1个对象

MapMethodProcessor

该类负责处理Map参数，处理方式是mavContainer.getModel()

public class MapMethodProcessor implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler {

	@Override
	public boolean supportsParameter(MethodParameter parameter) {
		return (Map.class.isAssignableFrom(parameter.getParameterType()) &&
				parameter.getParameterAnnotations().length == 0);
	}

	@Override
	@Nullable
	public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

		Assert.state(mavContainer != null, "ModelAndViewContainer is required for model exposure");
         // 这里是从 mavContainer 直接获取Model
		return mavContainer.getModel();
	}
 	
    // 省略部分代码...
}

ModelMethodProcessor

该类负责处理Model参数，处理方式是mavContainer.getModel()

public class ModelMethodProcessor implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler {

	@Override
	public boolean supportsParameter(MethodParameter parameter) {
		return Model.class.isAssignableFrom(parameter.getParameterType());
	}

	@Override
	@Nullable
	public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

		Assert.state(mavContainer != null, "ModelAndViewContainer is required for model exposure");
         // 这里也是从 mavContainer 直接获取Model 
		return mavContainer.getModel();
	}
    
     // 省略部分代码...
}

ModelAndViewContainer

Map、Model类型的参数，会返回 mavContainer.getMode()，也就是上面默认创建的new BindingAwareModelMap()，其是Model 也是Map

从方法中看到不管是Model还是Map，返回的都是defaultModel，这也代表我们在参数中的Map和Model是一个对象

public class ModelAndViewContainer {
    
    private final ModelMap defaultModel = new BindingAwareModelMap();
    
    public ModelMap getModel() {
		if (useDefaultModel()) {
             // 返回上面创建的默认的defaultModel
			return this.defaultModel;
		}
		else {
			if (this.redirectModel == null) {
				this.redirectModel = new ModelMap();
			}
			return this.redirectModel;
		}
	}
    
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cRiROD66-1652195877783)(E:/Gitee/spingboot/ModelMap.png)]

Model和Map数据如何存到request

上面测试代码已经试验了Mode和Map会存储到request，那么如何存储的呢？

在最底层的实现肯定很简单，也就是把数据取出来，然后遍历通过request.setAttribute()存进去，那么就看一下如何实现的

// 方法执行链
org.springframework.web.servlet.DispatcherServlet#doDispatch()
 -->org.springframework.web.servlet.DispatcherServlet#processDispatchResult()
  -->org.springframework.web.servlet.DispatcherServlet#render()
    -->org.springframework.web.servlet.view.AbstractView#render()
      -->org.springframework.web.servlet.view.InternalResourceView#renderMergedOutputModel()
        -->org.springframework.web.servlet.view.AbstractView#exposeModelAsRequestAttributes()

最终的方法就是exposeModelAsRequestAttributes()，很简单就是遍历存储

	protected void exposeModelAsRequestAttributes(Map<String, Object> model,
			HttpServletRequest request) throws Exception {
		// 遍历
		model.forEach((name, value) -> {
			if (value != null) {
				request.setAttribute(name, value);
			}
			else {
				request.removeAttribute(name);
			}
		});
	}

四、参数处理解析

1.调用链

在SpringMVC中，通过处理适配器调用目标方法的时候，中间会调用到该方法，方法内容也很好理解，第1步获取到方法参数，第2步反射调用方法

	@Nullable
	public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {

		Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
		if (logger.isTraceEnabled()) {
			logger.trace("Arguments: " + Arrays.toString(args));
		}
		return doInvoke(args);
	}

上面的代码包括两步，第1 通过 getMethodArgumentValues()方法来获取参数，第2 通过doInvoke()来执行对应的方法，是通过反射来执行，然后将结果返回，

那么首先来看获取实参的处理，整体的一个思路就是首先获取到该方法的全部形参，然后通过参数解析器，现在请求里面通过类型找，然后在通过形参名找，如此把请求携带的参数自动赋值到实参里面

	protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {
		// 获取方法的参数, 注意看这里是直接调用方法,前面没有类名，
         // 本方法处于InvocableHandlerMethod类，是HandlerMethod的子类
         // 我们前面获取的映射器是InvocableHandlerMethod的子类，所以直接调用
         // 所以获取到的就是该方法的形参列表数组
         // 点进到 getMethodParameters()方法里面 就是HandlerMethod类的getter方法
         // 下面看到了其关系图
		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);
            // 这儿一般的情况下会返回Null
			args[i] = findProvidedArgument(parameter, providedArgs);
			if (args[i] != null) {
				continue;
			}
            // 查找对应的参数的处理器，主要是遍历所有的参数的处理器，调用处理中的support方法，只要满足就返回true
            // 不同的参数类型有不同的处理器
            // 参数类型的初始化在后面介绍
			if (!this.resolvers.supportsParameter(parameter)) {
                 // 如果没有找到参数解析器 就报异常
				throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
			}
			try {
                // 找到了就直接执行参数处理器的resolveArgument() 解析参数 获取实参
				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;
	}

在这里插入图片描述

上面看到我们首先会查询该形参是否存在匹配的参数解析器，如果不存在就报异常，看一下supportsParameter(parameter)方法

	@Override
	public boolean supportsParameter(MethodParameter parameter) {
		return getArgumentResolver(parameter) != null;
	}

继续调用 getArgumentResolver()

	@Nullable
	private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
        // 先尝试从缓存中获取 这个是存在缓存的
		HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
		if (result == null) {
             // 遍历所有的参数处理器，调用每一个参数处理器的 supportsParameter 方法，直到返回的结果为true为止
             // 下面介绍该参数解析器在哪里初始化的
			for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
                  // 依次判断
				if (resolver.supportsParameter(parameter)) {
					result = resolver;
                      // 如果匹配到 就存入缓存
					this.argumentResolverCache.put(parameter, result);
					break;
				}
			}
		}
		return result;
	}

上面我们介绍了如何匹配参数解析器，接下来我们看一下resolveArgument()

当我们，其实注意看一下类结构，这前后用的几个方法 supportsParameter()、resolveArgument() 、getArgumentResolver()都是HandlerMethodArgumentResolverComposite 类的，而且并排的三个方法

   @Override
   @Nullable
   public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
   		NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
   	// 继续调用 getArgumentResolver() 方法获取到对应的参数解析器
   	HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
        // 如果为空 直接报异常 代表没有解析器可以解析该参数
   	if (resolver == null) {
   		throw new IllegalArgumentException("Unsupported parameter type [" +
   				parameter.getParameterType().getName() + "]. supportsParameter should be called first.");
   	}
        // 上面获取到了解析器，接下来解析参数 因为不同的参数解析器，解析方法不同
   	return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
   }

我们方法的形参有不同的类型，有包装类，字符串，基本数据类型，数组、引用数据类型等等，那么会分成2种情况，第一种就是普通的类型，第二种就是引用对象，SpringMVC会自动把参数封装到对象里面

2.普通形参匹配

普通的参数，是会借助 AbstractNamedValueMethodArgumentResolver 类来解析参数，然后我们查看其中的resolveArgument()，具体的代码如下：

public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

    // 获取方法的形参名信息 NamedValueInfo是一个静态内部类 包含这个形参的名称、required、defaultValue信息
    // 如果形参有@RequestParam注解 则注解信息都会保存在NamedValueInfo这里
	NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
    // 获取包装的方法参数的类型
	MethodParameter nestedParameter = parameter.nestedIfOptional();

    // 从上面的namedValueInfo单独取出形参名
	Object resolvedName = resolveEmbeddedValuesAndExpressions(namedValueInfo.name);
    // 非空判断
	if (resolvedName == null) {
		throw new IllegalArgumentException(
				"Specified name must not resolve to null: [" + namedValueInfo.name + "]");
	}

    // 获取参数的值
	Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
    // 获取的值为空
	if (arg == null) {
         // 查看是否有默认值，设置默认值
		if (namedValueInfo.defaultValue != null) {
			arg = resolveStringValue(namedValueInfo.defaultValue);
		}
		else if (namedValueInfo.required && !nestedParameter.isOptional()) {
            // 判断是否是必须要值，如果是直接抛出异常
			handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
		}
        // 处理空值，如果这个值的类型是Boolean类型，就设置为false，其他的情况下都是原来的默认值
		arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
	}
	else if ("".equals(arg) && namedValueInfo.defaultValue != null) {
         // 获取值为""同时默认值也不为空，那么就将默认值设置进去
		arg = resolveStringValue(namedValueInfo.defaultValue);
	}

    // 进行类型转换 因为URL请求接收的一般都是String类型，而我们的形参存在各种类型
	if (binderFactory != null) {
		WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
		try {
             // 在这里进行类型转换 转换成正确的参数类型
			arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
		}
		catch (ConversionNotSupportedException ex) {// 类型转换异常
			throw new MethodArgumentConversionNotSupportedException(arg, ex.getRequiredType(),
					namedValueInfo.name, parameter, ex.getCause());
		}
		catch (TypeMismatchException ex) {// 类型找不到异常
			throw new MethodArgumentTypeMismatchException(arg, ex.getRequiredType(),
					namedValueInfo.name, parameter, ex.getCause());
		}
         // 最极端情况 值为空&&默认值为空&&必填 报异常
         if (arg == null && namedValueInfo.defaultValue == null &&
					namedValueInfo.required && !nestedParameter.isOptional()) {
			handleMissingValueAfterConversion(namedValueInfo.name, nestedParameter, webRequest);
		}
	}

	handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
	
    //返回处理好的参数的
	return arg;
}

由于RequestParamMethodArgumentResolver类没有实现HandlerMethodArgumentResolver接口，所以这儿调用的是父类的resolveArgument方法，但是获取对应参数的值是调用子类RequestParamMethodArgumentResolver的resolveName方法，具体的代码如下：

protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
    // 获取请求
	HttpServletRequest servletRequest = request.getNativeRequest(HttpServletRequest.class);
	if (servletRequest != null) {
		Object mpArg = MultipartResolutionDelegate.resolveMultipartArgument(name, parameter, servletRequest);
		if (mpArg != MultipartResolutionDelegate.UNRESOLVABLE) {
			return mpArg;
		}
	}

	Object arg = null;
    // 处理文件的
	MultipartRequest multipartRequest = request.getNativeRequest(MultipartRequest.class);
	if (multipartRequest != null) {
		List<MultipartFile> files = multipartRequest.getFiles(name);
		if (!files.isEmpty()) {
			arg = (files.size() == 1 ? files.get(0) : files);
		}
	}
	if (arg == null) {
        // 重点在这里 还是调用请求的API来获取参数 返回是个数组
		String[] paramValues = request.getParameterValues(name);
		if (paramValues != null) {
			arg = (paramValues.length == 1 ? paramValues[0] : paramValues);
		}
	}
	return arg;
}

我们终于看到对应参数的获取方法resolveName()，就是利用了servlet的api来获取指定的参数的值的。我们继续看上面的resolveArgument()剩余的代码，注释内容都在上面写清楚了，这里就不在重复了。

3.自定义对象参数

当接口参数中接收的是一个对象，而不是普通类型的时候，那么SpringMVC依旧能把参数准确的赋值到参数对象中，那么它是如何操作的呢？

这里还是借助我们的参数解析器ServletModelAttributeMethodProcessor，不过方法编写在父类中ModelAttributeMethodProcessor

ModelAttributeMethodProcessor

public class ModelAttributeMethodProcessor implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler {
	
    @Override
	public boolean supportsParameter(MethodParameter parameter) {
         // 判断是否存在@ModelAttribute注解  || 
		return (parameter.hasParameterAnnotation(ModelAttribute.class) ||
                 // 判断是否为简单类型,也就是一些Number，Data，Enum等
				(this.annotationNotRequired && !BeanUtils.isSimpleProperty(parameter.getParameterType())));
	}
    
	@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();
				}
				else {
					attribute = ex.getTarget();
				}
				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;
	}   
}

isSimpleProperty() 是否为简单类型

在上面ModelAttributeMethodProcessor中的supportsParameter()中，当判断参数是否需要使用该解析器的时候，需要抛出简单类型

	public static boolean isSimpleProperty(Class<?> type) {
		Assert.notNull(type, "'type' must not be null");
		return isSimpleValueType(type) || (type.isArray() && isSimpleValueType(type.getComponentType()));
	}

    // 这里判断是否为即简单类型,可以看到,都是一些常用的基本类型
	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));
	}

setPropertyValues()

上面的方法调用到这里会经过几个方法，这里省略了，只截取了重要的方法

这里会通过循环来设置对象属性，但是注意一点：

注意：这里循环的内容是请求发送过来的参数，将接收的参数循环，然后赋值到参数对象中，那么当多个参数对象存在相同字段的时候，那么都会赋值，这里和普通参数获取不同，普通参数是拿着参数名去请求中获取，而参数对象则相反，其是将接收的参数遍历，通过反射，调用setter方法，赋值到参数对象内

@Override
	public void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
			throws BeansException {

		List<PropertyAccessException> propertyAccessExceptions = null;
		List<PropertyValue> propertyValues = (pvs instanceof MutablePropertyValues ?
				((MutablePropertyValues) pvs).getPropertyValueList() : Arrays.asList(pvs.getPropertyValues()));

		if (ignoreUnknown) {
			this.suppressNotWritablePropertyException = true;
		}
		try {
             // 这里循环的内容是 请求中携带的参数 
			for (PropertyValue pv : propertyValues) {
				try {
                      // 这里设置属性值
					setPropertyValue(pv);
				}
				catch (NotWritablePropertyException ex) {
					if (!ignoreUnknown) {
						throw ex;
					}
					// Otherwise, just ignore it and continue...
				}
				catch (NullValueInNestedPathException ex) {
					if (!ignoreInvalid) {
						throw ex;
					}
					// Otherwise, just ignore it and continue...
				}
				catch (PropertyAccessException ex) {
					if (propertyAccessExceptions == null) {
						propertyAccessExceptions = new ArrayList<>();
					}
					propertyAccessExceptions.add(ex);
				}
			}
		}
		finally {
			if (ignoreUnknown) {
				this.suppressNotWritablePropertyException = false;
			}
		}

		// If we encountered individual exceptions, throw the composite exception.
		if (propertyAccessExceptions != null) {
			PropertyAccessException[] paeArray = propertyAccessExceptions.toArray(new PropertyAccessException[0]);
			throw new PropertyBatchUpdateException(paeArray);
		}
	}

processLocalProperty()

会判断该参数对象中是否存在这个字段，也就是是否需要赋值
把数据进行类型转换
调用方法设置值

private void processLocalProperty(PropertyTokenHolder tokens, PropertyValue pv) {
         // 这里会获取属性处理器
         // 如果接收的参数在参数对象中不存在,则为Null
		PropertyHandler ph = getLocalPropertyHandler(tokens.actualName);
		if (ph == null || !ph.isWritable()) {
			if (pv.isOptional()) {
				if (logger.isDebugEnabled()) {
					logger.debug("Ignoring optional value for property '" + tokens.actualName +
							"' - property not found on bean class [" + getRootClass().getName() + "]");
				}
				return;
			}
			if (this.suppressNotWritablePropertyException) {
				// Optimization for common ignoreUnknown=true scenario since the
				// exception would be caught and swallowed higher up anyway...
				return;
			}
			throw createNotWritablePropertyException(tokens.canonicalName);
		}

		Object oldValue = null;
		try {
			Object originalValue = pv.getValue();
			Object valueToApply = originalValue;
			if (!Boolean.FALSE.equals(pv.conversionNecessary)) {
				if (pv.isConverted()) {
					valueToApply = pv.getConvertedValue();
				}
				else {
					if (isExtractOldValueForEditor() && ph.isReadable()) {
						try {
							oldValue = ph.getValue();
						}
						catch (Exception ex) {
							if (ex instanceof PrivilegedActionException) {
								ex = ((PrivilegedActionException) ex).getException();
							}
							if (logger.isDebugEnabled()) {
								logger.debug("Could not read previous value of property '" +
										this.nestedPath + tokens.canonicalName + "'", ex);
							}
						}
					}
                      // 这里会进行转换,因为接收的参数文本类型，但是我们接收的参数是各种类型
                      // 对于Http来说 所谓万物皆文本
					valueToApply = convertForProperty(
							tokens.canonicalName, oldValue, originalValue, ph.toTypeDescriptor());
				}
				pv.getOriginalPropertyValue().conversionNecessary = (valueToApply != originalValue);
			}
             // 设置值
			ph.setValue(valueToApply);
		}
		catch (TypeMismatchException ex) {
			throw ex;
		}
		catch (InvocationTargetException ex) {
			PropertyChangeEvent propertyChangeEvent = new PropertyChangeEvent(
					getRootInstance(), this.nestedPath + tokens.canonicalName, oldValue, pv.getValue());
			if (ex.getTargetException() instanceof ClassCastException) {
				throw new TypeMismatchException(propertyChangeEvent, ph.getPropertyType(), ex.getTargetException());
			}
			else {
				Throwable cause = ex.getTargetException();
				if (cause instanceof UndeclaredThrowableException) {
					// May happen e.g. with Groovy-generated methods
					cause = cause.getCause();
				}
				throw new MethodInvocationException(propertyChangeEvent, cause);
			}
		}
		catch (Exception ex) {
			PropertyChangeEvent pce = new PropertyChangeEvent(
					getRootInstance(), this.nestedPath + tokens.canonicalName, oldValue, pv.getValue());
			throw new MethodInvocationException(pce, ex);
		}
	}

setValue()

获取setter的赋值方法，然后进行赋值

		@Override
		public void setValue(@Nullable Object value) throws Exception {
             // 获取参数的setter方法,有了setter，就方便赋值了
			Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?
					((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :
					this.pd.getWriteMethod());
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
					ReflectionUtils.makeAccessible(writeMethod);
					return null;
				});
				try {
					AccessController.doPrivileged((PrivilegedExceptionAction<Object>)
							() -> writeMethod.invoke(getWrappedInstance(), value), acc);
				}
				catch (PrivilegedActionException ex) {
					throw ex.getException();
				}
			}
			else {
				ReflectionUtils.makeAccessible(writeMethod);
                  // 通过反射调用setter
				writeMethod.invoke(getWrappedInstance(), value);
			}
		}

4.参数转换器

Converter

在普通参数和对象参数最终赋值的时候都会借助一个WebDataBinder来绑定数据，那么它需要转换器Converter来辅助，转换器主要是将参数转换成我们需要的类型，因为从Http请求传递过来的参数都是字符串，对应Http来说，万物接文字，那么需要将传递过来的字符串转换成我们接收参数的类型，就是通过Converter来完成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a0DSByY8-1652195877784)(E:\Gitee\spingboot\converters.png)]

自定义Converter

正常我们前端发送过来的数据都是一个 key 对应一个Value，但是有的时候我们想1个字段发送2个值

例如: http://127.0.0.1:8080/test8?user=1,张，将两个值一起发送，后台实现解析，赋值到2个字段上

这个时候，我们需要在自定义Converter，来实现这个功能

@Configuration(proxyBeanMethods = false)
public class UserConfig {

    // 还是借助 WebMvcConfigurer 自定义MVC策略
    @Bean
    public WebMvcConfigurer webMvcConfigurer() {
        return new WebMvcConfigurer() {
			
            @Override
            public void addFormatters(FormatterRegistry registry) {
                registry.addConverter(new Converter<String, User>() {
                    @Override
                    public User convert(String source) {
                        if (!source.isEmpty()) {
                            User user = new User();
                            String[] split = source.split(",");
                            user.setId(Integer.valueOf(split[0]));
                            user.setName(split[1]);
                            return user;
                        }
                        return null;
                    }
                });
            }
        };
    }

}

5.注意点

自定义参数对象，将请求数据自动封装到参数中，请求需要是GET请求，如果是POST，请求体中是不会处理的
这里循环的内容是请求发送过来的参数，将接收的参数循环，然后赋值到参数对象中，那么当多个参数对象存在相同字段的时候，那么都会赋值
这里和普通参数获取不同，普通参数匹配是拿着参数名去请求中获取，而参数对象则相反，其是将接收的参数遍历，通过反射，调用setter方法，赋值到参数对象内
p请求传递过来的参数都是字符串，对应Http来说，万物接文字，那么需要将传递过来的字符串转换成我们接收参数的类型，就是通过Converter来完成

[外链图片转存中…(img-a0DSByY8-1652195877784)]

自定义Converter

正常我们前端发送过来的数据都是一个 key 对应一个Value，但是有的时候我们想1个字段发送2个值

例如: http://127.0.0.1:8080/test8?user=1,张，将两个值一起发送，后台实现解析，赋值到2个字段上

这个时候，我们需要在自定义Converter，来实现这个功能

@Configuration(proxyBeanMethods = false)
public class UserConfig {

    // 还是借助 WebMvcConfigurer 自定义MVC策略
    @Bean
    public WebMvcConfigurer webMvcConfigurer() {
        return new WebMvcConfigurer() {
			
            @Override
            public void addFormatters(FormatterRegistry registry) {
                registry.addConverter(new Converter<String, User>() {
                    @Override
                    public User convert(String source) {
                        if (!source.isEmpty()) {
                            User user = new User();
                            String[] split = source.split(",");
                            user.setId(Integer.valueOf(split[0]));
                            user.setName(split[1]);
                            return user;
                        }
                        return null;
                    }
                });
            }
        };
    }

}

5.注意点

自定义参数对象，将请求数据自动封装到参数中，请求需要是GET请求，如果是POST，请求体中是不会处理的
这里循环的内容是请求发送过来的参数，将接收的参数循环，然后赋值到参数对象中，那么当多个参数对象存在相同字段的时候，那么都会赋值
这里和普通参数获取不同，普通参数匹配是拿着参数名去请求中获取，而参数对象则相反，其是将接收的参数遍历，通过反射，调用setter方法，赋值到参数对象内

为人师表好少年

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
《SpringMVC系列》第三章：请求处理

重点：Controller层支持的各种注解以及负责处理这个注解参数解析器Servert Api 默认注入的参数参数是如何自动绑定的，包括单个参数和对象参数一、参数解析器1.方法参数处理解析器在SpringMVC中请求调用目标方法需要处理参数，那么不同的参数肯定处理方式不同，SpringMVC提供了一个接口HandlerMethodArgumentResolver，然后多个子类重写，用于处理不同的参数这个接口提供了两个方法，也很好理解，第1个判断是否为该类型的参数，第2个负责接续publi
复制链接

扫一扫