随便写一个demo:
@RequestMapping("/car/{id}")
public Map<String, Object> getCar(@PathVariable("id") Integer id,
@RequestParam("type") String type,
@RequestParam("hobby") List<String> hobby){
Map<String, Object> map = new HashMap<>();
map.put("id",id);
map.put("type",type);
map.put("hobby", hobby);
return map;
}之前说过通过获取到的mapperHandler中以及找到了控制器以及具体的方法，接下来就需要来处理方法中的各种类型的参数，也就是需要用的SpringMVC中提供的HandlerAdapter。
一、HandlerAdapter
该接口主要就两个方法，一个supports用来判断是否支持这类适配器，如果支持就进行处理（handle方法）。
SpringMVC给我们创建了四种Adapter ：
0—针对含有RequestMapping注解的处理器
......
1.1 RequestMappingHandlerAdapter
获取到第一个适配器RequestMappingHandlerAdapter，调用其supports方法，判断是否支持请求。
supports()
最后就获取到了适合当前请求的适配器了。
1.2 执行获取到的适配器
在上一步中获取到的适配器在这里进行处理。
在该方法内部会唤醒控制器的方法
可以看到无论是否满足if条件，都会执行invokeHandlerMethod这个方法
@Nullable
protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
ServletWebRequest webRequest = new ServletWebRequest(request, response);
ModelAndView var15;
try {
WebDataBinderFactory binderFactory = this.getDataBinderFactory(handlerMethod);
ModelFactory modelFactory = this.getModelFactory(handlerMethod, binderFactory);
ServletInvocableHandlerMethod invocableMethod = this.createInvocableHandlerMethod(handlerMethod);
if (this.argumentResolvers != null) {
invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
}
if (this.returnValueHandlers != null) {
invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
}
invocableMethod.setDataBinderFactory(binderFactory);
invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
modelFactory.initModel(webRequest, mavContainer, invocableMethod);
mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
asyncWebRequest.setTimeout(this.asyncRequestTimeout);
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
asyncManager.setTaskExecutor(this.taskExecutor);
asyncManager.setAsyncWebRequest(asyncWebRequest);
asyncManager.registerCallableInterceptors(this.callableInterceptors);
asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);
Object result;
if (asyncManager.hasConcurrentResult()) {
result = asyncManager.getConcurrentResult();
mavContainer = (ModelAndViewContainer)asyncManager.getConcurrentResultContext()[0];
asyncManager.clearConcurrentResult();
LogFormatUtils.traceDebug(this.logger, (traceOn) -> {
String formatted = LogFormatUtils.formatValue(result, !traceOn);
return "Resume with async result [" + formatted + "]";
});
invocableMethod = invocableMethod.wrapConcurrentResult(result);
}
invocableMethod.invokeAndHandle(webRequest, mavContainer, new Object[0]);
if (asyncManager.isConcurrentHandlingStarted()) {
result = null;
return (ModelAndView)result;
}
var15 = this.getModelAndView(mavContainer, modelFactory, webRequest);
} finally {
webRequest.requestCompleted();
}
return var15;
}在这个方法内部，注意到：
argumentResolvers参数解析器（SpringMVC提供的）。
里面共有27个参数解析器，每一个参数和其注解都会进行一一匹配。
和上面的HandlerAdapter一样的结构，先判断然后去执行。
准备工作完成之后开始给参数赋值，具体的赋值过程如下：
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
Object returnValue = this.invokeForRequest(webRequest, mavContainer, providedArgs);
this.setResponseStatus(webRequest);
if (returnValue == null) {
if (this.isRequestNotModified(webRequest) || this.getResponseStatus() != null || mavContainer.isRequestHandled()) {
this.disableContentCachingIfNecessary(webRequest);
mavContainer.setRequestHandled(true);
return;
}
} else if (StringUtils.hasText(this.getResponseStatusReason())) {
mavContainer.setRequestHandled(true);
return;
}
mavContainer.setRequestHandled(false);
Assert.state(this.returnValueHandlers != null, "No return value handlers");
try {
this.returnValueHandlers.handleReturnValue(returnValue, this.getReturnValueType(returnValue), mavContainer, webRequest);
} catch (Exception var6) {
if (logger.isTraceEnabled()) {
logger.trace(this.formatErrorForReturnValue(returnValue), var6);
}
throw var6;
}
}
其中这一步是真正的执行目标方法，里面有doInvoke方法，利用反射执行控制器的方法
执行完之后获取到了请求方法中的参数并且也都赋值了。
所以看看invokeForRequest方法内部是如何获取参数并赋值的
1.3 获取方法中的参数并赋值
@Nullable
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
Object[] args = this.getMethodArgumentValues(request, mavContainer, providedArgs);
if (logger.isTraceEnabled()) {
logger.trace("Arguments: " + Arrays.toString(args));
}
return this.doInvoke(args);
}该方法内部调用了getMethodArgumentValues方法，说明是通过这个方法来获取参数值的：
protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
MethodParameter[] parameters = this.getMethodParameters();
if (ObjectUtils.isEmpty(parameters)) {
return EMPTY_ARGS;
} else {
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) {
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 var10) {
if (logger.isDebugEnabled()) {
String exMsg = var10.getMessage();
if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
logger.debug(formatArgumentError(parameter, exMsg));
}
}
throw var10;
}
}
}
return args;
}
} 第一步获取到的parameters
内部的基本过程就是：在获取到的parameters集合中的参数一个一个进行迭代然后选择合适的解析器，并且根据url中的路径来进行赋值，即可！
第二类：自定义对象参数
简单Demo：
HTML页面表单：
<form action="/getPerson" method="get">
姓名:<input name="userName" value="zhangsan"><br/>
年龄：<input name="age" value="25"><br/>
宠物名：<input name="pet.name" value="dahua"><br/>
宠物年龄<input name="pet.age" value="2"><br/>
<input type="submit" value="保存">
</form>Controller：
@RequestMapping("/getPerson")
public Person getPerson(Person person){
return person;
}结果：
现在问题是如何将表单中提交的数据封装成了一个Person对象的？
再一次说到getMethodArgumentValues中
protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
......
try {
args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
}
......
}这里的大概逻辑就是 先是获取到了控制器方法中的参数，初步判断是否为空（没赋值的时候肯定为空），然后再try里头有这个方法
也就是一个一个给参数赋值的过程。最终到达参数赋值的方法体中：
@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 = (ModelAttribute)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 {
try {
attribute = this.createAttribute(name, parameter, binderFactory, webRequest);
} catch (BindException var10) {
if (this.isBindExceptionRequired(parameter)) {
throw var10;
}
if (parameter.getParameterType() == Optional.class) {
attribute = Optional.empty();
} else {
attribute = var10.getTarget();
}
bindingResult = var10.getBindingResult();
}
}
if (bindingResult == null) {
WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
if (binder.getTarget() != null) {
if (!mavContainer.isBindingDisabled(name)) {
this.bindRequestParameters(binder, webRequest);
}
this.validateIfApplicable(binder, parameter);
if (binder.getBindingResult().hasErrors() && this.isBindExceptionRequired(binder, parameter)) {
throw new BindException(binder.getBindingResult());
}
}
if (!parameter.getParameterType().isInstance(attribute)) {
attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
}
bindingResult = binder.getBindingResult();
}
Map<String, Object> bindingResultModel = bindingResult.getModel();
mavContainer.removeAttributes(bindingResultModel);
mavContainer.addAllAttributes(bindingResultModel);
return attribute;
}
在这里利用反射创建了一个对象，此例就是Person对象
之后通过 WebDataBinder 绑定器来给attribute赋值。
binder中的target属性就是刚刚创建的attribute
然后再conversionService业务中有一个converts
有124个转换器。
因为HTML 中的 参数值都会作为文本传递过来，也就是String类型的，Person对象中的属性age是Integer类型的，所以就将age的文本值转换为Integer类型即可赋值。
具体转换方法是在这里：
就暂时不进行深究了。
最后需要注意的是赋值的过程就是调用 对象属性中的set方法，所以再html表单中的 name 要和属性中的set方法名后的值相同，应该是称为属性或者是字段值？否则无法将值赋给参数。
这里增加了个性别，表单中属性名为SEX，bean对象中属性名为sex。
发送请求后无法赋值：
所以，表单中的属性值一定要和字段值相同！
1505
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
