关于java:三SpringMVC参数绑定

申请进入DispatcherServlet的doDispatch后，获取HandlerMethod。而后依据HandlerMethod来确认HandlerApapter，确认后执行HandlerAdapter的handle办法。这里确认HandlerApater为RequestMappingHandlerAdapter，在执行handlerMethod之前，须要解决参数的绑定。

1. 简略参数绑定

执行HandlerAdapter的handler办法后，进入RequestMappingHandlerAdapter的invokeHandleMethod办法

private ModelAndView invokeHandleMethod(HttpServletRequest request,            HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {    ServletWebRequest webRequest = new ServletWebRequest(request, response);    WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);    ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);    //依据handlerMethod和binderFactory创立一个ServletInvocableHandlerMethod。后续把申请间接交给ServletInvocableHandlerMethod执行。    //createRequestMappingMethod办法比较简单，把之前RequestMappingHandlerAdapter初始化的argumentResolvers和returnValueHandlers增加至ServletInvocableHandlerMethod中    ServletInvocableHandlerMethod requestMappingMethod = createRequestMappingMethod(handlerMethod, binderFactory);    ModelAndViewContainer mavContainer = new ModelAndViewContainer();    mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));    modelFactory.initModel(webRequest, mavContainer, requestMappingMethod);    mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);    AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);    asyncWebRequest.setTimeout(this.asyncRequestTimeout);    final WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);    asyncManager.setTaskExecutor(this.taskExecutor);    asyncManager.setAsyncWebRequest(asyncWebRequest);    asyncManager.registerCallableInterceptors(this.callableInterceptors);    asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);    if (asyncManager.hasConcurrentResult()) {        Object result = asyncManager.getConcurrentResult();        mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];        asyncManager.clearConcurrentResult();        if (logger.isDebugEnabled()) {            logger.debug("Found concurrent result value [" + result + "]");        }        requestMappingMethod = requestMappingMethod.wrapConcurrentResult(result);    }    requestMappingMethod.invokeAndHandle(webRequest, mavContainer);    if (asyncManager.isConcurrentHandlingStarted()) {        return null;    }    return getModelAndView(mavContainer, modelFactory, webRequest);}

而后进入invokeAndHanldle办法，而后进入invokeForRequest办法，这个办法的职责是从request中解析出HandlerMethod办法所须要的参数，而后通过反射调用HandlerMethod中的method

public final Object invokeForRequest(NativeWebRequest request,                                        ModelAndViewContainer mavContainer,                                        Object... providedArgs) throws Exception {        //从request中解析出HandlerMethod办法所须要的参数，并返回Object[]        Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);        if (logger.isTraceEnabled()) {            StringBuilder builder = new StringBuilder("Invoking [");            builder.append(this.getMethod().getName()).append("] method with arguments ");            builder.append(Arrays.asList(args));            logger.trace(builder.toString());        }                //通过反射执行HandleMethod中的method，办法参数为args。并返回办法执行的返回值        Object returnValue = invoke(args);        if (logger.isTraceEnabled()) {            logger.trace("Method [" + this.getMethod().getName() + "] returned [" + returnValue + "]");        }        return returnValue;    }

进入getMethodArgumentValues办法

private Object[] getMethodArgumentValues(        NativeWebRequest request, ModelAndViewContainer mavContainer,        Object... providedArgs) throws Exception {            //获取办法参数数组    MethodParameter[] parameters = getMethodParameters();        //创立一个参数数组，保留从request解析出的办法参数    Object[] args = new Object[parameters.length];    for (int i = 0; i < parameters.length; i++) {        MethodParameter parameter = parameters[i];        parameter.initParameterNameDiscovery(parameterNameDiscoverer);        GenericTypeResolver.resolveParameterType(parameter, getBean().getClass());        args[i] = resolveProvidedArgument(parameter, providedArgs);        if (args[i] != null) {            continue;        }                //判断之前RequestMappingHandlerAdapter初始化的那24个HandlerMethodArgumentResolver（参数解析器），是否存在反对该参数解析的解析器        if (argumentResolvers.supportsParameter(parameter)) {            try {                args[i] = argumentResolvers.resolveArgument(parameter, mavContainer, request, dataBinderFactory);                continue;            } catch (Exception ex) {                if (logger.isTraceEnabled()) {                    logger.trace(getArgumentResolutionErrorMessage("Error resolving argument", i), ex);                }                throw ex;            }        }        if (args[i] == null) {            String msg = getArgumentResolutionErrorMessage("No suitable resolver for argument", i);            throw new IllegalStateException(msg);        }    }    return args;}

进入HandlerMethodArgumentResolverComposite的resolveArgument办法

public Object resolveArgument(            MethodParameter parameter, ModelAndViewContainer mavContainer,            NativeWebRequest webRequest, WebDataBinderFactory binderFactory)            throws Exception {                    //首先获取参数解析器，这里获取的逻辑是首先从argumentResolverCache缓存中获取该MethodParameter匹配的HandlerMethodArgumentResolver。如果为空，遍历初始化定义的那24个。查找匹配的HandlerMethodArgumentResolver，而后增加至argumentResolverCache缓存中        HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);        Assert.notNull(resolver, "Unknown parameter type [" + parameter.getParameterType().getName() + "]");                //解析参数        return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);    }

再进入HandlerMethodArgumentResolver的resolverArgument办法

public final Object resolveArgument(            MethodParameter parameter, ModelAndViewContainer mavContainer,            NativeWebRequest webRequest, WebDataBinderFactory binderFactory)            throws Exception {                    //获取int的Class对象        Class<?> paramType = parameter.getParameterType();                //依据参数定义创立一个NamedValueInfo对象        NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);        //依据参数名解析出对象的值        Object arg = resolveName(namedValueInfo.name, parameter, webRequest);        if (arg == null) {            if (namedValueInfo.defaultValue != null) {                arg = resolveDefaultValue(namedValueInfo.defaultValue);            }            else if (namedValueInfo.required) {                handleMissingValue(namedValueInfo.name, parameter);            }            arg = handleNullValue(namedValueInfo.name, arg, paramType);        }        else if ("".equals(arg) && (namedValueInfo.defaultValue != null)) {            arg = resolveDefaultValue(namedValueInfo.defaultValue);        }                //下面步骤获取的args是String类型，而后转换为办法参数所须要的类型(int)        if (binderFactory != null) {            WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);            arg = binder.convertIfNecessary(arg, paramType, parameter);        }        handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);                return arg;    }

这个办法的职责是依据parameter对象创立一个NamedValueInfo对象。这个对象寄存的就是参数名、是否必须、参数默认值3个成员变量。而后进入resolverName办法解析参数，最初返回

2. 对象参数绑定

对象参数解析绑定会交给ServletModelAttributeMethodProcessor这个类进行解析，进入supportsParameter办法

/***带有@ModelAttribute注解返回true* parameter不是简略类型也返回true.*/public boolean supportsParameter(MethodParameter parameter) {    if (parameter.hasParameterAnnotation(ModelAttribute.class)) {             return true;    } else if (this.annotationNotRequired) {                    return !BeanUtils.isSimpleProperty(parameter.getParameterType());    } else {                    return false;    }}

进入ServletModelAttributeMethodProcessor的resolveArgument办法。它的resolveArgument是由父类ModelAttributeMethodProcessor具体实现的

/*** 解析model中的参数，如果从ModelAndViewContainer未找到，间接通过反射实例化一个对象。具体实例化是通过父类的createAttribute办法，通过调用BeanUtils.instantiateClass办法来实例化的。这个对象便是后续传给test2(User u)办法的对象，然而此时创立的对象外面的值都还为空，注入值是通过bindRequestParameters办法来实现的。*/public final Object resolveArgument(    MethodParameter parameter, ModelAndViewContainer mavContainer,            NativeWebRequest request, WebDataBinderFactory binderFactory)        throws Exception {            String name = ModelFactory.getNameForParameter(parameter);        Object attribute = (mavContainer.containsAttribute(name)) ?    mavContainer.getModel().get(name) : createAttribute(name, parameter, binderFactory, request);    WebDataBinder binder = binderFactory.createBinder(request, attribute, name);            if (binder.getTarget() != null) {                //将申请绑定至指标binder的target对象，也就是刚刚创立的attribute对象。    bindRequestParameters(binder, request);                //如果有验证，则验证参数    validateIfApplicable(binder, parameter);                if (binder.getBindingResult().hasErrors()) {                        if (isBindExceptionRequired(binder, parameter)) {                      throw new BindException(binder.getBindingResult());                }            }        }                // Add resolved attribute and BindingResult at the end of the model        Map<String, Object> bindingResultModel = binder.getBindingResult().getModel();        mavContainer.removeAttributes(bindingResultModel);        mavContainer.addAllAttributes(bindingResultModel);                return binder.getTarget();    }

该办法依据request和attribute、name创立一个WebDataBinder对象，其中。而后进入bindRequestParameters办法绑定，依据reqeust中的参数创立一个MutablePropertyValues对象。MutablePropertyValues外面寄存了一个或多个PropertyValue，其中PropertyValue用于保留,单个bean属性的相干信息，比方参数名、参数值。这里须要留神的是PropertyValue并不是保留request对象的所有参数属性信息。而是一个参数属性对应一个PropertyValue。比方这里的reqeust对象，携带了两个参数，name和age，便会别离创立两个PropertyValue对象。
创立MutablePropertyValues对象化后，进入DataBinder.applyPropertyValues(DataBinder.java line737)。会依据刚刚创立的User对象。创立一个BeanWrapperImpl对象，BeanWrapperImpl实现了PropertyAccessor（属性拜访器）接口。这是spring-bean下的一个类，在Sping中，对Bean属性的存取都是通过BeanWrapperImpl类来实现的。BeanWarapperImpl在这里作用就是通过PropertyValue中的属性相干形容，注入到BeanWarapperImpl对应的java对象的属性中去。具体注入的办法是setPropertyValues，这个办法略简单。它的职责简略总结起来就是依据属性名调用对应的set...办法。比方注入User对象的name属性时，通过反射获取setName办法。如果有该办法便调用。这也是为什么在定义SpringMVC model 对象须要set...办法。

3. 参数绑定解析总结

SpringMVC初始化时，RequestMappingHandlerAdapter类会把一些默认的参数解析器增加到argumentResolvers中。当SpringMVC接管到申请后首先依据url查找对应的HandlerMethod。
遍历HandlerMethod的MethodParameter数组
依据MethodParameter的类型来查找确认应用哪个HandlerMethodArgumentResolver，遍历所有的argumentResolvers的supportsParameter(MethodParameter parameter)办法。。如果返回true，则示意查找胜利，以后MethodParameter，应用该HandlerMethodArgumentResolver。这里确认大多都是依据参数的注解曾经参数的Type来确认。
解析参数，从request中解析出MethodParameter对应的参数，这里解析进去的后果都是String类型。
转换参数，把对应String转换成具体方法所须要的类型，这里就包含了根本类型、对象、List、Set、Map。