@RequestMapping(value = "/user/{aid}/online/**", method = RequestMethod.GET)

HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);

  List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
  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);
  }

 public RequestMappingInfo getMatchingCondition(HttpServletRequest request) {
  RequestMethodsRequestCondition methods = this.methodsCondition.getMatchingCondition(request);
  ParamsRequestCondition params = this.paramsCondition.getMatchingCondition(request);
  HeadersRequestCondition headers = this.headersCondition.getMatchingCondition(request);
  ConsumesRequestCondition consumes = this.consumesCondition.getMatchingCondition(request);
  ProducesRequestCondition produces = this.producesCondition.getMatchingCondition(request);
 
  if (methods == null || params == null || headers == null || consumes == null || produces == null) {
   return null;
  }
 
  PatternsRequestCondition patterns = this.patternsCondition.getMatchingCondition(request);
  if (patterns == null) {
   return null;
  }

  if (this.pathMatcher.match(pattern, lookupPath)) {
   return pattern;
  }

protected void initHandlerMethods() {
 if (logger.isDebugEnabled()) {
   logger.debug("Looking for request mappings in application context: " + getApplicationContext());
  }
 
        //獲取Spring容器裝配的所有bean的名稱
 String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ?
    BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
    getApplicationContext().getBeanNamesForType(Object.class));
 
           //遍歷
 for (String beanName : beanNames) {
                //判斷該bean是否有@controller或者@RequestMapping注解
  if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX) &&
    isHandler(getApplicationContext().getType(beanName))){
                        //如果有上述注解，則需要保存對(duì)應(yīng)關(guān)系
   detectHandlerMethods(beanName);
  }
 }
 handlerMethodsInitialized(getHandlerMethods());
}
protected void detectHandlerMethods(final Object handler) {
        //獲取傳過來handler的類信息
 Class<?> handlerType =
   (handler instanceof String ? getApplicationContext().getType((String) handler) : handler.getClass());
 
 // Avoid repeated calls to getMappingForMethod which would rebuild RequestMappingInfo instances
        //初始化一個(gè)保存映射信息的map
 final Map<Method, T> mappings = new IdentityHashMap<Method, T>();
 final Class<?> userType = ClassUtils.getUserClass(handlerType);
 
 Set<Method> methods = HandlerMethodSelector.selectMethods(userType, new MethodFilter() {
  @Override
  public boolean matches(Method method) {
                //獲取該類里所有方法的映射信息 T為RequestMappingInfo
                //mapping值的形式為{[/test/test1],methods=[],params=[],headers=[],consumes=[],produces=[],custom=[]}
   T mapping = getMappingForMethod(method, userType);
   if (mapping != null) {
                                //將信息加入map
    mappings.put(method, mapping);
    return true;
   }
   else {
    return false;
   }
  }
 });
 
 for (Method method : methods) {
                //注冊(cè)HandlerMethod，在里邊進(jìn)行一些重復(fù)驗(yàn)證等
  registerHandlerMethod(handler, method, mappings.get(method));
 }
}

@Override
//該方法接收兩個(gè)參數(shù)，一個(gè)是具體方法，一個(gè)是方法所在的類
 protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
  RequestMappingInfo info = null;
//找到方法的@RequestMapping注解
  RequestMapping methodAnnotation = AnnotationUtils.findAnnotation(method, RequestMapping.class);
  if (methodAnnotation != null) {
//這個(gè)方法返回null
   RequestCondition<?> methodCondition = getCustomMethodCondition(method);
//創(chuàng)建RequestMappingInfo對(duì)象
   info = createRequestMappingInfo(methodAnnotation, methodCondition);
//找到類的@RequestMapping注解
   RequestMapping typeAnnotation = AnnotationUtils.findAnnotation(handlerType, RequestMapping.class);
   if (typeAnnotation != null) {
//該方法也返回一個(gè)null
    RequestCondition<?> typeCondition = getCustomTypeCondition(handlerType);
//如果類和方法都有@RequestMapping注解，則進(jìn)行combine操作
    info = createRequestMappingInfo(typeAnnotation, typeCondition).combine(info);
   }
  }
  return info;
 }

protected RequestMappingInfo createRequestMappingInfo(RequestMapping annotation, RequestCondition<?> customCondition) {
//拿到@RequestMapping注解上的value值
  String[] patterns = resolveEmbeddedValuesInPatterns(annotation.value());
//創(chuàng)建一個(gè)RequestMappingInfo，參數(shù)為一堆condition，出了PatternsRequestCondition，其余全部使用@RequestMapping注解上的值
  return new RequestMappingInfo(
    annotation.name(),
    new PatternsRequestCondition(patterns, getUrlPathHelper(), getPathMatcher(),
      this.useSuffixPatternMatch, this.useTrailingSlashMatch, this.fileExtensions),
    new RequestMethodsRequestCondition(annotation.method()),
    new ParamsRequestCondition(annotation.params()),
    new HeadersRequestCondition(annotation.headers()),
    new ConsumesRequestCondition(annotation.consumes(), annotation.headers()),
    new ProducesRequestCondition(annotation.produces(), annotation.headers(), this.contentNegotiationManager),
    customCondition);
 }

protected void registerHandlerMethod(Object handler, Method method, T mapping) {
//handler此處為帶有@controller或者@RequestMapping的類的名稱
//初始化一個(gè)HandlerMethod，包含一些類的名稱和方法等信息
  HandlerMethod newHandlerMethod = createHandlerMethod(handler, method);
  HandlerMethod oldHandlerMethod = this.handlerMethods.get(mapping);
//判斷是否有handlerMethods是否有重復(fù)數(shù)據(jù)，有則拋異常，沒有則將其加入handlerMethods map中
  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);
  }
 
//將沒有*號(hào)和問好的pattern加入到urlMap中
  Set<String> patterns = getMappingPathPatterns(mapping);
  for (String pattern : patterns) {
   if (!getPathMatcher().isPattern(pattern)) {
    this.urlMap.add(pattern, mapping);
   }
  }
 
//維護(hù)一個(gè)nameMap，key為名字，格式為congroller類大寫字母+#+方法名
//比如TestBank類的getBank方法，可以為TB#getBank
  if (this.namingStrategy != null) {
   String name = this.namingStrategy.getName(newHandlerMethod, mapping);
   updateNameMap(name, newHandlerMethod);
  }
 }

protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
  List<Match> matches = new ArrayList<Match>();
//從urlMap中尋找能匹配的處理方法
  List<T> directPathMatches = this.urlMap.get(lookupPath);
//如果從urlMap中找到匹配的處理方法，則調(diào)用addMatchingMappings方法，將匹配的方法放入matches集合
  if (directPathMatches != null) {
   addMatchingMappings(directPathMatches, matches, request);
  }
//如果urlMap中沒有找到直接匹配的方法
  if (matches.isEmpty()) {
   // No choice but to go through all mappings...
   addMatchingMappings(this.handlerMethods.keySet(), matches, request);
  }
 
  if (!matches.isEmpty()) {
//如果找到了匹配的方法，先獲取一個(gè)比較器
   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);
   }
//如果成功匹配的方法只有一個(gè)，拿這個(gè)方法返回。如果匹配到多個(gè)方法，取最匹配的前兩個(gè)進(jìn)行比較。
//如果比較結(jié)果為0，則拋出沒有找到唯一合適處理方法的異常
   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 {
//沒有找到匹配的則返回null
   return handleNoMatch(handlerMethods.keySet(), lookupPath, request);
  }
 }