SpringMVC常见组件之HandlerAdapter分析

// 判断是否支持入参handler，也就是当前HandlerAdapter是否适用于入参handler
boolean supports(Object handler);
//使用给定的handler处理请求 返回响应--这是核心入口
ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
// 最后修饰标记，如何不支持handler，则返回 -1
long getLastModified(HttpServletRequest request, Object handler);

其supports方法对handler做了类型校验必须是HandlerMethod 类型，然后暴露抽象方法supportsInternal给子类实现
publi

@Override
@Nullable
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
    throws Exception {
  return handleInternal(request, response, (HandlerMethod) handler);
}

protected abstract long getLastModifiedInternal(HttpServletRequest request, HandlerMethod handlerMethod);

// 是否忽略spring的xml配置，默认false
private static final boolean shouldIgnoreXml = SpringProperties.getFlag("spring.xml.ignore");
 // 找标注了@InitBinder方法
public static final MethodFilter INIT_BINDER_METHODS = method ->
    AnnotatedElementUtils.hasAnnotation(method, InitBinder.class);
// 找标注了 @ModelAttribute方法，但是没有标注@RequestMapping
public static final MethodFilter MODEL_ATTRIBUTE_METHODS = method ->
    (!AnnotatedElementUtils.hasAnnotation(method, RequestMapping.class) &&
        AnnotatedElementUtils.hasAnnotation(method, ModelAttribute.class));
// 自定义的参数解析器
@Nullable
private List<HandlerMethodArgumentResolver> customArgumentResolvers;
// 框架内部的参数解析器
@Nullable
private HandlerMethodArgumentResolverComposite argumentResolvers;
// 标注了@InitBinder方法的参数解析器
@Nullable
private HandlerMethodArgumentResolverComposite initBinderArgumentResolvers;
// 自定义返回结果处理器
@Nullable
private List<HandlerMethodReturnValueHandler> customReturnValueHandlers;
// 框架内部的返回结果处理器
@Nullable
private HandlerMethodReturnValueHandlerComposite returnValueHandlers;
// 框架内部视图解析器
@Nullable
private List<ModelAndViewResolver> modelAndViewResolvers;
// 框架内部内容协商管理器
private ContentNegotiationManager contentNegotiationManager = new ContentNegotiationManager();
// 信息转换器
private List<HttpMessageConverter<?>> messageConverters;
// 请求响应体通知/顾问器，主要用来在读取请求或者输出响应前做一些处理
private final List<Object> requestResponseBodyAdvice = new ArrayList<>();
// 数据绑定初始化器
@Nullable
private WebBindingInitializer webBindingInitializer;
private AsyncTaskExecutor taskExecutor = new SimpleAsyncTaskExecutor("MvcAsync");
@Nullable
private Long asyncRequestTimeout;
private CallableProcessingInterceptor[] callableInterceptors = new CallableProcessingInterceptor[0];
private DeferredResultProcessingInterceptor[] deferredResultInterceptors = new DeferredResultProcessingInterceptor[0];
private ReactiveAdapterRegistry reactiveAdapterRegistry = ReactiveAdapterRegistry.getSharedInstance();
private boolean ignoreDefaultModelOnRedirect = false;
private int cacheSecondsForSessionAttributeHandlers = 0;
private boolean synchronizeOnSession = false;
private SessionAttributeStore sessionAttributeStore = new DefaultSessionAttributeStore();
// 参数名发现/解析器
private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
// beanFactory
@Nullable
private ConfigurableBeanFactory beanFactory;
// 如下是一些缓存
private final Map<Class<?>, SessionAttributesHandler> sessionAttributesHandlerCache = new ConcurrentHashMap<>(64);
private final Map<Class<?>, Set<Method>> initBinderCache = new ConcurrentHashMap<>(64);
// @ControllerAdvice类中的@InitBinder方法
private final Map<ControllerAdviceBean, Set<Method>> initBinderAdviceCache = new LinkedHashMap<>();
private final Map<Class<?>, Set<Method>> modelAttributeCache = new ConcurrentHashMap<>(64);
// @ControllerAdvice类中的@ModelAttribute方法
private final Map<ControllerAdviceBean, Set<Method>> modelAttributeAdviceCache = new LinkedHashMap<>();

@Override
public void afterPropertiesSet() {
  // Do this first, it may add ResponseBody advice beans
  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 List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
  List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(30);
  // 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()));
  resolvers.add(new SessionAttributeMethodArgumentResolver());
  resolvers.add(new RequestAttributeMethodArgumentResolver());
  // 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());
  if (KotlinDetector.isKotlinPresent()) {
    resolvers.add(new ContinuationHandlerMethodArgumentResolver());
  }
  // Custom arguments
  if (getCustomArgumentResolvers() != null) {
    resolvers.addAll(getCustomArgumentResolvers());
  }
  // Catch-all  这里很有意思哦
  resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
  resolvers.add(new ServletModelAttributeMethodProcessor(true));
  return resolvers;
}

private List<HandlerMethodArgumentResolver> getDefaultInitBinderArgumentResolvers() {
  List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(20);
  // 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 ExpressionValueMethodArgumentResolver(getBeanFactory()));
  resolvers.add(new SessionAttributeMethodArgumentResolver());
  resolvers.add(new RequestAttributeMethodArgumentResolver());
  // Type-based argument resolution
  resolvers.add(new ServletRequestMethodArgumentResolver());
  resolvers.add(new ServletResponseMethodArgumentResolver());
  // Custom arguments
  if (getCustomArgumentResolvers() != null) {
    resolvers.addAll(getCustomArgumentResolvers());
  }
  // Catch-all
  resolvers.add(new PrincipalMethodArgumentResolver());
  resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
  return resolvers;
}

private List<HandlerMethodReturnValueHandler> getDefaultReturnValueHandlers() {
  List<HandlerMethodReturnValueHandler> handlers = new ArrayList<>(20);
  // Single-purpose return value types
  handlers.add(new ModelAndViewMethodReturnValueHandler());
  handlers.add(new ModelMethodProcessor());
  handlers.add(new ViewMethodReturnValueHandler());
  handlers.add(new ResponseBodyEmitterReturnValueHandler(getMessageConverters(),
      this.reactiveAdapterRegistry, this.taskExecutor, this.contentNegotiationManager));
  handlers.add(new StreamingResponseBodyReturnValueHandler());
  handlers.add(new HttpEntityMethodProcessor(getMessageConverters(),
      this.contentNegotiationManager, this.requestResponseBodyAdvice));
  handlers.add(new HttpHeadersReturnValueHandler());
  handlers.add(new CallableMethodReturnValueHandler());
  handlers.add(new DeferredResultMethodReturnValueHandler());
  handlers.add(new AsyncTaskMethodReturnValueHandler(this.beanFactory));
  // Annotation-based return value types
  handlers.add(new ServletModelAttributeMethodProcessor(false));
  handlers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(),
      this.contentNegotiationManager, this.requestResponseBodyAdvice));
  // Multi-purpose return value types
  handlers.add(new ViewNameMethodReturnValueHandler());
  handlers.add(new MapMethodProcessor());
  // Custom return value types
  if (getCustomReturnValueHandlers() != null) {
    handlers.addAll(getCustomReturnValueHandlers());
  }
  // Catch-all
  if (!CollectionUtils.isEmpty(getModelAndViewResolvers())) {
    handlers.add(new ModelAndViewResolverMethodReturnValueHandler(getModelAndViewResolvers()));
  }
  else {
    handlers.add(new ServletModelAttributeMethodProcessor(true));
  }
  return 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;
}

public class SessionAttributesHandler {
  private final Set<String> attributeNames = new HashSet<>();
  private final Set<Class<?>> attributeTypes = new HashSet<>();
  private final Set<String> knownAttributeNames = Collections.newSetFromMap(new ConcurrentHashMap<>(4));
  private final SessionAttributeStore sessionAttributeStore;
  public SessionAttributesHandler(Class<?> handlerType, SessionAttributeStore sessionAttributeStore) {
    Assert.notNull(sessionAttributeStore, "SessionAttributeStore may not be null");
    this.sessionAttributeStore = sessionAttributeStore;
    SessionAttributes ann = AnnotatedElementUtils.findMergedAnnotation(handlerType, SessionAttributes.class);
    if (ann != null) {
      Collections.addAll(this.attributeNames, ann.names());
      Collections.addAll(this.attributeTypes, ann.types());
    }
    this.knownAttributeNames.addAll(this.attributeNames);
  }
  //...
}

public void initModel(NativeWebRequest request, ModelAndViewContainer container, HandlerMethod handlerMethod)
    throws Exception {
  //获取SessionAttributesHandler.knownAttributeNames中在session里面不为null的属性
  Map<String, ?> sessionAttributes = this.sessionAttributesHandler.retrieveAttributes(request);
  //合并值不为null的,且container中的model不包含该key的属性
  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 + "'", name);
      }
      container.addAttribute(name, value);
    }
  }
}

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
    Object... providedArgs) throws Exception {
  // 这里业务代码可能抛出异常，那么将会一路抛出到dispatchServlet中
  Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
  // 设置响应状态，如果HttpStatus不为null的话
  setResponseStatus(webRequest);
  if (returnValue == null) {
  // 判断请求是否未修改、响应状态是否不为null、请求是否已经被处理
    if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
    // 如果有必要则禁用内容缓存
      disableContentCachingIfNecessary(webRequest);
      // 设置请求被处理完毕
      mavContainer.setRequestHandled(true);
      return;
    }
  }else if (StringUtils.hasText(getResponseStatusReason())) {
    mavContainer.setRequestHandled(true);//是否有responseStatusReason，如果有设置请求已处理
    return;
  }
// 设置请求还没有被处理
  mavContainer.setRequestHandled(false);
  Assert.state(this.returnValueHandlers != null, "No return value handlers");
  try {
    this.returnValueHandlers.handleReturnValue( // 处理返回结果
        returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
  }
  catch (Exception ex) {
    if (logger.isTraceEnabled()) {
      logger.trace(formatErrorForReturnValue(returnValue), ex);
    }
    throw ex;
  }
}

@Nullable
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
    Object... providedArgs) throws Exception {
  //获取解析到的参数值
  Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
  if (logger.isTraceEnabled()) {
    logger.trace("Arguments: " + Arrays.toString(args));
  }
  //反射调用方法获取方法返回结果
  return doInvoke(args);
}

protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
    Object... providedArgs) throws Exception {
  MethodParameter[] parameters = getMethodParameters();
  if (ObjectUtils.isEmpty(parameters)) {
    return EMPTY_ARGS;
  }
  Object[] args = new Object[parameters.length];
  for (int i = 0; i < parameters.length; i++) {
    MethodParameter parameter = parameters[i];
    parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
    args[i] = findProvidedArgument(parameter, providedArgs);
    if (args[i] != null) {
      continue;
    }
    if (!this.resolvers.supportsParameter(parameter)) {
      throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
    }
    try {
      args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
    }
    //...
  }
  return args;
}

@Nullable
private ModelAndView getModelAndView(ModelAndViewContainer mavContainer,
    ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception {
  // 更新model
  modelFactory.updateModel(webRequest, mavContainer);
  // 很关键哦，表示请求已经处理，比如添加@ResponseBody注解的时候
  if (mavContainer.isRequestHandled()) {
    return null;
  }
  // 获取model，封装实例化ModelAndView 
  ModelMap model = mavContainer.getModel();
  ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, mavContainer.getStatus());
  if (!mavContainer.isViewReference()) {
    mav.setView((View) mavContainer.getView());
  }
  // 重定向请求时，如果有重定向属性 放到outputFlashMap中
  if (model instanceof RedirectAttributes) {
    Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
    HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
    if (request != null) {
      RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
    }
  }
  return mav;
}

<mvc:view-controller path="/" view-name="index"></mvc:view-controller>

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping" >
      <!--或者如下配置-->
      <property name="mappings">
          <value>
              /myController=myController
          </value>
      </property>
      <property name="order">
          <value>
              1
          </value>
      </property>
  </bean>

@org.springframework.stereotype.Controller
public class MyController implements Controller {
   @Override
   public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
       System.out.println(request.getParameterMap());
       System.out.println(response.getStatus());
       ModelAndView modelAndView = new ModelAndView();
       modelAndView.setViewName("success");
       return modelAndView;
   }
}

public class SimpleControllerHandlerAdapter implements HandlerAdapter {
  // 判断是否支持当前handler --判断handler是否为Controller类型
  @Override
  public boolean supports(Object handler) {
    return (handler instanceof Controller);
  }
  // 直接调用handler的handleRequest方法
  @Override
  @Nullable
  public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
      throws Exception {
    return ((Controller) handler).handleRequest(request, response);
  }
  // 如果是LastModified则调用其getLastModified方法，否则返回-1
  @Override
  public long getLastModified(HttpServletRequest request, Object handler) {
    if (handler instanceof LastModified) {
      return ((LastModified) handler).getLastModified(request);
    }
    return -1L;
  }
}

public class HttpRequestHandlerAdapter implements HandlerAdapter {
// 判断handler是否为HttpRequestHandler类型
  @Override
  public boolean supports(Object handler) {
    return (handler instanceof HttpRequestHandler);
  }
// 直接调用handlerd的handleRequest方法
  @Override
  @Nullable
  public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
      throws Exception {
    ((HttpRequestHandler) handler).handleRequest(request, response);
    return null;
  }
  // 如果是LastModified则调用其getLastModified方法，否则返回-1  @Override
  public long getLastModified(HttpServletRequest request, Object handler) {
    if (handler instanceof LastModified) {
      return ((LastModified) handler).getLastModified(request);
    }
    return -1L;
  }
}

@Override
public void handleRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
  Assert.state(this.servletContext != null, "No ServletContext set");
  RequestDispatcher rd = this.servletContext.getNamedDispatcher(this.defaultServletName);
  if (rd == null) {
    throw new IllegalStateException("A RequestDispatcher could not be located for the default servlet '" +
        this.defaultServletName + "'");
  }
  rd.forward(request, response);
}

public class SimpleServletHandlerAdapter implements HandlerAdapter {
// 判断handler是否为Servlet
  @Override
  public boolean supports(Object handler) {
    return (handler instanceof Servlet);
  }
// 调用Servlet的service方法
  @Override
  @Nullable
  public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
      throws Exception {
    ((Servlet) handler).service(request, response);
    return null;
  }
// 直接返回-1
  @Override
  public long getLastModified(HttpServletRequest request, Object handler) {
    return -1;
  }
}

// 判断是否为HandlerFunction类型
@Override
public boolean supports(Object handler) {
  return handler instanceof HandlerFunction;
}
@Nullable
@Override
public ModelAndView handle(HttpServletRequest servletRequest,
    HttpServletResponse servletResponse,
    Object handler) throws Exception {
  HandlerFunction<?> handlerFunction = (HandlerFunction<?>) handler;
  ServerRequest serverRequest = getServerRequest(servletRequest);
  ServerResponse serverResponse = handlerFunction.handle(serverRequest);
  return serverResponse.writeTo(servletRequest, servletResponse,
      new ServerRequestContext(serverRequest));
}
// 直接返回-1
public long getLastModified(HttpServletRequest request, Object handler) {
  return -1L;
}