前提：当找到handler以后，那么就要让handler发挥作用，这个时候handlerAdapter就派上用场了 这里面比较复杂就是requestMappingHandlerAdapter了，其他的由于handler比较固定，基本上之前调用他们实现的接口的方法。 @Override public final boolean supports(Object handler) { return (handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler)); } supportsInternal方法子类实现，用于扩展，但在requestMappingHandlerAdapter子类中并没有做什么，直接返回true。 @Override public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { return handleInternal(request, response, (HandlerMethod) handler); } handleInternal方法也有子类实现。在调用handler之前，会做一些数据绑定，比如会查找@ControllerAdvice注解，查找@InitBinder，@ModuleAttribute,查找实现了RequestBodyAdvice的类等等。 初始化一些参数解析器，校验器 RequestMappingHandlerAdapter实现了InitializingBean接口，所以在初始化这个adapter并且设置了相应的属性之后就会调用afterPropertiesSet方法 @Override public void afterPropertiesSet() { // Do this first, it may add ResponseBody advice beans //初始化@ControllerAdvice标注的类 initControllerAdviceCache(); if (this.argumentResolvers == null) { List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers(); this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers); } if (this.initBinderArgumentResolvers == null) { List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers(); this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers); } if (this.returnValueHandlers == null) { List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers(); this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers); } } private void initControllerAdviceCache() { if (getApplicationContext() == null) { return; } if (logger.isInfoEnabled()) { logger.info("Looking for @ControllerAdvice: " + getApplicationContext()); } //在applicationContext容器中找到被@controllerAdvice标注的bean，并排序 List<ControllerAdviceBean> beans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext()); AnnotationAwareOrderComparator.sort(beans); //创建实现了@responseBodyAdvice的bean List<Object> requestResponseBodyAdviceBeans = new ArrayList<Object>(); for (ControllerAdviceBean bean : beans) { //查找被@ModelAttribute注解标注的方法 Set<Method> attrMethods = MethodIntrospector.selectMethods(bean.getBeanType(), MODEL_ATTRIBUTE_METHODS); if (!attrMethods.isEmpty()) { this.modelAttributeAdviceCache.put(bean, attrMethods); if (logger.isInfoEnabled()) { logger.info("Detected @ModelAttribute methods in " + bean); } } //查找被@InitBinder注解标注的方法 Set<Method> binderMethods = MethodIntrospector.selectMethods(bean.getBeanType(), INIT_BINDER_METHODS); if (!binderMethods.isEmpty()) { this.initBinderAdviceCache.put(bean, binderMethods); if (logger.isInfoEnabled()) { logger.info("Detected @InitBinder methods in " + bean); } } //查找父类是RequestBodyAdvice的bean if (RequestBodyAdvice.class.isAssignableFrom(bean.getBeanType())) { requestResponseBodyAdviceBeans.add(bean); if (logger.isInfoEnabled()) { logger.info("Detected RequestBodyAdvice bean in " + bean); } } //查找父类是ResponseBodyAdvice的bean if (ResponseBodyAdvice.class.isAssignableFrom(bean.getBeanType())) { requestResponseBodyAdviceBeans.add(bean); if (logger.isInfoEnabled()) { logger.info("Detected ResponseBodyAdvice bean in " + bean); } } } if (!requestResponseBodyAdviceBeans.isEmpty()) { //将使用@ControllerAdvice注解找的bean放到最前面 this.requestResponseBodyAdvice.addAll(0, requestResponseBodyAdviceBeans); } 方法返回后 接下来就开始初始化解析器了 if (this.argumentResolvers == null) { List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers(); this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers); } getDefaultArgumentResolvers方法 private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() { List<HandlerMethodArgumentResolver> resolvers = new ArrayList<HandlerMethodArgumentResolver>(); // Annotation-based argument resolution基于注解参数解析器 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 ServletModelAttributeMethodProcessor(false)); resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice)); resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters(), this.requestResponseBodyAdvice)); resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory())); resolvers.add(new RequestHeaderMapMethodArgumentResolver()); resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory())); resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory())); // Type-based argument resolution resolvers.add(new ServletRequestMethodArgumentResolver()); resolvers.add(new ServletResponseMethodArgumentResolver()); resolvers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice)); 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()); } // Catch-all可以处理所有类型的参数解析器 resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true)); resolvers.add(new ServletModelAttributeMethodProcessor(true)); return resolvers; } 准备就绪之后，开始调用handleInternal方法 @Override protected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception { ModelAndView mav; //检查是否支持当前请求的方法，检查session是否为必须的 checkRequest(request); // Execute invokeHandlerMethod in synchronized block if required. //执行session同步 if (this.synchronizeOnSession) { HttpSession session = request.getSession(false); if (session != null) { Object mutex = WebUtils.getSessionMutex(session); synchronized (mutex) { mav = invokeHandlerMethod(request, response, handlerMethod); } } else { // No HttpSession available -> no mutex necessary mav = invokeHandlerMethod(request, response, handlerMethod); } } else { // No synchronization on session demanded at all... mav = invokeHandlerMethod(request, response, handlerMethod); } if (!response.containsHeader(HEADER_CACHE_CONTROL)) { if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) { applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers); } else { prepareResponse(response); } } return mav; } protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception { ServletWebRequest webRequest = new ServletWebRequest(request, response); //创建data绑定工厂，数据绑定是用来与String进行参数转换的 WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod); ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory); ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod); invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers); 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); if (asyncManager.hasConcurrentResult()) { Object result = asyncManager.getConcurrentResult(); mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0]; asyncManager.clearConcurrentResult(); if (logger.isDebugEnabled()) { logger.debug("Found concurrent result value [" + result + "]"); } invocableMethod = invocableMethod.wrapConcurrentResult(result); } invocableMethod.invokeAndHandle(webRequest, mavContainer); if (asyncManager.isConcurrentHandlingStarted()) { return null; } return getModelAndView(mavContainer, modelFactory, webRequest); } private WebDataBinderFactory getDataBinderFactory(HandlerMethod handlerMethod) throws Exception { Class<?> handlerType = handlerMethod.getBeanType(); //从缓存中查找是否已经存在这个类型对应的@InitBinder方法 Set<Method> methods = this.initBinderCache.get(handlerType); if (methods == null) { //如果为空，就对当前handler进行遍历查找@InitBinder的方法 methods = MethodIntrospector.selectMethods(handlerType, INIT_BINDER_METHODS); //保存到缓存中 this.initBinderCache.put(handlerType, methods); } List<InvocableHandlerMethod> initBinderMethods = new ArrayList<InvocableHandlerMethod>(); // Global methods first遍历全局（也就是@ControllerAdvice标注的类的@InitBinder方法，这个在adapter的afterPropertiesSet方法中初始化的） for (Entry<ControllerAdviceBean, Set<Method>> entry : this.initBinderAdviceCache.entrySet()) { if (entry.getKey().isApplicableToBeanType(handlerType)) { Object bean = entry.getKey().resolveBean(); for (Method method : entry.getValue()) { //创建InvocableHandlerMethod对象并添加 initBinderMethods.add(createInitBinderMethod(bean, method)); } } } //添加完全局的之后，再添加当前处理器的 for (Method method : methods) { Object bean = handlerMethod.getBean(); initBinderMethods.add(createInitBinderMethod(bean, method)); } return createDataBinderFactory(initBinderMethods); } public boolean isApplicableToBeanType(Class<?> beanType) { //如果@controllerAdvice什么属性都没有写，说明将所有配置的方法应用到所有的handler中 if (!hasSelectors()) { return true; } else if (beanType != null) { for (String basePackage : this.basePackages) { if (beanType.getName().startsWith(basePackage)) { return true; } } for (Class<?> clazz : this.assignableTypes) { if (ClassUtils.isAssignable(clazz, beanType)) { return true; } } for (Class<? extends Annotation> annotationClass : this.annotations) { if (AnnotationUtils.findAnnotation(beanType, annotationClass) != null) { return true; } } } return false; } private InvocableHandlerMethod createInitBinderMethod(Object bean, Method method) { //InvocableHandlerMethod 是handlerMethod的子类 InvocableHandlerMethod binderMethod = new InvocableHandlerMethod(bean, method); binderMethod.setHandlerMethodArgumentResolvers(this.initBinderArgumentResolvers); binderMethod.setDataBinderFactory(new DefaultDataBinderFactory(this.webBindingInitializer)); binderMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer); return binderMethod; } 最后返回一个createDataBinderFactory(initBinderMethods); 回到invokeHandlerMethod方法，创建了DataBinderFactory后，接下来就是创建ModelFactory了 private ModelFactory getModelFactory(HandlerMethod handlerMethod, WebDataBinderFactory binderFactory) { //获取SessionAttributesHandler，这个处理器用来处理@SessionAttributes注解的方法 SessionAttributesHandler sessionAttrHandler = getSessionAttributesHandler(handlerMethod); Class<?> handlerType = handlerMethod.getBeanType(); //获取标注了@ModelAttribute的方法 Set<Method> methods = this.modelAttributeCache.get(handlerType); if (methods == null) { //如果缓存中没有就重新查找当前标注了@ModelAttribute的方法，并存到缓存中 methods = MethodIntrospector.selectMethods(handlerType, MODEL_ATTRIBUTE_METHODS); this.modelAttributeCache.put(handlerType, methods); } List<InvocableHandlerMethod> attrMethods = new ArrayList<InvocableHandlerMethod>(); // Global methods first添加全局的@ModelAttribute注解的方法 for (Entry<ControllerAdviceBean, Set<Method>> entry : this.modelAttributeAdviceCache.entrySet()) { if (entry.getKey().isApplicableToBeanType(handlerType)) { Object bean = entry.getKey().resolveBean(); for (Method method : entry.getValue()) { attrMethods.add(createModelAttributeMethod(binderFactory, bean, method)); } } } for (Method method : methods) { Object bean = handlerMethod.getBean(); attrMethods.add(createModelAttributeMethod(binderFactory, bean, method)); } //创建ModelFactory工厂 return new ModelFactory(attrMethods, binderFactory, sessionAttrHandler); } //第一个参数传入的是标记了@ModelAttribute的方法，第二个参数数据绑定，第三个是@SessionAttributes注解对应的处理器 public ModelFactory(List<InvocableHandlerMethod> handlerMethods, WebDataBinderFactory binderFactory, SessionAttributesHandler attributeHandler) { if (handlerMethods != null) { for (InvocableHandlerMethod handlerMethod : handlerMethods) { this.modelMethods.add(new ModelMethod(handlerMethod)); } } this.dataBinderFactory = binderFactory; this.sessionAttributesHandler = attributeHandler; } private ModelMethod(InvocableHandlerMethod handlerMethod) { this.handlerMethod = handlerMethod; for (MethodParameter parameter : handlerMethod.getMethodParameters()) { if (parameter.hasParameterAnnotation(ModelAttribute.class)) { this.dependencies.add(getNameForParameter(parameter)); } } } 当缓存什么的都弄好了之后就开始处理当前handleMethod了 ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod); invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers); invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers); invocableMethod.setDataBinderFactory(binderFactory); invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer); ModelAndViewContainer mavContainer = new ModelAndViewContainer(); //将FlashMap中的属性添加到mav容器中 mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request)); modelFactory.initModel(webRequest, mavContainer, invocableMethod); mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect); public void initModel(NativeWebRequest request, ModelAndViewContainer container, HandlerMethod handlerMethod) throws Exception { //从sessionAttribute中回复参数到mavContainer中 Map<String, ?> sessionAttributes = this.sessionAttributesHandler.retrieveAttributes(request); //合并参数，因为sessionAttribute中的参数可能会与flashmap中的参数冲突，但不会覆盖原来的参数 container.mergeAttributes(sessionAttributes); //调用modelAttribute注解的方法 invokeModelAttributeMethods(request, container); for (String name : findSessionAttributeArguments(handlerMethod)) { if (!container.containsAttribute(name)) { Object value = this.sessionAttributesHandler.retrieveAttribute(request, name); if (value == null) { throw new HttpSessionRequiredException("Expected session attribute '" + name + "'"); } container.addAttribute(name, value); } } } invokeModelAttributeMethods(request, container); private void invokeModelAttributeMethods(NativeWebRequest request, ModelAndViewContainer container) throws Exception { while (!this.modelMethods.isEmpty()) { //获取第一个modelMethod方法，并将其移除，等下次调用的时候就就是第二个modelMethod，如果参数有@ModelAttribute，则优先处理 InvocableHandlerMethod modelMethod = getNextModelMethod(container).getHandlerMethod(); //获取模型值，即属性key值 String modelName = modelMethod.getMethodAnnotation(ModelAttribute.class).value(); //如果已经存在了就不再调用 if (container.containsAttribute(modelName)) { continue; } //调用方法 Object returnValue = modelMethod.invokeForRequest(request, container); if (!modelMethod.isVoid()){ String returnValueName = getNameForReturnValue(returnValue, modelMethod.getReturnType()); if (!container.containsAttribute(returnValueName)) { container.addAttribute(returnValueName, returnValue); } } } } private ModelMethod getNextModelMethod(ModelAndViewContainer container) { //遍历所有的modelmethod，如果他们的依赖存在，就优先使用这个方法参数与中有@ModelAttribute注解的modelmethod方法，否则就直接返回第一个modelmethod for (ModelMethod modelMethod : this.modelMethods) { if (modelMethod.checkDependencies(container)) { if (logger.isTraceEnabled()) { logger.trace("Selected @ModelAttribute method " + modelMethod); } this.modelMethods.remove(modelMethod); return modelMethod; } } //获取第一个modelmethod，并将它已移除 ModelMethod modelMethod = this.modelMethods.get(0); if (logger.isTraceEnabled()) { logger.trace("Selected @ModelAttribute method (not present: " + modelMethod.getUnresolvedDependencies(container)+ ") " + modelMethod); } this.modelMethods.remove(modelMethod); return modelMethod; } // public Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception { //获取方法参数值 Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs); if (logger.isTraceEnabled()) { StringBuilder sb = new StringBuilder("Invoking ["); sb.append(getBeanType().getSimpleName()).append("."); sb.append(getMethod().getName()).append("] method with arguments "); sb.append(Arrays.asList(args)); logger.trace(sb.toString()); } Object returnValue = doInvoke(args); if (logger.isTraceEnabled()) { logger.trace("Method [" + getMethod().getName() + "] returned [" + returnValue + "]"); } return returnValue; } private Object[] getMethodArgumentValues(NativeWebRequest request, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception { //获取方法参数数组 MethodParameter[] parameters = getMethodParameters(); Object[] args = new Object[parameters.length]; for (int i = 0; i < parameters.length; i++) { MethodParameter parameter = parameters[i]; //给当前参数封装对象设置参数名解析器 parameter.initParameterNameDiscovery(this.parameterNameDiscoverer); //给当前参数封装对象设置参数类型 GenericTypeResolver.resolveParameterType(parameter, getBean().getClass()); //尝试从给定的providedArgs参数查找对应类型的参数，如果找到就设置这个值到args数组中，这个providedArgs在这里是没有传递任何值的 args[i] = resolveProvidedArgument(parameter, providedArgs); //如果不为空就continue，表示已经有值了 if (args[i] != null) { continue; } //查找有没有支持此参数解析的解析器 if (this.argumentResolvers.supportsParameter(parameter)) { try { //解析参数 args[i] = this.argumentResolvers.resolveArgument( parameter, mavContainer, request, this.dataBinderFactory); continue; } catch (Exception ex) { if (logger.isDebugEnabled()) { logger.debug(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; } (this.argumentResolvers.supportsParameter(parameter) private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) { //先从缓存中找，如果没有找到，在遍历所有的解析器，这个解析器集合保存在一个解析器Composite类中，SpringMVC中这样的类一般是使用的责任链模式 HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter); if (result == null) { for (HandlerMethodArgumentResolver methodArgumentResolver : this.argumentResolvers) { if (logger.isTraceEnabled()) { logger.trace("Testing if argument resolver [" + methodArgumentResolver + "] supports [" + parameter.getGenericParameterType() + "]"); } if (methodArgumentResolver.supportsParameter(parameter)) { result = methodArgumentResolver; this.argumentResolverCache.put(parameter, result); break; } } } return result; } this.argumentResolvers.resolveArgument( parameter, mavContainer, request, this.dataBinderFactory);方法体如下 @Override public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception { //获取参数解析器，如果没有获取到就抛出错误 HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter); if (resolver == null) { throw new IllegalArgumentException("Unknown parameter type [" + parameter.getParameterType().getName() + "]"); } return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory); } HandlerMethodArgumentResolver的实现类有很多，这里选几个分析一下 首先先分析一下RequestResponseBodyMethodProcessor，这是一个集argumentResolve和handlerReturnValue于一身的类 直接看解析方法resolveArgument： @Override public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception { //使用转化器进行参数的转换 Object arg = readWithMessageConverters(webRequest, parameter, parameter.getGenericParameterType()); String name = Conventions.getVariableNameForParameter(parameter); 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()); } } mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult()); return arg; } protected <T> Object readWithMessageConverters(NativeWebRequest webRequest, MethodParameter methodParam, Type paramType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException { HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class); ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(servletRequest); Object arg = readWithMessageConverters(inputMessage, methodParam, paramType); if (arg == null) { if (methodParam.getParameterAnnotation(RequestBody.class).required()) { throw new HttpMessageNotReadableException("Required request body is missing: " + methodParam.getMethod().toGenericString()); } } return arg; } readWithMessageConverters方法 protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter param, Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException { MediaType contentType; boolean noContentType = false; try { //获取请求的ContentType contentType = inputMessage.getHeaders().getContentType(); } catch (InvalidMediaTypeException ex) { throw new HttpMediaTypeNotSupportedException(ex.getMessage()); } if (contentType == null) { noContentType = true; //设置默认的contentType contentType = MediaType.APPLICATION_OCTET_STREAM; } //获取类的类型 Class<?> contextClass = (param != null ? param.getContainingClass() : null); //获取的参数的泛型类型 Class<T> targetClass = (targetType instanceof Class<?> ? (Class<T>) targetType : null); //如果没有就再次尝试设置一遍 if (targetClass == null) { ResolvableType resolvableType = (param != null ? ResolvableType.forMethodParameter(param) : ResolvableType.forType(targetType)); targetClass = (Class<T>) resolvableType.resolve(); } //获取请求方法 HttpMethod httpMethod = ((HttpRequest) inputMessage).getMethod(); Object body = NO_VALUE; try { inputMessage = new EmptyBodyCheckingHttpInputMessage(inputMessage); //遍历这个解析器中的所有的converter，判断是否是泛化的转换器 for (HttpMessageConverter<?> converter : this.messageConverters) { Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter.getClass(); if (converter instanceof GenericHttpMessageConverter) { GenericHttpMessageConverter<?> genericConverter = (GenericHttpMessageConverter<?>) converter; //判断是否能够进行解析 if (genericConverter.canRead(targetType, contextClass, contentType)) { if (logger.isDebugEnabled()) { logger.debug("Read [" + targetType + "] as "" + contentType + "" with [" + converter + "]"); } if (inputMessage.getBody() != null) { //如果请求体有值，那么就尝试调用实现了RequestAdvice的类，对请求体进行预先处理 inputMessage = getAdvice().beforeBodyRead(inputMessage, param, targetType, converterType); //使用converter进行转化 body = genericConverter.read(targetType, contextClass, inputMessage); //对处理完的body进行后置处理，就是使用实现了ResponseAdvice的类进行处理 body = getAdvice().afterBodyRead(body, inputMessage, param, targetType, converterType); } else { body = null; //处理空请求体 body = getAdvice().handleEmptyBody(body, inputMessage, param, targetType, converterType); } break; } } //如果不是泛化的转换器，那么就判断目标class是否为空。 else if (targetClass != null) { if (converter.canRead(targetClass, contentType)) { if (logger.isDebugEnabled()) { logger.debug("Read [" + targetType + "] as "" + contentType + "" with [" + converter + "]"); } if (inputMessage.getBody() != null) { inputMessage = getAdvice().beforeBodyRead(inputMessage, param, targetType, converterType); body = ((HttpMessageConverter<T>) converter).read(targetClass, inputMessage); body = getAdvice().afterBodyRead(body, inputMessage, param, targetType, converterType); } else { body = null; body = getAdvice().handleEmptyBody(body, inputMessage, param, targetType, converterType); } break; } } } } catch (IOException ex) { throw new HttpMessageNotReadableException("Could not read document: " + ex.getMessage(), ex); } //如果body没有被处理过 if (body == NO_VALUE) { if (httpMethod == null || !SUPPORTED_METHODS.contains(httpMethod) || (noContentType && inputMessage.getBody() == null)) { return null; } throw new HttpMediaTypeNotSupportedException(contentType, this.allSupportedMediaTypes); } canRead,判断是否可以处理这个请求类型的数据，对于json来说text/html肯定是不能进行处理的 protected boolean canRead(MediaType mediaType) { if (mediaType == null) { return true; } for (MediaType supportedMediaType : getSupportedMediaTypes()) { if (supportedMediaType.includes(mediaType)) { return true; } } return false; } 解析好后继续 public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception { Object arg = readWithMessageConverters(webRequest, parameter, parameter.getGenericParameterType()); //如果指定的参数名为URL，连续两个大写字母的那么就保持它原来的样子，其他的就把第一个字母变成小写，如果是集合类的那么将泛型类型加上list字符串 String name = Conventions.getVariableNameForParameter(parameter); //创建数据绑定器 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()); } } //保存绑定数据后的结果信息 mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult()); return arg; } public static String getVariableNameForParameter(MethodParameter parameter) { Assert.notNull(parameter, "MethodParameter must not be null"); Class<?> valueClass; boolean pluralize = false; if (parameter.getParameterType().isArray()) { //获取数组的元素类型 valueClass = parameter.getParameterType().getComponentType(); pluralize = true; } else if (Collection.class.isAssignableFrom(parameter.getParameterType())) { //获取集合的泛型参数类型 valueClass = GenericCollectionTypeResolver.getCollectionParameterType(parameter); if (valueClass == null) { throw new IllegalArgumentException( "Cannot generate variable name for non-typed Collection parameter type"); } //设置为TRUE pluralize = true; } else { valueClass = parameter.getParameterType(); } //获取名字，出去包名 String name = ClassUtils.getShortNameAsProperty(valueClass); //如果pluralize为true，那么就在名字候命加上list字符串 return (pluralize ? pluralize(name) : name); } @Override public final WebDataBinder createBinder(NativeWebRequest webRequest, Object target, String objectName) throws Exception { //创建webdata 绑定 WebDataBinder dataBinder = createBinderInstance(target, objectName, webRequest); if (this.initializer != null) { this.initializer.initBinder(dataBinder, webRequest); } //开始调用绑定方法 initBinder(dataBinder, webRequest); return dataBinder; } initBinder方法 public void initBinder(WebDataBinder binder, NativeWebRequest request) throws Exception { for (InvocableHandlerMethod binderMethod : this.binderMethods) { if (isBinderMethodApplicable(binderMethod, binder)) { //跟前面调用方法是一样的，不过这次传入了一个提供的参数，那就是webDataBinder的实例，所以我们可以在@initBinder方法中添加一些校验器，编辑器等等操作。 Object returnValue = binderMethod.invokeForRequest(request, null, binder); if (returnValue != null) { throw new IllegalStateException("@InitBinder methods should return void: " + binderMethod); } } } } 创建了webDataBinder之后，并且如果我们在@initBinder注解的方法中做了一些事情，比如添加了校验器啥的，接下来的代码如下 if (arg != null) { validateIfApplicable(binder, parameter); if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) { throw new MethodArgumentNotValidException(parameter, binder.getBindingResult()); } } mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult()); //校验 protected void validateIfApplicable(WebDataBinder binder, MethodParameter methodParam) { Annotation[] annotations = methodParam.getParameterAnnotations(); for (Annotation ann : annotations) { //只有注释了@valid的参数才会进行校验 Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class); if (validatedAnn != null || ann.annotationType().getSimpleName().startsWith("Valid")) { //获取注解中value值，这些值可以最为校验分组用，SpringMVC的校验使用的JSR303校验和自定义校验器 Object hints = (validatedAnn != null ? validatedAnn.value() : AnnotationUtils.getValue(ann)); Object[] validationHints = (hints instanceof Object[] ? (Object[]) hints : new Object[] {hints}); //开始校验 binder.validate(validationHints); break; } } } //遍历校验器进行校验 public void validate(Object... validationHints) { for (Validator validator : getValidators()) { //使用JSR303的方式校验 if (!ObjectUtils.isEmpty(validationHints) && validator instanceof SmartValidator) { ((SmartValidator) validator).validate(getTarget(), getBindingResult(), validationHints); } else if (validator != null) { //使用自定义校验器校验 validator.validate(getTarget(), getBindingResult()); } } } 好了，对于RequestBody注解的参数就是这么解析的。 来研究一下ModelAttributeMethodProcessor是怎么解析的 @Override public boolean supportsParameter(MethodParameter parameter) { //判断参数是否有@ModelAttribute注解 if (parameter.hasParameterAnnotation(ModelAttribute.class)) { return true; } else if (this.annotationNotRequired) { return !BeanUtils.isSimpleProperty(parameter.getParameterType()); } else { return false; } } //解析参数 public final Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception { //获取参数名，先从注解的指定的名称找，如果没有就用Conventions.getVariableNameForParameter(parameter)方法获取参数名，这个在前面就已经使用过了 String name = ModelFactory.getNameForParameter(parameter); //判断这个参数是否在MavContainer中已经存在了，如果存在就直接获取这个参数值，如果没有找到就去request中寻找参数 Object attribute = (mavContainer.containsAttribute(name) ? mavContainer.getModel().get(name) : createAttribute(name, parameter, binderFactory, webRequest)); //创建WebDataBinder ，调用@initBinder注解的绑定方法 WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name); if (binder.getTarget() != null) { //这里是绑定请求的参数 bindRequestParameters(binder, webRequest); validateIfApplicable(binder, parameter); if (binder.getBindingResult().hasErrors() && 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.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter); } protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest request) { ServletRequest servletRequest = request.getNativeRequest(ServletRequest.class); ServletRequestDataBinder servletBinder = (ServletRequestDataBinder) binder; servletBinder.bind(servletRequest); } public void bind(ServletRequest request) { //解析创建成一个MutablePropertyValues MutablePropertyValues mpvs = new ServletRequestParameterPropertyValues(request); //判断是否为MultipartRequest 类型，如果是就获取这种类型的请求 MultipartRequest multipartRequest = WebUtils.getNativeRequest(request, MultipartRequest.class); if (multipartRequest != null) { bindMultipart(multipartRequest.getMultiFileMap(), mpvs); } //获取url中的变量Map用url定义的参数值，如果已经在mpvs存在的参数将不会覆盖 addBindValues(mpvs, request); //绑定参数 doBind(mpvs); } //创建MutablePropertyValues时的解析，解析成一个去掉指定前缀的Map，当然这里没有设置前缀 public static Map<String, Object> getParametersStartingWith(ServletRequest request, String prefix) { Assert.notNull(request, "Request must not be null"); Enumeration<String> paramNames = request.getParameterNames(); Map<String, Object> params = new TreeMap<String, Object>(); if (prefix == null) { prefix = ""; } while (paramNames != null && paramNames.hasMoreElements()) { String paramName = paramNames.nextElement(); if ("".equals(prefix) || paramName.startsWith(prefix)) { String unprefixed = paramName.substring(prefix.length()); String[] values = request.getParameterValues(paramName); if (values == null || values.length == 0) { // Do nothing, no values found at all. } else if (values.length > 1) { params.put(unprefixed, values); } else { params.put(unprefixed, values[0]); } } } return params; } 然后在传入这个paramMap到构造器 public MutablePropertyValues(Map<?, ?> original) { // We can optimize this because it's all new: // There is no replacement of existing property values. if (original != null) { this.propertyValueList = new ArrayList<PropertyValue>(original.size()); for (Map.Entry<?, ?> entry : original.entrySet()) { //propertyValueList是一个list，存储着PropertyValue对象，这个对象存着请求参数的名称和对应的值。 this.propertyValueList.add(new PropertyValue(entry.getKey().toString(), entry.getValue())); } } else { this.propertyValueList = new ArrayList<PropertyValue>(0); } } protected void bindMultipart(Map<String, List<MultipartFile>> multipartFiles, MutablePropertyValues mpvs) { for (Map.Entry<String, List<MultipartFile>> entry : multipartFiles.entrySet()) { String key = entry.getKey(); List<MultipartFile> values = entry.getValue(); if (values.size() == 1) { MultipartFile value = values.get(0); //默认情况下会保存空的MultipartFiles,所以即使你的上传文件框没有上传文件，也会存在空的文件 if (isBindEmptyMultipartFiles() || !value.isEmpty()) { mpvs.add(key, value); } } else { mpvs.add(key, values); } } } 开始绑定参数 @Override protected void doBind(MutablePropertyValues mpvs) { //检查有default值前缀的参数 checkFieldDefaults(mpvs); //检查有标记前缀的参数 checkFieldMarkers(mpvs); 真正绑定参数的方法 super.doBind(mpvs); } checkFieldDefaults方法： protected void checkFieldDefaults(MutablePropertyValues mpvs) { //如果字段默认的前缀不为空，那么就去掉前缀，然后判断这个属性在对应的参数对象中是否可写，并且在mpvs中不存在这个属性参会加入到mvps中，并且移除之前的 if (getFieldDefaultPrefix() != null) { String fieldDefaultPrefix = getFieldDefaultPrefix(); PropertyValue[] pvArray = mpvs.getPropertyValues(); for (PropertyValue pv : pvArray) { if (pv.getName().startsWith(fieldDefaultPrefix)) { String field = pv.getName().substring(fieldDefaultPrefix.length()); if (getPropertyAccessor().isWritableProperty(field) && !mpvs.contains(field)) { mpvs.add(field, pv.getValue()); } mpvs.removePropertyValue(pv); } } } } 这个方法和上面的是一样的道理 protected void checkFieldMarkers(MutablePropertyValues mpvs) { if (getFieldMarkerPrefix() != null) { String fieldMarkerPrefix = getFieldMarkerPrefix(); PropertyValue[] pvArray = mpvs.getPropertyValues(); for (PropertyValue pv : pvArray) { if (pv.getName().startsWith(fieldMarkerPrefix)) { String field = pv.getName().substring(fieldMarkerPrefix.length()); if (getPropertyAccessor().isWritableProperty(field) && !mpvs.contains(field)) { Class<?> fieldType = getPropertyAccessor().getPropertyType(field); mpvs.add(field, getEmptyValue(field, fieldType)); } mpvs.removePropertyValue(pv); } } } } 接下来调用了 protected void doBind(MutablePropertyValues mpvs) { //检查是否是运行的字段，这些字段都可以在@initBinder注解的方法中指定 checkAllowedFields(mpvs); //判断是否为必须的字段 checkRequiredFields(mpvs); //应用属性值 applyPropertyValues(mpvs); } //应用指定的值到对应的对象中 protected void applyPropertyValues(MutablePropertyValues mpvs) { try { // Bind request parameters onto target object. //绑定请求参数到目标参数中 getPropertyAccessor().setPropertyValues(mpvs, isIgnoreUnknownFields(), isIgnoreInvalidFields()); } catch (PropertyBatchUpdateException ex) { // Use bind error processor to create FieldErrors. for (PropertyAccessException pae : ex.getPropertyAccessExceptions()) { getBindingErrorProcessor().processPropertyAccessException(pae, getInternalBindingResult()); } } } 接下来就是对参数进行类型转换 return binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter); public <T> T convertIfNecessary(String propertyName, Object oldValue, Object newValue, Class<T> requiredType, TypeDescriptor typeDescriptor) throws IllegalArgumentException { // Custom editor for this type?获取@initBinder注解的方法中自定义的参数编辑器 PropertyEditor editor = this.propertyEditorRegistry.findCustomEditor(requiredType, propertyName); ConversionFailedException conversionAttemptEx = null; // No custom editor but custom ConversionService specified? ConversionService conversionService = this.propertyEditorRegistry.getConversionService(); if (editor == null && conversionService != null && newValue != null && typeDescriptor != null) { TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue); if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) { try { //如果可以转换就进行转换 return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor); } catch (ConversionFailedException ex) { // fallback to default conversion logic below conversionAttemptEx = ex; } } } Object convertedValue = newValue; 。。。。。。。。。。。。。。。。。。。。。。。（代码较长，省略） 当所有的参数都解析完毕后，调用方法 Object returnValue = doInvoke(args); //如果不出例外，就直接使用放射方法调用 protected Object doInvoke(Object... args) throws Exception { ReflectionUtils.makeAccessible(getBridgedMethod()); try { return getBridgedMethod().invoke(getBean(), args); } catch (IllegalArgumentException ex) { assertTargetBean(getBridgedMethod(), getBean(), args); String message = (ex.getMessage() != null ? ex.getMessage() : "Illegal argument"); throw new IllegalStateException(getInvocationErrorMessage(message, args), ex); } catch (InvocationTargetException ex) { // Unwrap for HandlerExceptionResolvers ... Throwable targetException = ex.getTargetException(); if (targetException instanceof RuntimeException) { throw (RuntimeException) targetException; } else if (targetException instanceof Error) { throw (Error) targetException; } else if (targetException instanceof Exception) { throw (Exception) targetException; } else { String msg = getInvocationErrorMessage("Failed to invoke controller method", args); throw new IllegalStateException(msg, targetException); } } }