//Scan beans in the ApplicationContext, detect and register handler methods.
protected void initHandlerMethods() {
 ...
 //獲取applicationContext中所有的bean name
 String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ?
 BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
 getApplicationContext().getBeanNamesForType(Object.class));
 
 //遍歷beanName數(shù)組
 for (String beanName : beanNames) {
 //isHandler會根據(jù)bean來判斷bean定義中是否帶有Controller注解或RequestMapping注解
 if (isHandler(getApplicationContext().getType(beanName))){
 detectHandlerMethods(beanName);
 }
 }
 handlerMethodsInitialized(getHandlerMethods());
}

 /**
 * Look for handler methods in a handler
 * @param handler the bean name of a handler or a handler instance
 */
protected void detectHandlerMethods(final Object handler) {
 //獲取當(dāng)前Controller bean的class對象
 Class<?> handlerType = (handler instanceof String) ?
 getApplicationContext().getType((String) handler) : handler.getClass();
 //避免重復(fù)調(diào)用 getMappingForMethod 來重建 RequestMappingInfo 實例
 final Map<Method, T> mappings = new IdentityHashMap<Method, T>();
 //同上，也是該Controller bean的class對象
 final Class<?> userType = ClassUtils.getUserClass(handlerType); 
 //獲取當(dāng)前bean的所有handler method
 //根據(jù) method 定義是否帶有 RequestMapping 
 //若有則創(chuàng)建RequestMappingInfo實例
 Set<Method> methods = HandlerMethodSelector.selectMethods(userType, new MethodFilter() {
  @Override
  public boolean matches(Method method) {
  T mapping = getMappingForMethod(method, userType);
  if (mapping != null) {
   mappings.put(method, mapping);
   return true;
  }
  else {
   return false;
  }
  }
 });

 //遍歷并注冊當(dāng)前bean的所有handler method
 for (Method method : methods) {
  //注冊handler method，進(jìn)入以下方法
  registerHandlerMethod(handler, method, mappings.get(method));
 }

 @Override
 protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
 RequestMappingInfo info = null;
 //獲取method的@RequestMapping
 RequestMapping methodAnnotation = AnnotationUtils.findAnnotation(method, RequestMapping.class);
 if (methodAnnotation != null) {
  RequestCondition<?> methodCondition = getCustomMethodCondition(method);
  info = createRequestMappingInfo(methodAnnotation, methodCondition);
  //獲取method所屬bean的@RequtestMapping注解
  RequestMapping typeAnnotation = AnnotationUtils.findAnnotation(handlerType, RequestMapping.class);
  if (typeAnnotation != null) {
  RequestCondition<?> typeCondition = getCustomTypeCondition(handlerType);
  //合并兩個@RequestMapping注解
  info = createRequestMappingInfo(typeAnnotation, typeCondition).combine(info);
  }
 }
 return info;
 }

protected void registerHandlerMethod(Object handler, Method method, T mapping) {
 //創(chuàng)建HandlerMethod
 HandlerMethod newHandlerMethod = createHandlerMethod(handler, method);
 HandlerMethod oldHandlerMethod = handlerMethods.get(mapping);
 //檢查配置是否存在歧義性
 if (oldHandlerMethod != null && !oldHandlerMethod.equals(newHandlerMethod)) {
  throw new IllegalStateException("Ambiguous mapping found. Cannot map '" + newHandlerMethod.getBean()
   + "' bean method \n" + newHandlerMethod + "\nto " + mapping + ": There is already '"
   + oldHandlerMethod.getBean() + "' bean method\n" + oldHandlerMethod + " mapped.");
 }
 this.handlerMethods.put(mapping, newHandlerMethod);
 if (logger.isInfoEnabled()) {
  logger.info("Mapped \"" + mapping + "\" onto " + newHandlerMethod);
 }
 //獲取@RequestMapping注解的value，然后添加value->RequestMappingInfo映射記錄至urlMap中
 Set<String> patterns = getMappingPathPatterns(mapping);
 for (String pattern : patterns) {
  if (!getPathMatcher().isPattern(pattern)) {
  this.urlMap.add(pattern, mapping);
  }
 }
}

@Controller
@RequestMapping("/AmbiguousTest")
public class AmbiguousTestController {
 @RequestMapping(value = "/test1")
 @ResponseBody
 public String test1(){
  return "method test1";
 }
 @RequestMapping(value = "/test1")
 @ResponseBody
 public String test2(){
  return "method test2";
 }
}

@Controller
@RequestMapping("/UrlMap")
public class UrlMapController {
 @RequestMapping(value = "/test1", method = RequestMethod.GET)
 @ResponseBody
 public String test1(){
  return "method test1";
 }

 @RequestMapping(value = "/test1")
 @ResponseBody
 public String test2(){
  return "method test2";
 }

 @RequestMapping(value = "/test3")
 @ResponseBody
 public String test3(){
  return "method test3";
 }
}

@Controller
@RequestMapping("/LookupTest")
public class LookupTestController {

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

 @RequestMapping(value = "/test1", headers = "Referer=https://www.baidu.com")
 @ResponseBody
 public String test2(){
  return "method test2";
 }

 @RequestMapping(value = "/test1", params = "id=1")
 @ResponseBody
 public String test3(){
  return "method test3";
 }

 @RequestMapping(value = "/*")
 @ResponseBody
 public String test4(){
  return "method test4";
 }
}

protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
 List<Match> matches = new ArrayList<Match>();
 //根據(jù)uri獲取直接匹配的RequestMappingInfos
 List<T> directPathMatches = this.urlMap.get(lookupPath);
 if (directPathMatches != null) {
  addMatchingMappings(directPathMatches, matches, request);
 }
 //不存在直接匹配的RequetMappingInfo，遍歷所有RequestMappingInfo
 if (matches.isEmpty()) {
  // No choice but to go through all mappings
  addMatchingMappings(this.handlerMethods.keySet(), matches, request);
 }
 //獲取最佳匹配的RequestMappingInfo對應(yīng)的HandlerMethod
 if (!matches.isEmpty()) {
  Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
  Collections.sort(matches, comparator);

  if (logger.isTraceEnabled()) {
  logger.trace("Found " + matches.size() + " matching mapping(s) for [" + lookupPath + "] : " + matches);
  }
  //再一次檢查配置的歧義性
  Match bestMatch = matches.get(0);
  if (matches.size() > 1) {
  Match secondBestMatch = matches.get(1);
  if (comparator.compare(bestMatch, secondBestMatch) == 0) {
   Method m1 = bestMatch.handlerMethod.getMethod();
   Method m2 = secondBestMatch.handlerMethod.getMethod();
   throw new IllegalStateException(
     "Ambiguous handler methods mapped for HTTP path '" + request.getRequestURL() + "': {" +
     m1 + ", " + m2 + "}");
  }
  }

  handleMatch(bestMatch.mapping, lookupPath, request);
  return bestMatch.handlerMethod;
 }
 else {
  return handleNoMatch(handlerMethods.keySet(), lookupPath, request);
 }
}

private void addMatchingMappings(Collection<T> mappings, List<Match> matches, HttpServletRequest request) {
 for (T mapping : mappings) {
  T match = getMatchingMapping(mapping, request);
  if (match != null) {
  matches.add(new Match(match, handlerMethods.get(mapping)));
  }
 }
}

public int compareTo(RequestMappingInfo other, HttpServletRequest request) {
 int result = patternsCondition.compareTo(other.getPatternsCondition(), request);
 if (result != 0) {
  return result;
 }
 result = paramsCondition.compareTo(other.getParamsCondition(), request);
 if (result != 0) {
  return result;
 }
 result = headersCondition.compareTo(other.getHeadersCondition(), request);
 if (result != 0) {
  return result;
 }
 result = consumesCondition.compareTo(other.getConsumesCondition(), request);
 if (result != 0) {
  return result;
 }
 result = producesCondition.compareTo(other.getProducesCondition(), request);
 if (result != 0) {
  return result;
 }
 result = methodsCondition.compareTo(other.getMethodsCondition(), request);
 if (result != 0) {
  return result;
 }
 result = customConditionHolder.compareTo(other.customConditionHolder, request);
 if (result != 0) {
  return result;
 }
 return 0;
}

@RequestMapping(value = "/test5", method = {RequestMethod.GET, RequestMethod.POST})
@ResponseBody
public String test5(){
 return "method test5";
}
@RequestMapping(value = "/test5", method = {RequestMethod.GET, RequestMethod.DELETE})
@ResponseBody
public String test6(){
 return "method test6";
}

public int compareTo(RequestMethodsRequestCondition other, HttpServletRequest request) {
 return other.methods.size() - this.methods.size();
}