HandlerAdapter处理适配器

HandlerMapping通过request找到了handler，HandlerAdapter是具体使用Handler来干活的，每个HandlerAdapter封装了一种Handler的具体使用方法

Spring 中的处理器的实现有很多种方式，比如可以实现 Controller 接口，也可以用 @RequestMapping 注解将方法作为一个处理器等，这就导致 Spring 不知道怎么调用用户的处理器逻辑。所以这里需要一个处理器适配器，由处理器适配器去调用处理器的逻辑

HandlerAdapter按照特定规则去执行Handler，通过扩展适配器可以对更多类型的处理器进行执行

public interface HandlerAdapter {

   // 判断是否可以使用某个Handler
   boolean supports(Object handler);

   // 具体使用handler完成工作
   ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;

   // 获取Last-Modified资源最后一次修改时间
   long getLastModified(HttpServletRequest request, Object handler);

}

<bean id="annotationMethodHandlerAdapter"
class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" />

• HttpRequestHandlerAdapter 用于适配HttpRequestHandler
• SimpleControllerHandlerAdapter 用于适配Controller
• SimpleServletHandlerAdapter 用于适配Servlet
• RequestMappingHandlerAdapter 用于适配HandlerMethod

RequestMappingHandlerAdapter

平常使用最多的也是RequestMappingHandlerAdapter，即使用@Controller和@RequestMapping来进行映射的接口，即实现了InitializingBean接口，所以会执行afterPropertiesSet方法

public void afterPropertiesSet() {
   // Do this first, it may add ResponseBody advice beans
  // @ControllerAdvice的bean
   initControllerAdviceCache();

   if (this.argumentResolvers == null) {
     // 一些参数解析器，如解析@RequestParam、@PathVariable、@RequestBody等
      List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
      this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
   }
   if (this.initBinderArgumentResolvers == null) {
     // initBinder的参数解析器
      List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
      this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
   }
   if (this.returnValueHandlers == null) {
     // 返回值的参数解析器，如ModelAndView、ResponseEntity、HttpEntity、@ResponseBody注解等
      List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
      this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
   }
}

处理请求

protected ModelAndView handleInternal(HttpServletRequest request,
      HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

   ModelAndView mav;
   checkRequest(request);

   // Execute invokeHandlerMethod in synchronized block if required.
   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;
}

invokeHandlerMethod

protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
      HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

   ServletWebRequest webRequest = new ServletWebRequest(request, response);
   try {
     // 将注解@InitBinder的方法找出来
      WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
     // 用来处理Model的，在处理器具体处理之前对Model进行初始化，在处理万请求之后对Model参数进行更新
      ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
		// 用于参数绑定、处理请求以及返回值处理
      ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
      invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
      invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
      invocableMethod.setDataBinderFactory(binderFactory);
      invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
		// 用于保存Model和View的
      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;
      }
			// 请求执行完之后进行处理
     // ①modelFactory.updateModel 更新Model
     // ②根据mavContainer创建modelAndView
     // ③如果model是RedirectAttributes类型，需要设置到FlashMap中
      return getModelAndView(mavContainer, modelFactory, webRequest);
   }
   finally {
      webRequest.requestCompleted();
   }
}