HandlerMapping 分析

public interface HandlerMapping {
   @Nullable
   HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;

}

@Override
protected void initApplicationContext(ApplicationContext context) {
   // 处理父类的 initApplicationContext 方法
   super.initApplicationContext(context);
   if (this.servletContext == null && context instanceof WebApplicationContext) {
      this.servletContext = ((WebApplicationContext) context).getServletContext();
      if (this.servletContext != null) {
         // 初始化ServletContext
         initServletContext(this.servletContext);
      }
   }
}

protected void initApplicationContext(ApplicationContext context) throws BeansException {
   initApplicationContext();
}
protected void initApplicationContext() throws BeansException {
}

	// org.springframework.web.servlet.handler.SimpleUrlHandlerMapping#initApplicationContext
	@Override
	public void initApplicationContext() throws BeansException {
		super.initApplicationContext();
		registerHandlers(this.urlMap);
	}

protected void registerHandlers(Map<String, Object> urlMap) throws BeansException {
   if (urlMap.isEmpty()) {
      logger.trace("No patterns in " + formatMappingName());
   }
   else {
      // 循环处理 urlMap
      urlMap.forEach((url, handler) -> {
         // Prepend with slash if not already present.
         if (!url.startsWith("/")) {
            url = "/" + url;
         }
         // Remove whitespace from handler bean name.
         if (handler instanceof String) {
            handler = ((String) handler).trim();
         }
         registerHandler(url, handler);
      });
      if (logger.isDebugEnabled()) {
         List<String> patterns = new ArrayList<>();
         if (getRootHandler() != null) {
            patterns.add("/");
         }
         if (getDefaultHandler() != null) {
            patterns.add("/**");
         }
         patterns.addAll(getHandlerMap().keySet());
         logger.debug("Patterns " + patterns + " in " + formatMappingName());
      }
   }
}

protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {
   Assert.notNull(urlPath, "URL path must not be null");
   Assert.notNull(handler, "Handler object must not be null");
   Object resolvedHandler = handler;

   // Eagerly resolve handler if referencing singleton via name.
   if (!this.lazyInitHandlers && handler instanceof String) {
      String handlerName = (String) handler;
      ApplicationContext applicationContext = obtainApplicationContext();
      if (applicationContext.isSingleton(handlerName)) {
         // 从容器中获取 handler 对象
         resolvedHandler = applicationContext.getBean(handlerName);
      }
   }

   // 尝试从handlerMap中获取对象
   Object mappedHandler = this.handlerMap.get(urlPath);
   if (mappedHandler != null) {
      if (mappedHandler != resolvedHandler) {
         throw new IllegalStateException(
               "Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
               "]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
      }
   }
   // 容器中不存在的处理情况
   else {
      if (urlPath.equals("/")) {
         if (logger.isTraceEnabled()) {
            logger.trace("Root mapping to " + getHandlerDescription(handler));
         }
         setRootHandler(resolvedHandler);
      }
      else if (urlPath.equals("/*")) {
         if (logger.isTraceEnabled()) {
            logger.trace("Default mapping to " + getHandlerDescription(handler));
         }
         setDefaultHandler(resolvedHandler);
      }
      else {
         this.handlerMap.put(urlPath, resolvedHandler);
         if (logger.isTraceEnabled()) {
            logger.trace("Mapped [" + urlPath + "] onto " + getHandlerDescription(handler));
         }
      }
   }
}

registerBeanDefinitionParser("default-servlet-handler", new DefaultServletHandlerBeanDefinitionParser())

@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
   Object source = parserContext.extractSource(element);

   String defaultServletName = element.getAttribute("default-servlet-name");
   RootBeanDefinition defaultServletHandlerDef = new RootBeanDefinition(DefaultServletHttpRequestHandler.class);
   defaultServletHandlerDef.setSource(source);
   defaultServletHandlerDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
   if (StringUtils.hasText(defaultServletName)) {
      defaultServletHandlerDef.getPropertyValues().add("defaultServletName", defaultServletName);
   }
   String defaultServletHandlerName = parserContext.getReaderContext().generateBeanName(defaultServletHandlerDef);
   parserContext.getRegistry().registerBeanDefinition(defaultServletHandlerName, defaultServletHandlerDef);
   parserContext.registerComponent(new BeanComponentDefinition(defaultServletHandlerDef, defaultServletHandlerName));

   Map<String, String> urlMap = new ManagedMap<>();
   urlMap.put("/**", defaultServletHandlerName);

   RootBeanDefinition handlerMappingDef = new RootBeanDefinition(SimpleUrlHandlerMapping.class);
   handlerMappingDef.setSource(source);
   handlerMappingDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
   handlerMappingDef.getPropertyValues().add("urlMap", urlMap);

   String handlerMappingBeanName = parserContext.getReaderContext().generateBeanName(handlerMappingDef);
   parserContext.getRegistry().registerBeanDefinition(handlerMappingBeanName, handlerMappingDef);
   parserContext.registerComponent(new BeanComponentDefinition(handlerMappingDef, handlerMappingBeanName));

   // Ensure BeanNameUrlHandlerMapping (SPR-8289) and default HandlerAdapters are not "turned off"
   MvcNamespaceUtils.registerDefaultComponents(parserContext, source);

   return null;
}

/** List of HandlerMappings used by this servlet. */
@Nullable
private List<HandlerMapping> handlerMappings;

@Nullable
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
   if (this.handlerMappings != null) {
      for (HandlerMapping mapping : this.handlerMappings) {
         HandlerExecutionChain handler = mapping.getHandler(request);
         if (handler != null) {
            return handler;
         }
      }
   }
   return null;
}

@Override
@Nullable
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
   // 将 request 进行搜索找到对应的 handler 对象
   Object handler = getHandlerInternal(request);
   if (handler == null) {
      // 获取默认的 handler
      handler = getDefaultHandler();
   }
   if (handler == null) {
      return null;
   }
   // Bean name or resolved handler?
   // handler 是否是 String 类型
   if (handler instanceof String) {
      // handler 是字符串类型从容器中获取对象
      String handlerName = (String) handler;
      handler = obtainApplicationContext().getBean(handlerName);
   }

   // 获取 HandlerExecutionChain 对象
   HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);

   if (logger.isTraceEnabled()) {
      logger.trace("Mapped to " + handler);
   }
   else if (logger.isDebugEnabled() && !request.getDispatcherType().equals(DispatcherType.ASYNC)) {
      logger.debug("Mapped to " + executionChain.getHandler());
   }

   // 跨域处理
   if (hasCorsConfigurationSource(handler) || CorsUtils.isPreFlightRequest(request)) {
      CorsConfiguration config = (this.corsConfigurationSource != null ? this.corsConfigurationSource.getCorsConfiguration(request) : null);
      CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
      config = (config != null ? config.combine(handlerConfig) : handlerConfig);
      executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
   }

   return executionChain;
}

@Override
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
   // 获取当前请求路径
   String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
   // 设置属性
   request.setAttribute(LOOKUP_PATH, lookupPath);
   // 上锁
   this.mappingRegistry.acquireReadLock();
   try {
      // 寻找 handler method
      HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
      return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
   }
   finally {
      // 释放锁
      this.mappingRegistry.releaseReadLock();
   }
}

@Nullable
protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
   List<Match> matches = new ArrayList<>();
   // 从 路由映射表 获取
   List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
   // 如果url对应的数据不为空
   if (directPathMatches != null) {
      // 添加匹配映射
      addMatchingMappings(directPathMatches, matches, request);
   }
   if (matches.isEmpty()) {
      // No choice but to go through all mappings...
      // 添加匹配映射
      addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
   }

   if (!matches.isEmpty()) {
      // 比较对象
      Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
      // 排序
      matches.sort(comparator);
      // 获取第一个 match 对象
      Match bestMatch = matches.get(0);
      if (matches.size() > 1) {
         if (logger.isTraceEnabled()) {
            logger.trace(matches.size() + " matching mappings: " + matches);
         }

         // 是否跨域请求
         if (CorsUtils.isPreFlightRequest(request)) {
            return PREFLIGHT_AMBIGUOUS_MATCH;
         }
         // 取出第二个元素.
         Match secondBestMatch = matches.get(1);
         // 如果比较结果相同
         if (comparator.compare(bestMatch, secondBestMatch) == 0) {
            // 第二个元素和第一个元素的比较过程
            Method m1 = bestMatch.handlerMethod.getMethod();
            Method m2 = secondBestMatch.handlerMethod.getMethod();
            String uri = request.getRequestURI();
            throw new IllegalStateException(
                  "Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
         }
      }
      // 设置属性
      request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.handlerMethod);
      // 处理匹配的结果
      handleMatch(bestMatch.mapping, lookupPath, request);
      return bestMatch.handlerMethod;
   }
   else {
      // 处理没有匹配的结果
      return handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
   }
}

@GetMapping("/a/{title}")
public String title(
      @PathVariable("title") String title
) {
   return title;
}

@GetMapping("/a/{title2}")
public String title2(@PathVariable("title2") String title2) {
   return "title";
}

@Override
protected HandlerMethod handleNoMatch(
      Set<RequestMappingInfo> infos, String lookupPath, HttpServletRequest request) throws ServletException {

   // 创建对象 PartialMatchHelper
   PartialMatchHelper helper = new PartialMatchHelper(infos, request);
   if (helper.isEmpty()) {
      return null;
   }

   // http 请求方式
   if (helper.hasMethodsMismatch()) {
      Set<String> methods = helper.getAllowedMethods();
      // 请求方式比较
      if (HttpMethod.OPTIONS.matches(request.getMethod())) {
         // handler 转换
         HttpOptionsHandler handler = new HttpOptionsHandler(methods);
         // 构建 handler method
         return new HandlerMethod(handler, HTTP_OPTIONS_HANDLE_METHOD);
      }
      throw new HttpRequestMethodNotSupportedException(request.getMethod(), methods);
   }

   // 可消费的 Content-Type 错误
   if (helper.hasConsumesMismatch()) {
      Set<MediaType> mediaTypes = helper.getConsumableMediaTypes();
      MediaType contentType = null;
      if (StringUtils.hasLength(request.getContentType())) {
         try {
            // 字符串转换成对象
            contentType = MediaType.parseMediaType(request.getContentType());
         }
         catch (InvalidMediaTypeException ex) {
            throw new HttpMediaTypeNotSupportedException(ex.getMessage());
         }
      }
      throw new HttpMediaTypeNotSupportedException(contentType, new ArrayList<>(mediaTypes));
   }

   // 可生产的 Content-Type 错误
   if (helper.hasProducesMismatch()) {
      Set<MediaType> mediaTypes = helper.getProducibleMediaTypes();
      throw new HttpMediaTypeNotAcceptableException(new ArrayList<>(mediaTypes));
   }

   // 参数错误
   if (helper.hasParamsMismatch()) {
      List<String[]> conditions = helper.getParamConditions();
      throw new UnsatisfiedServletRequestParameterException(conditions, request.getParameterMap());
   }

   return null;
}

@RequestMapping(value = "/getMapping",method = RequestMethod.GET)
public String getMapping() {
   return "data";
}

@PostMapping(value = "/postMapping",consumes = {MediaType.APPLICATION_JSON_VALUE},produces = {})
public Object postMapping(
      @RequestBody Map<String, String> map
) {
   return "";
}

POST http://localhost:8080/postMapping
Content-Type: application/x-www-form-urlencoded

@PostMapping(value = "/postMapping", consumes = {MediaType.APPLICATION_JSON_VALUE}, produces = {"text/plain"})
public Object postMapping(
      @RequestBody Map<String, String> map
) {
   return "";
}

POST http://localhost:8080/postMapping
Content-Type: application/json
Accept: application/json

@GetMapping(value = "/getMapping2", params = {"va"})
public String getMapping2(
      @RequestParam("va") String va
) {
   return va;
}

GET http://localhost:8080/getMapping2

private void addMatchingMappings(Collection<T> mappings, List<Match> matches, HttpServletRequest request) {
   for (T mapping : mappings) {
      // 抽象方法
      // 通过抽象方法获取 match 结果
      T match = getMatchingMapping(mapping, request);
      // 是否为空
      if (match != null) {
         // 从 mappingLookup 获取结果并且插入到matches中
         matches.add(new Match(match, this.mappingRegistry.getMappings().get(mapping)));
      }
   }
}

@Override
protected RequestMappingInfo getMatchingMapping(RequestMappingInfo info, HttpServletRequest request) {
   return info.getMatchingCondition(request);
}

protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
		// 判断 handler 对象的类型是否是 HandlerExecutionChain, 如果不是会进行对象创建,如果是会进行强制转换
		HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
				(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));

		// 提取请求的地址
		String lookupPath = this.urlPathHelper.getLookupPathForRequest(request, LOOKUP_PATH);
		// 拦截器处理
		for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
			if (interceptor instanceof MappedInterceptor) {
				MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
				// 验证url地址是否是需要进行拦截,如果需要就加入
				if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
					chain.addInterceptor(mappedInterceptor.getInterceptor());
				}
			}
			else {
				chain.addInterceptor(interceptor);
			}
		}
		return chain;
	}

public HandlerExecutionChain(Object handler, @Nullable HandlerInterceptor... interceptors) {
   if (handler instanceof HandlerExecutionChain) {
      HandlerExecutionChain originalChain = (HandlerExecutionChain) handler;
      this.handler = originalChain.getHandler();
      this.interceptorList = new ArrayList<>();
      CollectionUtils.mergeArrayIntoCollection(originalChain.getInterceptors(), this.interceptorList);
      CollectionUtils.mergeArrayIntoCollection(interceptors, this.interceptorList);
   }
   else {
      this.handler = handler;
      this.interceptors = interceptors;
   }
}

public class AllHandlerInterceptor implements HandlerInterceptor {
   @Override
   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
      System.out.println("in AllHandlerInterceptor");
      return true;
   }

   @Override
   public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

   }

   @Override
   public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

   }
}

<mvc:interceptors>
   <mvc:interceptor>
      <mvc:mapping path="/**" />
      <bean id="AllHandlerInterceptor" class="com.source.hot.mvc.handlerInterceptor.AllHandlerInterceptor"/>
   </mvc:interceptor>
</mvc:interceptors>

// 跨域处理
// 对handler的跨域判断
// 对请求的跨域判断
if (hasCorsConfigurationSource(handler) || CorsUtils.isPreFlightRequest(request)) {
    // 从请求中获取跨域配置
    CorsConfiguration config = (this.corsConfigurationSource != null ? this.corsConfigurationSource.getCorsConfiguration(request) : null);
    // 从 handler中获取跨域配置
    CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
    // 确定最终的跨域配置
    config = (config != null ? config.combine(handlerConfig) : handlerConfig);
    // executionChain 对象添加跨域配置
    executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
}

protected boolean hasCorsConfigurationSource(Object handler) {
   if (handler instanceof HandlerExecutionChain) {
      handler = ((HandlerExecutionChain) handler).getHandler();
   }
   return (handler instanceof CorsConfigurationSource || this.corsConfigurationSource != null);
}

<mvc:cors>
   <mvc:mapping path="/**"/>
</mvc:cors>

public static boolean isPreFlightRequest(HttpServletRequest request) {
   return (HttpMethod.OPTIONS.matches(request.getMethod()) &&
         request.getHeader(HttpHeaders.ORIGIN) != null &&
         request.getHeader(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD) != null);
}

OPTIONS http://localhost:8080/demo
Origin: "localhost"
Access-Control-Request-Method: GET

public class ControllerImpl implements Controller {
   @Override
   public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
      ModelAndView modelAndView = new ModelAndView();
      modelAndView.setStatus(HttpStatus.OK);
      return modelAndView;
   }
}

<bean id="controllerImpl" class="com.source.hot.mvc.ctr.ControllerImpl"/>

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
   <property name="order" value="1"/>
   <property name="mappings">
      <value>
         /hello=controllerImpl
      </value>
   </property>
</bean>

@Override
@Nullable
protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
   // 提取请求地址
   String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
   // 设置请求地址
   request.setAttribute(LOOKUP_PATH, lookupPath);
   // 查询 handler 对象
   Object handler = lookupHandler(lookupPath, request);
   if (handler == null) {
      // We need to care for the default handler directly, since we need to
      // expose the PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE for it as well.
      Object rawHandler = null;
      // 对于访问路径是 / 的处理
      if ("/".equals(lookupPath)) {
         // 获取根Handler对象
         rawHandler = getRootHandler();
      }
      // handler 还是空
      if (rawHandler == null) {
         // 获取默认的Handler对象
         rawHandler = getDefaultHandler();
      }
      // rawHandler 不为空
      if (rawHandler != null) {
         // Bean name or resolved handler?
         // 类型是String从容器中获取
         if (rawHandler instanceof String) {
            String handlerName = (String) rawHandler;
            rawHandler = obtainApplicationContext().getBean(handlerName);
         }
         // 验证 handler
         validateHandler(rawHandler, request);
         // 构建 handler 对象
         handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
      }
   }
   return handler;
}

Object handler = this.handlerMap.get(urlPath);
// 不为空的处理情况
if (handler != null) {
   // Bean name or resolved handler?
   if (handler instanceof String) {
      String handlerName = (String) handler;
      handler = obtainApplicationContext().getBean(handlerName);
   }
   // 验证handler对象
   validateHandler(handler, request);
   // 创建 handler 对象
   return buildPathExposingHandler(handler, urlPath, urlPath, null);
}

// 第二部分
// Pattern match?
// url 正则匹配集合
List<String> matchingPatterns = new ArrayList<>();
// 循环处理handlerMap的key列表，将符合正则表达式的数据放入到容器中
for (String registeredPattern : this.handlerMap.keySet()) {
   if (getPathMatcher().match(registeredPattern, urlPath)) {
      matchingPatterns.add(registeredPattern);
   }
   else if (useTrailingSlashMatch()) {
      if (!registeredPattern.endsWith("/") && getPathMatcher().match(registeredPattern + "/", urlPath)) {
         matchingPatterns.add(registeredPattern + "/");
      }
   }
}

// 第三部分
String bestMatch = null;
// 第一步 容器排序
// 创建url比较器
Comparator<String> patternComparator = getPathMatcher().getPatternComparator(urlPath);
if (!matchingPatterns.isEmpty()) {
   matchingPatterns.sort(patternComparator);
   if (logger.isTraceEnabled() && matchingPatterns.size() > 1) {
      logger.trace("Matching patterns " + matchingPatterns);
   }
   bestMatch = matchingPatterns.get(0);
}
// 需要进行匹配的对象存在的情况
if (bestMatch != null) {
   // 第二步: 通过最佳匹配的url获取对应的handler对象
   handler = this.handlerMap.get(bestMatch);
   if (handler == null) {
      if (bestMatch.endsWith("/")) {
         handler = this.handlerMap.get(bestMatch.substring(0, bestMatch.length() - 1));
      }
      if (handler == null) {
         throw new IllegalStateException(
               "Could not find handler for best pattern match [" + bestMatch + "]");
      }
   }
   // Bean name or resolved handler?
   if (handler instanceof String) {
      String handlerName = (String) handler;
      handler = obtainApplicationContext().getBean(handlerName);
   }
   validateHandler(handler, request);
   String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestMatch, urlPath);

   // There might be multiple 'best patterns', let's make sure we have the correct URI template variables
   // for all of them
   // 第三步: matchingPatterns 数量超过1个的情况处理
   Map<String, String> uriTemplateVariables = new LinkedHashMap<>();
   for (String matchingPattern : matchingPatterns) {
      if (patternComparator.compare(bestMatch, matchingPattern) == 0) {
         Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(matchingPattern, urlPath);
         Map<String, String> decodedVars = getUrlPathHelper().decodePathVariables(request, vars);
         uriTemplateVariables.putAll(decodedVars);
      }
   }
   if (logger.isTraceEnabled() && uriTemplateVariables.size() > 0) {
      logger.trace("URI variables " + uriTemplateVariables);
   }
   return buildPathExposingHandler(handler, bestMatch, pathWithinMapping, uriTemplateVariables);
}

protected Object buildPathExposingHandler(Object rawHandler, String bestMatchingPattern,
      String pathWithinMapping, @Nullable Map<String, String> uriTemplateVariables) {

   // 通过 handler对象创建 HandlerExecutionChain
   HandlerExecutionChain chain = new HandlerExecutionChain(rawHandler);
   // 添加 PathExposingHandlerInterceptor 拦截器
   chain.addInterceptor(new PathExposingHandlerInterceptor(bestMatchingPattern, pathWithinMapping));
   if (!CollectionUtils.isEmpty(uriTemplateVariables)) {
      // 添加 UriTemplateVariablesHandlerInterceptor 拦截器
      chain.addInterceptor(new UriTemplateVariablesHandlerInterceptor(uriTemplateVariables));
   }
   return chain;
}

private void initHandlerMappings(ApplicationContext context) {
   this.handlerMappings = null;

   if (this.detectAllHandlerMappings) {
      // Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
      Map<String, HandlerMapping> matchingBeans =
            BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
      if (!matchingBeans.isEmpty()) {
         this.handlerMappings = new ArrayList<>(matchingBeans.values());
         // We keep HandlerMappings in sorted order.
         AnnotationAwareOrderComparator.sort(this.handlerMappings);
      }
   }
   else {
      try {
         HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
         this.handlerMappings = Collections.singletonList(hm);
      }
      catch (NoSuchBeanDefinitionException ex) {
         // Ignore, we'll add a default HandlerMapping later.
      }
   }

   // Ensure we have at least one HandlerMapping, by registering
   // a default HandlerMapping if no other mappings are found.
   if (this.handlerMappings == null) {
      this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
      if (logger.isTraceEnabled()) {
         logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
               "': using default strategies from DispatcherServlet.properties");
      }
   }
}

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
   org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
   org.springframework.web.servlet.function.support.RouterFunctionMapping

@Override
protected String[] determineUrlsForHandler(String beanName) {
   // url 列表
   List<String> urls = new ArrayList<>();
   if (beanName.startsWith("/")) {
      urls.add(beanName);
   }
   // 获取 beanName的别名
   String[] aliases = obtainApplicationContext().getAliases(beanName);
   for (String alias : aliases) {
      if (alias.startsWith("/")) {
         urls.add(alias);
      }
   }
   return StringUtils.toStringArray(urls);
}

protected void detectHandlers() throws BeansException {
   // 提取上下文
   ApplicationContext applicationContext = obtainApplicationContext();
   // 获取所有所有的BeanName
   String[] beanNames = (this.detectHandlersInAncestorContexts ?
         BeanFactoryUtils.beanNamesForTypeIncludingAncestors(applicationContext, Object.class) :
         applicationContext.getBeanNamesForType(Object.class));

   // Take any bean name that we can determine URLs for.
   // 循环处理BeanName 找到以/开头的数据
   for (String beanName : beanNames) {
      String[] urls = determineUrlsForHandler(beanName);
      if (!ObjectUtils.isEmpty(urls)) {
         // URL paths found: Let's consider it a handler.
         // 注册处理器
         registerHandler(urls, beanName);
      }
   }

   if ((logger.isDebugEnabled() && !getHandlerMap().isEmpty()) || logger.isTraceEnabled()) {
      logger.debug("Detected " + getHandlerMap().size() + " mappings in " + formatMappingName());
   }
}

protected void registerHandler(String[] urlPaths, String beanName) throws BeansException, IllegalStateException {
   Assert.notNull(urlPaths, "URL path array must not be null");
   for (String urlPath : urlPaths) {
      registerHandler(urlPath, beanName);
   }
}

public class HttpRequestHandlerFirst implements HttpRequestHandler {
   @Override
   public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      PrintWriter writer = response.getWriter();
      writer.write("HttpRequestHandlerFirst");
   }
}

<bean name="/hrh" class="com.source.hot.mvc.httpRequestHandler.HttpRequestHandlerFirst" />

@Override
public void afterPropertiesSet() {
   this.config = new RequestMappingInfo.BuilderConfiguration();
   this.config.setUrlPathHelper(getUrlPathHelper());
   this.config.setPathMatcher(getPathMatcher());
   this.config.setSuffixPatternMatch(this.useSuffixPatternMatch);
   this.config.setTrailingSlashMatch(this.useTrailingSlashMatch);
   this.config.setRegisteredSuffixPatternMatch(this.useRegisteredSuffixPatternMatch);
   this.config.setContentNegotiationManager(getContentNegotiationManager());

   super.afterPropertiesSet();
}

<mvc:annotation-driven>
   <mvc:path-matching path-helper="" path-matcher="" registered-suffixes-only="" suffix-pattern="" trailing-slash=""/>
</mvc:annotation-driven>

@Override
public void afterPropertiesSet() {
   initHandlerMethods();
}
protected void initHandlerMethods() {
    for (String beanName : getCandidateBeanNames()) {
        if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
            processCandidateBean(beanName);
        }
    }
    handlerMethodsInitialized(getHandlerMethods());
}

protected void processCandidateBean(String beanName) {
   Class<?> beanType = null;
   try {
      // 获取 BeanName 对应的Bean类型
      beanType = obtainApplicationContext().getType(beanName);
   }
   catch (Throwable ex) {
      // An unresolvable bean type, probably from a lazy bean - let's ignore it.
      if (logger.isTraceEnabled()) {
         logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
      }
   }
   // 判断类型是否是 handler对象
   // 主要判断是否具备Controller 或者 RequestMapping 注解
   if (beanType != null && isHandler(beanType)) {
      // 确定 handlerMethod
      detectHandlerMethods(beanName);
   }
}

@Override
protected boolean isHandler(Class<?> beanType) {
   return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
         AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
}

protected void detectHandlerMethods(Object handler) {
   // 获取 handler 的类型
   Class<?> handlerType = (handler instanceof String ?
         obtainApplicationContext().getType((String) handler) : handler.getClass());

   if (handlerType != null) {
      // 反射加载类
      Class<?> userType = ClassUtils.getUserClass(handlerType);
      Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
            (MethodIntrospector.MetadataLookup<T>) method -> {
               try {
                  // 处理单个 method 
                  return getMappingForMethod(method, userType);
               }
               catch (Throwable ex) {
                  throw new IllegalStateException("Invalid mapping on handler class [" +
                        userType.getName() + "]: " + method, ex);
               }
            });
      if (logger.isTraceEnabled()) {
         logger.trace(formatMappings(userType, methods));
      }
      // 进行 handlerMethod 注册
      methods.forEach((method, mapping) -> {
         Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
         registerHandlerMethod(handler, invocableMethod, mapping);
      });
   }
}

// 方法签名： org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping#getMappingForMethod
@Override
@Nullable
protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
    // 创建 methd 对应的 RequestMappingInfo
    RequestMappingInfo info = createRequestMappingInfo(method);
    if (info != null) {
        // handler类的数据处理
        RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
        if (typeInfo != null) {
            // 类数据和方法数据整合
            info = typeInfo.combine(info);
        }
        // 前缀处理
        String prefix = getPathPrefix(handlerType);
        if (prefix != null) {
            info = RequestMappingInfo.paths(prefix).options(this.config).build().combine(info);
        }
    }
    return info;
}

@Nullable
private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
    // 提取 RequestMapping注解数据
    RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(element, RequestMapping.class);
    // 提取 RequestCondition 数据
    RequestCondition<?> condition = (element instanceof Class ?
                                     getCustomTypeCondition((Class<?>) element) : getCustomMethodCondition((Method) element));
    // 创建对象
    return (requestMapping != null ? createRequestMappingInfo(requestMapping, condition) : null);
}

protected RequestMappingInfo createRequestMappingInfo(
      RequestMapping requestMapping, @Nullable RequestCondition<?> customCondition) {

   RequestMappingInfo.Builder builder = RequestMappingInfo
         .paths(resolveEmbeddedValuesInPatterns(requestMapping.path()))
         .methods(requestMapping.method())
         .params(requestMapping.params())
         .headers(requestMapping.headers())
         .consumes(requestMapping.consumes())
         .produces(requestMapping.produces())
         .mappingName(requestMapping.name());
   if (customCondition != null) {
      builder.customCondition(customCondition);
   }
   return builder.options(this.config).build();
}

@RestController
public class HandleNoMatchController {
   @RequestMapping(value = "/getMapping", method = RequestMethod.GET)
   public String getMapping() {
      return "data";
   }
}

@RestController
@RequestMapping("/demo")
public class HandleNoMatchController {
   @RequestMapping(value = "/getMapping", method = RequestMethod.GET)
   public String getMapping() {
      return "data";
   }
}

methods.forEach((method, mapping) -> {
   // 获取执行方法,
   Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
   registerHandlerMethod(handler, invocableMethod, mapping);
});

@Override
protected void registerHandlerMethod(Object handler, Method method, RequestMappingInfo mapping) {
   super.registerHandlerMethod(handler, method, mapping);
   updateConsumesCondition(mapping, method);
}

private void updateConsumesCondition(RequestMappingInfo info, Method method) {
   // 提取 ConsumesRequestCondition 数据
   ConsumesRequestCondition condition = info.getConsumesCondition();
   if (!condition.isEmpty()) {
      for (Parameter parameter : method.getParameters()) {
         // 提取参数的RequestBody注解
         MergedAnnotation<RequestBody> annot = MergedAnnotations.from(parameter).get(RequestBody.class);
         if (annot.isPresent()) {
            // 设置是否必填
            condition.setBodyRequired(annot.getBoolean("required"));
            break;
         }
      }
   }
}

@PostMapping(value = "/postMapping/",
             consumes = {MediaType.APPLICATION_JSON_VALUE},
             produces = {"text/plain"}
            )
public Object postMapping(
    @RequestBody(required = false) Map<String, String> map
) {
    return "";
}

protected void registerHandlerMethod(Object handler, Method method, T mapping) {
   this.mappingRegistry.register(mapping, handler, method);
}

public void register(T mapping, Object handler, Method method) {
   // Assert that the handler method is not a suspending one.
   if (KotlinDetector.isKotlinType(method.getDeclaringClass()) && KotlinDelegate.isSuspend(method)) {
      throw new IllegalStateException("Unsupported suspending handler method detected: " + method);
   }
   this.readWriteLock.writeLock().lock();
   try {
      // handler method 创建
      HandlerMethod handlerMethod = createHandlerMethod(handler, method);
      // 验证 method mapping
      validateMethodMapping(handlerMethod, mapping);
      // 放入缓存
      this.mappingLookup.put(mapping, handlerMethod);

      // 通过 requestMappingInfo 找到 url
      List<String> directUrls = getDirectUrls(mapping);
      for (String url : directUrls) {
         this.urlLookup.add(url, mapping);
      }

      String name = null;
      if (getNamingStrategy() != null) {
         // 获取名字
         // 类名#方法名
         name = getNamingStrategy().getName(handlerMethod, mapping);
         // 设置 handlerMethod + name 的关系
         addMappingName(name, handlerMethod);
      }

       // 跨域配置信息处理
      CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
      if (corsConfig != null) {
         this.corsLookup.put(handlerMethod, corsConfig);
      }

      this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
   }
   finally {
      this.readWriteLock.writeLock().unlock();
   }
}

class MappingRegistry {

   /**
    * key:mapping
    * value: mapping registration
    */
   private final Map<T, MappingRegistration<T>> registry = new HashMap<>();

   /**
    * key: mapping
    * value: handlerMethod
    */
   private final Map<T, HandlerMethod> mappingLookup = new LinkedHashMap<>();

   /**
    * key: url
    * value: list mapping
    */
   private final MultiValueMap<String, T> urlLookup = new LinkedMultiValueMap<>();

   /**
    * key: name
    * value: handler method
    */
   private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();

   /**
    * key:handler method
    * value: 跨域配置
    */
   private final Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();
}

@Override
public void afterPropertiesSet() throws Exception {
   if (this.routerFunction == null) {
      // 初始化 routerFunction 对象
      initRouterFunction();
   }
   if (CollectionUtils.isEmpty(this.messageConverters)) {
      // 初始化 messageConverters 对象
      initMessageConverters();
   }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.4.RELEASE</version>

    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <groupId>com.source.hot</groupId>
  <artifactId>webflux-ex</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
  </dependencies>

</project>

@SpringBootApplication
public class App {

   public static void main(String[] args) {
      SpringApplication.run(App.class, args);
   }


   @Bean
   public RouterFunction<ServerResponse> productListing() {
      return route().GET("/product", req -> ok().body("hello"))
            .build();
   }

}

@SuppressWarnings({"rawtypes", "unchecked"})
private void initRouterFunction() {
    ApplicationContext applicationContext = obtainApplicationContext();
    // 获取容器中RouterFunction对象
    Map<String, RouterFunction> beans =
        (this.detectHandlerFunctionsInAncestorContexts ?
         BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, RouterFunction.class) :
         applicationContext.getBeansOfType(RouterFunction.class));


    // 待处理的返回值
    List<RouterFunction> routerFunctions = new ArrayList<>(beans.values());
    if (!CollectionUtils.isEmpty(routerFunctions) && logger.isInfoEnabled()) {
        routerFunctions.forEach(routerFunction -> logger.info("Mapped " + routerFunction));
    }
    // routerFunctions 数据处理
    this.routerFunction = routerFunctions.stream()
        .reduce(RouterFunction::andOther)
        .orElse(null);
}

private void initMessageConverters() {
   List<HttpMessageConverter<?>> messageConverters = new ArrayList<>(4);
   messageConverters.add(new ByteArrayHttpMessageConverter());
   messageConverters.add(new StringHttpMessageConverter());

   try {
      messageConverters.add(new SourceHttpMessageConverter<>());
   }
   catch (Error err) {
      // Ignore when no TransformerFactory implementation is available
   }
   messageConverters.add(new AllEncompassingFormHttpMessageConverter());

   this.messageConverters = messageConverters;
}

@Nullable
@Override
protected Object getHandlerInternal(HttpServletRequest servletRequest) throws Exception {
   // 获取请求地址
   String lookupPath = getUrlPathHelper().getLookupPathForRequest(servletRequest);
   // 设置属性
   servletRequest.setAttribute(LOOKUP_PATH, lookupPath);
   if (this.routerFunction != null) {
      // 创建 ServerRequest 对象
      ServerRequest request = ServerRequest.create(servletRequest, this.messageConverters);
      servletRequest.setAttribute(RouterFunctions.REQUEST_ATTRIBUTE, request);
      // 从 routerFunction 中找到对应的数据
      return this.routerFunction.route(request).orElse(null);
   } else {
      return null;
   }
}

GET("/product", req -> ok().body("hello"))

//org.springframework.web.servlet.handler.AbstractHandlerMethodMapping#createHandlerMethod
protected HandlerMethod createHandlerMethod(Object handler, Method method) {
   // 是否是字符串
   if (handler instanceof String) {
      // 创建对象
      return new HandlerMethod((String) handler,
            obtainApplicationContext().getAutowireCapableBeanFactory(), method);
   }
   return new HandlerMethod(handler, method);
}

public HandlerMethod(Object bean, Method method) {
   Assert.notNull(bean, "Bean is required");
   Assert.notNull(method, "Method is required");
   this.bean = bean;
   this.beanFactory = null;
   this.beanType = ClassUtils.getUserClass(bean);
   this.method = method;
   this.bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
   this.parameters = initMethodParameters();
   evaluateResponseStatus();
   this.description = initDescription(this.beanType, this.method);
}

public HandlerMethod(String beanName, BeanFactory beanFactory, Method method) {
   Assert.hasText(beanName, "Bean name is required");
   Assert.notNull(beanFactory, "BeanFactory is required");
   Assert.notNull(method, "Method is required");
   this.bean = beanName;
   this.beanFactory = beanFactory;
   Class<?> beanType = beanFactory.getType(beanName);
   if (beanType == null) {
      throw new IllegalStateException("Cannot resolve bean type for bean with name '" + beanName + "'");
   }
   this.beanType = ClassUtils.getUserClass(beanType);
   this.method = method;
   this.bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
   this.parameters = initMethodParameters();
   evaluateResponseStatus();
   this.description = initDescription(this.beanType, this.method);
}

public static Method findBridgedMethod(Method bridgeMethod) {
   if (!bridgeMethod.isBridge()) {
      return bridgeMethod;
   }
   Method bridgedMethod = cache.get(bridgeMethod);
   if (bridgedMethod == null) {
      // Gather all methods with matching name and parameter size.
      List<Method> candidateMethods = new ArrayList<>();
      MethodFilter filter = candidateMethod ->
            isBridgedCandidateFor(candidateMethod, bridgeMethod);
      ReflectionUtils.doWithMethods(bridgeMethod.getDeclaringClass(), candidateMethods::add, filter);
      if (!candidateMethods.isEmpty()) {
         bridgedMethod = candidateMethods.size() == 1 ?
               candidateMethods.get(0) :
               searchCandidates(candidateMethods, bridgeMethod);
      }
      if (bridgedMethod == null) {
         // A bridge method was passed in but we couldn't find the bridged method.
         // Let's proceed with the passed-in method and hope for the best...
         bridgedMethod = bridgeMethod;
      }
      cache.put(bridgeMethod, bridgedMethod);
   }
   return bridgedMethod;
}

private static final Map<Method, Method> cache = new ConcurrentReferenceHashMap<>();

ReflectionUtils.doWithMethods(bridgeMethod.getDeclaringClass(), candidateMethods::add, filter)

private MethodParameter[] initMethodParameters() {
   int count = this.bridgedMethod.getParameterCount();
   MethodParameter[] result = new MethodParameter[count];
   for (int i = 0; i < count; i++) {
      result[i] = new HandlerMethodParameter(i);
   }
   return result;
}

private void evaluateResponseStatus() {
   ResponseStatus annotation = getMethodAnnotation(ResponseStatus.class);
   if (annotation == null) {
      annotation = AnnotatedElementUtils.findMergedAnnotation(getBeanType(), ResponseStatus.class);
   }
   if (annotation != null) {
      this.responseStatus = annotation.code();
      this.responseStatusReason = annotation.reason();
   }
}