Spring MVC学习教程之RequestMappingHandlerAdapter详解

public interface HandlerAdapter {// 用于判断当前HandlerAdapter是否能够处理当前请求boolean supports(Object handler);// 如果当前HandlerAdapter能够用于适配当前请求，那么就会处理当前请求中// 诸如参数和返回值等信息，以便能够直接委托给具体的Handler处理ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;// 获取当前请求的最后更改时间，主要用于供给浏览器判断当前请求是否修改过，// 从而判断是否可以直接使用之前缓存的结果long getLastModified(HttpServletRequest request, Object handler);}

// AbstractHandlerMethodAdapter@Overridepublic final boolean supports(Object handler) {// 判断当前handler是否为HandlerMethod类型，并且判断supportsInternal()方法返回值是否为true，// 这里supportsInternal()方法是提供给子类实现的一个方法，对于RequestMappingHandlerAdapter// 而言，其返回值始终是true，因为其只需要处理的handler是HandlerMethod类型的即可return (handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler));}

// RequestMappingHandlerAdapter@Overrideprotected boolean supportsInternal(HandlerMethod handlerMethod) {// 这里RequestMappingHandlerAdapter只是对supportsInternal()返回true，因为其只需要// 处理的handler类型是HandlerMethod类型即可return true;}

@Overrideprotected ModelAndView handleInternal(HttpServletRequest request,HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {ModelAndView mav;checkRequest(request);// 判断当前是否需要支持在同一个session中只能线性地处理请求if (this.synchronizeOnSession) {// 获取当前请求的session对象HttpSession session = request.getSession(false);if (session != null) {// 为当前session生成一个唯一的可以用于锁定的keyObject mutex = WebUtils.getSessionMutex(session);synchronized (mutex) {// 对HandlerMethod进行参数等的适配处理，并调用目标handlermav = invokeHandlerMethod(request, response, handlerMethod);}} else {// 如果当前不存在session，则直接对HandlerMethod进行适配mav = invokeHandlerMethod(request, response, handlerMethod);}} else {// 如果当前不需要对session进行同步处理，则直接对HandlerMethod进行适配mav = invokeHandlerMethod(request, response, handlerMethod);}// 判断当前请求头中是否包含Cache-Control请求头，如果不包含，则对当前response进行处理，// 为其设置过期时间if (!response.containsHeader(HEADER_CACHE_CONTROL)) {// 如果当前SessionAttribute中存在配置的attributes，则为其设置过期时间。// 这里SessionAttribute主要是通过@SessionAttribute注解生成的if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);} else {// 如果当前不存在SessionAttributes，则判断当前是否存在Cache-Control设置，// 如果存在，则按照该设置进行response处理，如果不存在，则设置response中的// Cache的过期时间为-1，即立即失效prepareResponse(response);}}return mav;}

@Nullableprotected ModelAndView invokeHandlerMethod(HttpServletRequest request,HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {ServletWebRequest webRequest = new ServletWebRequest(request, response);try {// 获取容器中全局配置的InitBinder和当前HandlerMethod所对应的Controller中// 配置的InitBinder，用于进行参数的绑定WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);// 获取容器中全局配置的ModelAttribute和当前当前HandlerMethod所对应的Controller// 中配置的ModelAttribute，这些配置的方法将会在目标方法调用之前进行调用ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);// 将handlerMethod封装为一个ServletInvocableHandlerMethod对象，// 该对象用于对当前request的整体调用流程进行了封装ServletInvocableHandlerMethod invocableMethod =createInvocableHandlerMethod(handlerMethod);if (this.argumentResolvers != null) {// 设置当前容器中配置的所有ArgumentResolverinvocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);}if (this.returnValueHandlers != null) {// 设置当前容器中配置的所有ReturnValueHandlerinvocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);}// 将前面创建的WebDataBinderFactory设置到ServletInvocableHandlerMethod中invocableMethod.setDataBinderFactory(binderFactory);// 设置ParameterNameDiscoverer，该对象将按照一定的规则获取当前参数的名称invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);ModelAndViewContainer mavContainer = new ModelAndViewContainer();mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));// 这里initModel()方法主要作用是调用前面获取到的@ModelAttribute标注的方法，// 从而达到@ModelAttribute标注的方法能够在目标Handler调用之前调用的目的modelFactory.initModel(webRequest, mavContainer, invocableMethod);mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);// 获取当前的AsyncWebRequest，这里AsyncWebRequest的主要作用是用于判断目标// handler的返回值是否为WebAsyncTask或DefferredResult，如果是这两种中的一种，// 则说明当前请求的处理应该是异步的。所谓的异步，指的是当前请求会将Controller中// 封装的业务逻辑放到一个线程池中进行调用，待该调用有返回结果之后再返回到response中。// 这种处理的优点在于用于请求分发的线程能够解放出来，从而处理更多的请求，只有待目标任务// 完成之后才会回来将该异步任务的结果返回。AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);asyncWebRequest.setTimeout(this.asyncRequestTimeout);// 封装异步任务的线程池，request和interceptors到WebAsyncManager中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 + "]");}// 封装异步任务的处理结果，虽然封装的是一个HandlerMethod，但只是Spring简单的封装// 的一个Callable对象，该对象中直接将调用结果返回了。这样封装的目的在于能够统一的// 进行右面的ServletInvocableHandlerMethod.invokeAndHandle()方法的调用invocableMethod = invocableMethod.wrapConcurrentResult(result);}// 对请求参数进行处理，调用目标HandlerMethod，并且将返回值封装为一个ModelAndView对象invocableMethod.invokeAndHandle(webRequest, mavContainer);if (asyncManager.isConcurrentHandlingStarted()) {return null;}// 对封装的ModelAndView进行处理，主要是判断当前请求是否进行了重定向，如果进行了重定向，// 还会判断是否需要将FlashAttributes封装到新的请求中return getModelAndView(mavContainer, modelFactory, webRequest);} finally {// 调用request destruction callbacks和对SessionAttributes进行处理webRequest.requestCompleted();}}

private WebDataBinderFactory getDataBinderFactory(HandlerMethod handlerMethod) throws Exception {// 判断当前缓存中是否缓存了当前bean所需要装配的InitBinder方法，如果存在，则直接从缓存中取，// 如果不存在，则在当前bean中进行扫描获取Class<?> handlerType = handlerMethod.getBeanType();Set<Method> methods = this.initBinderCache.get(handlerType);if (methods == null) {// 在当前bean中查找所有标注了@InitBinder注解的方法，这里INIT_BINDER_METHODS就是一个// 选择器，表示只获取使用@InitBinder标注的方法methods = MethodIntrospector.selectMethods(handlerType, INIT_BINDER_METHODS);this.initBinderCache.put(handlerType, methods);}// 这里initBinderAdviceCache是在RequestMappingHandlerAdapter初始化时同步初始化的，// 其内包含的方法有如下两个特点：①当前方法所在类使用@ControllerAdvice进行标注了；// ②当前方法使用@InitBinder进行了标注。也就是说其内保存的方法可以理解为是全局类型// 的参数绑定方法List<InvocableHandlerMethod> initBinderMethods = new ArrayList<>();this.initBinderAdviceCache.forEach((clazz, methodSet) -> {// 这里判断的是当前配置的全局类型的InitBinder是否能够应用于当前bean，// 判断的方式主要在@ControllerAdvice注解中进行了声明，包括通过包名，类所在的包，// 接口或者注解的形式限定的范围if (clazz.isApplicableToBeanType(handlerType)) {Object bean = clazz.resolveBean();for (Method method : methodSet) {initBinderMethods.add(createInitBinderMethod(bean, method));}}});// 这里是将当前HandlerMethod所在bean中的InitBinder添加到需要执行的initBinderMethods中。// 这里从添加的顺序可以看出，全局类型的InitBinder会在当前bean中的InitBinder之前执行for (Method method : methods) {Object bean = handlerMethod.getBean();initBinderMethods.add(createInitBinderMethod(bean, method));}// 将需要执行的InitBinder封装到InitBinderDataBinderFactory中return createDataBinderFactory(initBinderMethods);}

private ModelFactory getModelFactory(HandlerMethod handlerMethod, WebDataBinderFactory binderFactory) {// 这里SessionAttributeHandler的作用是声明几个属性，使其能够在多个请求之间共享，// 并且其能够保证当前request返回的model中始终保有这些属性SessionAttributesHandler sessionAttrHandler = getSessionAttributesHandler(handlerMethod);// 判断缓存中是否保存有当前handler执行之前所需要执行的标注了@ModelAttribute的方法Class<?> handlerType = handlerMethod.getBeanType();Set<Method> methods = this.modelAttributeCache.get(handlerType);if (methods == null) {// 如果缓存中没有相关属性，那么就在当前bean中查找所有使用@ModelAttribute标注，但是// 没有使用@RequestMapping标注的方法，并将这些方法缓存起来methods = MethodIntrospector.selectMethods(handlerType, MODEL_ATTRIBUTE_METHODS);this.modelAttributeCache.put(handlerType, methods);}// 获取全局的使用@ModelAttribute标注，但是没有使用@RequestMapping标注的方法，// 这里全局类型的方法的声明方式需要注意的是，其所在的bean必须使用@ControllerAdvice进行标注List<InvocableHandlerMethod> attrMethods = new ArrayList<>();this.modelAttributeAdviceCache.forEach((clazz, methodSet) -> {// 判断@ControllerAdvice中指定的作用的bean范围与当前bean是否匹配，匹配了才会对其应用if (clazz.isApplicableToBeanType(handlerType)) {Object bean = clazz.resolveBean();for (Method method : methodSet) {attrMethods.add(createModelAttributeMethod(binderFactory, bean, method));}}});// 将当前方法中使用@ModelAttribute标注的方法添加到需要执行的attrMethods中。从这里的添加顺序// 可以看出，全局类型的方法将会先于局部类型的方法执行for (Method method : methods) {Object bean = handlerMethod.getBean();attrMethods.add(createModelAttributeMethod(binderFactory, bean, method));}// 将需要执行的方法等数据封装为ModelFactory对象return new ModelFactory(attrMethods, binderFactory, sessionAttrHandler);}

public void initModel(NativeWebRequest request, ModelAndViewContainer container,HandlerMethod handlerMethod) throws Exception {// 在当前request中获取使用@SessionAttribute注解声明的参数Map<String, ?> sessionAttributes = this.sessionAttributesHandler.retrieveAttributes(request);// 将@SessionAttribute声明的参数封装到ModelAndViewContainer中container.mergeAttributes(sessionAttributes);// 调用前面获取的使用@ModelAttribute标注的方法invokeModelAttributeMethods(request, container);// 这里首先获取目标handler执行所需的参数中与@SessionAttribute同名或同类型的参数，// 也就是handler想要直接从@SessionAttribute中声明的参数中获取的参数。然后对这些参数// 进行遍历，首先判断request中是否包含该属性，如果不包含，则从之前的SessionAttribute缓存// 中获取，如果两个都没有，则直接抛出异常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 + "'", name);}container.addAttribute(name, value);}}}

private void invokeModelAttributeMethods(NativeWebRequest request, ModelAndViewContainer container) throws Exception {while (!this.modelMethods.isEmpty()) {// 这里getNextModelMethod()方法始终会获取modelMethods中的第0号为的方法，// 后续该方法执行完了之后则会将该方法从modelMethods移除掉，因而这里while// 循环只需要判断modelMethods是否为空即可InvocableHandlerMethod modelMethod = getNextModelMethod(container).getHandlerMethod();// 获取当前方法中标注的ModelAttribute属性，然后判断当前request中是否有与该属性中name字段// 标注的值相同的属性，如果存在，并且当前ModelAttribute设置了不对该属性进行绑定，那么// 就直接略过当前方法的执行ModelAttribute ann = modelMethod.getMethodAnnotation(ModelAttribute.class);Assert.state(ann != null, "No ModelAttribute annotation");if (container.containsAttribute(ann.name())) {if (!ann.binding()) {container.setBindingDisabled(ann.name());}continue;}// 通过ArgumentResolver对方法参数进行处理，并且调用目标方法Object returnValue = modelMethod.invokeForRequest(request, container);// 如果当前方法的返回值不为空，则判断当前@ModelAttribute是否设置了需要绑定返回值，// 如果设置了，则将返回值绑定到请求中，后续handler可以直接使用该参数if (!modelMethod.isVoid()){String returnValueName = getNameForReturnValue(returnValue, modelMethod.getReturnType());if (!ann.binding()) {container.setBindingDisabled(returnValueName);}// 如果request中不包含该参数，则将该返回值添加到ModelAndViewContainer中，// 供handler使用if (!container.containsAttribute(returnValueName)) {container.addAttribute(returnValueName, returnValue);}}}}

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {// 对目标handler的参数进行处理，并且调用目标handlerObject returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);// 设置相关的返回状态setResponseStatus(webRequest);// 如果请求处理完成，则设置requestHandled属性if (returnValue == null) {if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {mavContainer.setRequestHandled(true);return;}} else if (StringUtils.hasText(getResponseStatusReason())) {// 如果请求失败，但是有错误原因，那么也会设置requestHandled属性mavContainer.setRequestHandled(true);return;}mavContainer.setRequestHandled(false);Assert.state(this.returnValueHandlers != null, "No return value handlers");try {// 遍历当前容器中所有ReturnValueHandler，判断哪种handler支持当前返回值的处理，// 如果支持，则使用该handler处理该返回值this.returnValueHandlers.handleReturnValue(returnValue, getReturnValueType(returnValue), mavContainer, webRequest);} catch (Exception ex) {if (logger.isTraceEnabled()) {logger.trace(getReturnValueHandlingErrorMessage("Error handling return value", returnValue), ex);}throw ex;}}

@Nullablepublic Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {// 将request中的参数转换为当前handler的参数形式Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);if (logger.isTraceEnabled()) {logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) + "' with arguments " + Arrays.toString(args));}// 这里doInvoke()方法主要是结合处理后的参数，使用反射对目标方法进行调用Object returnValue = doInvoke(args);if (logger.isTraceEnabled()) {logger.trace("Method [" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) + "] returned [" + returnValue + "]");}return returnValue;}// 本方法主要是通过当前容器中配置的ArgumentResolver对request中的参数进行转化，// 将其处理为目标handler的参数的形式private Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {// 获取当前handler所声明的所有参数，主要包括参数名，参数类型，参数位置，所标注的注解等等属性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);// providedArgs是调用方提供的参数，这里主要是判断这些参数中是否有当前类型// 或其子类型的参数，如果有，则直接使用调用方提供的参数，对于请求处理而言，默认情况下，// 调用方提供的参数都是长度为0的数组args[i] = resolveProvidedArgument(parameter, providedArgs);if (args[i] != null) {continue;}// 如果在调用方提供的参数中不能找到当前类型的参数值，则遍历Spring容器中所有的// ArgumentResolver，判断哪种类型的Resolver支持对当前参数的解析，这里的判断// 方式比较简单，比如RequestParamMethodArgumentResolver就是判断当前参数// 是否使用@RequestParam注解进行了标注if (this.argumentResolvers.supportsParameter(parameter)) {try {// 如果能够找到对当前参数进行处理的ArgumentResolver，则调用其// resolveArgument()方法从request中获取对应的参数值，并且进行转换args[i] = this.argumentResolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);continue;} catch (Exception ex) {if (logger.isDebugEnabled()) {logger.debug(getArgumentResolutionErrorMessage("Failed to resolve", i), ex);}throw ex;}}// 如果进行了参数处理之后当前参数还是为空，则抛出异常if (args[i] == null) {throw new IllegalStateException("Could not resolve method parameter at index " + parameter.getParameterIndex() + " in " + parameter.getExecutable().toGenericString() + ": " + getArgumentResolutionErrorMessage("No suitable resolver for",i));}}return args;}

@Overridepublic void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {// 获取能够处理当前返回值的Handler，比如如果返回值是ModelAndView类型，那么这里的handler就是// ModelAndViewMethodReturnValueHandlerHandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);if (handler == null) {throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());}// 通过获取到的handler处理返回值，并将其封装到ModelAndViewContainer中handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);}// 本方法的主要作用是获取能够处理当前返回值的ReturnValueHandlerprivate HandlerMethodReturnValueHandler selectHandler(@Nullable Object value, MethodParameter returnType) {// 判断返回值是否为异步类型的返回值，即WebAsyncTask或DefferredResultboolean isAsyncValue = isAsyncReturnValue(value, returnType);// 对所有的ReturnValueHandler进行遍历，判断其是否支持当前返回值的处理。这里如果当前返回值// 是异步类型的返回值，还会判断当前ReturnValueHandler是否为// AsyncHandlerMethodReturnValueHandler类型，如果不是，则会继续查找for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) {if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) {continue;}// 判断是否支持返回值处理的主要位置，比如ModelAndViewMethodReturnValueHandler就会// 判断返回值是否为ModelAndView类型，如果是，则表示其是当前ReturnValuleHandler所支持的类型if (handler.supportsReturnType(returnType)) {return handler;}}return null;}