SpringMVC源码之参数解析绑定原理

时间 2019-11-19

标签 springmvc 源码参数解析绑定原理栏目 Spring 繁體版

原文原文链接

摘要

本文从源码层面简单讲解SpringMVC的参数绑定原理

SpringMVC参数绑定相关组件的初始化过程

在理解初始化以前，先来认识一个接口

HandlerMethodArgumentResolver

方法参数解析器接口，这个接口是SpringMVC参数解析绑定的核心接口。不一样的参数类型绑定都是经过实现这个接口来实现。也能够经过实现这个接口来自定义参数解析器。这个接口中有以下两个方法

public interface HandlerMethodArgumentResolver {

    //该解析器是否支持parameter参数的解析
    boolean supportsParameter(MethodParameter parameter);

    //将方法参数从给定请求(webRequest)解析为参数值并返回
    Object resolveArgument(MethodParameter parameter,
                          ModelAndViewContainer mavContainer,
                          NativeWebRequest webRequest,
                          WebDataBinderFactory binderFactory) throws Exception;

}

初始化

RequestMappingHandlerAdapter.java类的afterPropertiesSet（line:481）方法初始化相关方法参数解析器。代码以下

public void afterPropertiesSet() {
    if (this.argumentResolvers == null) {
        //初始化SpringMVC默认的方法参数解析器，并添加至argumentResolvers（HandlerMethodArgumentResolverComposite）
        List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
        this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
    }
    if (this.initBinderArgumentResolvers == null) {
        //初始化SpringMVC默认的初始化绑定器(@InitBinder)参数解析器，并添加至initBinderArgumentResolvers（HandlerMethodArgumentResolverComposite）
        List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
        this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
    }
    if (this.returnValueHandlers == null) {
        //获取默认的方法返回值解析器
        List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
        this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
    }
    initControllerAdviceCache();
}

如今咱们进入getDefalutArgumentResolvers方法，代码以下

//默认的参数解析，建立了默认的24个参数解析器，并添加至resolvers
//这里的24个参数解析器都是针对不一样的参数类型来解析的
private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
    List<HandlerMethodArgumentResolver> resolvers = new ArrayList<HandlerMethodArgumentResolver>();

    // 基于注解的参数解析器

    //通常用于带有@RequestParam注解的简单参数绑定，简单参数好比byte、int、long、double、String以及对应的包装类型
    resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
    //用于处理带有@RequestParam注解，且参数类型为Map的解析绑定
    resolvers.add(new RequestParamMapMethodArgumentResolver());
    //通常用于处理带有@PathVariable注解的默认参数绑定
    resolvers.add(new PathVariableMethodArgumentResolver());
    //也是用于带有@PathVariable注解的Map相关参数绑定，后续还有一些默认的参数解析器。后续还有一些参数解析器，我这里都不一一解释了。想具体确认某个参数会交个哪一个参数解析器处理，能够经过如下解析器的supportsParameter(MethodParameter parameter)方法得知
    resolvers.add(new PathVariableMapMethodArgumentResolver());
    resolvers.add(new MatrixVariableMethodArgumentResolver());
    resolvers.add(new MatrixVariableMapMethodArgumentResolver());
    resolvers.add(new ServletModelAttributeMethodProcessor(false));
    resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters()));
    resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters()));
    resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
    resolvers.add(new RequestHeaderMapMethodArgumentResolver());
    resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
    resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));

    // 基于类型的参数解析器
    resolvers.add(new ServletRequestMethodArgumentResolver());
    resolvers.add(new ServletResponseMethodArgumentResolver());
    resolvers.add(new HttpEntityMethodProcessor(getMessageConverters()));
    resolvers.add(new RedirectAttributesMethodArgumentResolver());
    resolvers.add(new ModelMethodProcessor());
    resolvers.add(new MapMethodProcessor());
    resolvers.add(new ErrorsMethodArgumentResolver());
    resolvers.add(new SessionStatusMethodArgumentResolver());
    resolvers.add(new UriComponentsBuilderMethodArgumentResolver());

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

参数解析器添加至HandlerMethodArgumentResolverComposite这个类，这个也是实现了HandlerMethodArgumentResolver接口。这里运用涉及模式中的composite模式（组合模式），SpringMVC中，全部请求的参数解析都是进入HandlerMethodArgumentResolverComposite类来完成的。它有两个成员变量，以下

//它的元素在RequestMappingHandlerAdapter类的afterPropertiesSet方法中被添加，存放的是SpringMVC一些默认的HandlerMethodArgumentResolver参数解析器
private final List<HandlerMethodArgumentResolver> argumentResolvers =
            new LinkedList<HandlerMethodArgumentResolver>();
//存放已经解析过的参数，已经对应的HandlerMethodArgumentResolver解析器。加快查找过程
private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =
        new ConcurrentHashMap<MethodParameter, HandlerMethodArgumentResolver>(256);

介绍了这么多，话很少说。直接来看一个详细解析绑定过程吧

绑定过程

先看一个简单参数绑定，有以下Controller和请求,代码以下。

@Controller
@RequestMapping("/ParameterBind")
public class ParameterBindTestController {
    @ResponseBody
    @RequestMapping("/test1")
    public String test1(int id){
        System.out.println(id);
        return "test1";
    }
}

请求进入DispatcherServlet的doDispatch后，获取HandlerMethod。而后根据HandlerMethod来确认HandlerApapter，确认后执行HandlerAdapter的handle方法。这里确认HandlerApater为RequestMappingHandlerAdapter，在执行handlerMethod以前，须要处理参数的绑定。而后看看详细的参数绑定过程
执行HandlerAdapter的handler方法后，进入RequestMappingHandlerAdapter的invokeHandleMethod方法（line:711）

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

这个方法的职责是，首先获取paramType。也就是int对应的Class对象。而后根据parameter对象建立一个NamedValueInfo对象。这个对象存放的就是参数名、是否必须、参数默认值3个成员变量。而后进入resolverName方法解析参数，里面的逻辑其实很简单，就是根据方法的参数名来获取request中的参数。关键代码以下

String[] paramValues = webRequest.getParameterValues(name);
if (paramValues != null) {
    arg = paramValues.length == 1 ? paramValues[0] : paramValues;
}

因此这里返回的值就是9999,这里返回的值仍是String类型的。而须要的参数是int类型的。而后经过binder.coverIfNecessary方法把String转换为int类型返回。html

对象绑定

新加一个方法，代码以下

@ResponseBody
@RequestMapping("/test2")
public String test2(User u){
    System.out.println(u.toString());
    return "test1";
}

这个请求的参数解析绑定便会交给ServletModelAttributeMethodProcessor这个类，在初始化argumentResolvers的时候。是会建立两个不一样的ServletModelAttributeMethodProcessor对象的。

resolvers.add(new ServletModelAttributeMethodProcessor(false));
resolvers.add(new ServletModelAttributeMethodProcessor(true));

这两个有什么区别？进入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;
        }
    }

虽然test2(User u)方法没有ModelAttribute注解，可是User.class不是简单类型。因此该MethodHandler的参数u仍是会交给ServletModelAtttributeMethodProcessor处理。
看看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();
    }

该方法的职责是实例化一个parameterType的对象，而后根据request和attribute、name建立一个WebDataBinder对象，其中。而后进入bindRequestParameters方法绑定，根据reqeust中的参数建立一个MutablePropertyValues对象。MutablePropertyValues里面存放了一个或多个PropertyValue，其中PropertyValue用于保存单个bean属性的相关信息，好比参数名、参数值。这里须要注意的是PropertyValue并非保存request对象的全部参数属性信息。而是一个参数属性对应一个PropertyValue。好比这里的reqeust对象，携带了两个参数，name和age，便会分别建立两个PropertyValue对象。对应的MutablePropertyValues结构以下图
建立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...方法。若是没有set方法，参数注入便会失败。

参数解析绑定总结

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。

总结

解析所使用代码已上传至github，https://github.com/wycm/SpringMVC-Demo
以上源码是基于SpringMVC 3.2.2.RELEASE版本。以上即是SpringMVC参数解析绑定的主要过程，但愿对你们有帮助。本文可能有错误，但愿读者可以指出来。

版权声明
做者：wycm
出处：https://www.cnblogs.com/w-y-c-m/p/8443892.html
您的支持是对博主最大的鼓励，感谢您的认真阅读。
本文版权归做者全部，欢迎转载，但未经做者赞成必须保留此段声明，且在文章页面明显位置给出原文链接，不然保留追究法律责任的权利。
java