你了解SpringBoot启动时API相关信息是用什么数据结构存储的吗？（上篇）

@ResponseBody
@GetMapping("/test")
public String test(){
    return "test";
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@RequestMapping(method = RequestMethod.GET)
public @interface GetMapping {
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController {
}

/** HandlerMapping实现的抽象基类，定义了请求和HandlerMethod之间的映射。
对于每个注册的处理程序方法，一个唯一的映射由定义映射类型<T>细节的子类维护 
*/
public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping implements InitializingBean {
    // ...
    /**在初始化时检测处理程序方法。 可以说是入口处啦*/
    @Override
    public void afterPropertiesSet() {
        initHandlerMethods();
    }
    /**扫描 ApplicationContext 中的 bean，检测和注册处理程序方法。 */
    protected void initHandlerMethods() {
        //getCandidateBeanNames() :确定应用程序上下文中候选 bean 的名称。
        for (String beanName : getCandidateBeanNames()) {
            if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
                //确定指定候选 bean 的类型，如果标识为处理程序类型，则调用detectHandlerMethods 
                // 这里的处理程序 就为我们在controller 中书写的那些接口方法
                processCandidateBean(beanName);
            }
        }
        // 这里的逻辑不做讨论啦
        handlerMethodsInitialized(getHandlerMethods());
    }
    // ...
}

/** 确定指定候选 bean 的类型，如果标识为处理程序类型，则调用detectHandlerMethods 。  */
protected void processCandidateBean(String beanName) {
    Class<?> beanType = null;
    try {
        // 确定注入的bean 类型
        beanType = obtainApplicationContext().getType(beanName);
    }
    catch (Throwable ex) {
        // 无法解析的bean
        if (logger.isTraceEnabled()) {
            logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
        }
    }
  //isHandler 方法判断是否是web资源类。
    if (beanType != null && isHandler(beanType)) {
        // 算是这条线路上重点啦
        detectHandlerMethods(beanName);
    }
}

/**
给定类型是否是具有处理程序方法的处理程序。处理程序就是我们写的 Controller 类中的接口方法
期望处理程序具有类型级别的Controller注释或类型级别的RequestMapping注释。
*/
@Override
protected boolean isHandler(Class<?> beanType) {
    return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
            AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
}

/** 在指定的处理程序 bean 中查找处理程序方法。*/
  protected void detectHandlerMethods(Object handler) {
    Class<?> handlerType = (handler instanceof String ?
        obtainApplicationContext().getType((String) handler) : handler.getClass());
    if (handlerType != null) {
            //返回给定类的用户定义类：通常只是给定的类，但如果是 CGLIB 生成的子类，则返回原始类。
      Class<?> userType = ClassUtils.getUserClass(handlerType);
            //selectMethods:
            //根据相关元数据的查找，选择给定目标类型的方法。
      // 调用者通过MethodIntrospector.MetadataLookup参数定义感兴趣的方法，允许将关联的元数据收集到结果映射中
            // 简单理解 ：解析RequestMapping信息
      Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
          (MethodIntrospector.MetadataLookup<T>) method -> {
            try {
                              //为处理程序方法提供映射。 不能为其提供映射的方法不是处理程序方法
              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));
      }
      else if (mappingsLogger.isDebugEnabled()) {
        mappingsLogger.debug(formatMappings(userType, methods));
      }
            // 这里将解析的信息,循环进行注册
      methods.forEach((method, mapping) -> {
        Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
        registerHandlerMethod(handler, invocableMethod, mapping);
      });
    }
  }

/** 使用方法和类型级别的RequestMapping注解来创建RequestMappingInfo。 */
@Override
@Nullable
protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
    RequestMappingInfo info = createRequestMappingInfo(method);
    if (info != null) {
        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;
}

/**
委托createRequestMappingInfo(RequestMapping, RequestCondition) ，根据提供的annotatedElement是类还是方法提供适当的自定义RequestCondition 。
*/
@Nullable
private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
    //主要是 解析 Method 上的 @RequestMapping 信息
    RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(element, RequestMapping.class);
    RequestCondition<?> condition = (element instanceof Class ?
                                     getCustomTypeCondition((Class<?>) element) : getCustomMethodCondition((Method) element));
    return (requestMapping != null ? createRequestMappingInfo(requestMapping, condition) : null);
}

public static <T> Map<Method, T> selectMethods(Class<?> targetType, final MetadataLookup<T> metadataLookup) {
    final Map<Method, T> methodMap = new LinkedHashMap<>();
    Set<Class<?>> handlerTypes = new LinkedHashSet<>();
    Class<?> specificHandlerType = null;
    if (!Proxy.isProxyClass(targetType)) {
        specificHandlerType = ClassUtils.getUserClass(targetType);
        handlerTypes.add(specificHandlerType);
    }
    handlerTypes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetType));
    for (Class<?> currentHandlerType : handlerTypes) {
        final Class<?> targetClass = (specificHandlerType != null ? specificHandlerType : currentHandlerType);
        //对给定类和超类（或给定接口和超接口）的所有匹配方法执行给定的回调操作。
        ReflectionUtils.doWithMethods(currentHandlerType, method -> {
            Method specificMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
            T result = metadataLookup.inspect(specificMethod);
            if (result != null) {
                // BridgeMethodResolver :给定一个合成bridge Method返回被桥接的Method 。 
                //当扩展其方法具有参数化参数的参数化类型时，编译器可能会创建桥接方法。 在运行时调用期间，可以通过反射调用和/或使用桥接Method 
                //findBridgedMethod : 找到提供的bridge Method的原始方法。
                Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
                if (bridgedMethod == specificMethod || metadataLookup.inspect(bridgedMethod) == null) {
                    methodMap.put(specificMethod, result);
                }
            }
        }, ReflectionUtils.USER_DECLARED_METHODS);
    }
    return methodMap;
}

methods.forEach((method, mapping) -> {
    //选择目标类型上的可调用方法：如果实际公开在目标类型上，则给定方法本身，或者目标类型的接口之一或目标类型本身上的相应方法。
   // 简单理解返回个方法吧
    Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
    registerHandlerMethod(handler, invocableMethod, mapping);
});

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

public void register(T mapping, Object handler, Method method) {
    this.readWriteLock.writeLock().lock();
    try {
        //创建 HandlerMethod 实例。
        HandlerMethod handlerMethod = createHandlerMethod(handler, method);
        //验证方法映射
        validateMethodMapping(handlerMethod, mapping);
        //这里就是直接获取路径  mapping 的值是 GET[/login]
        // 获取出来后 就是 /login
        Set<String> directPaths = AbstractHandlerMethodMapping.this.getDirectPaths(mapping);
        for (String path : directPaths) {
            //this.pathLookup 它的定义如下：
            //   private final MultiValueMap<String, T> pathLookup = new LinkedMultiValueMap<>();
            //   其实new 就是一个 new LinkedHashMap<>();
            // 这里就是将 path 作为key ，mapping作为value 存起来
            this.pathLookup.add(path, mapping);
        }
        String name = null;
        // 这里的意思可以归纳为：
        if (getNamingStrategy() != null) {
            ///确定给定 HandlerMethod 和映射的名称。
            name = getNamingStrategy().getName(handlerMethod, mapping);
            addMappingName(name, handlerMethod);
        }
        // 下面几行是处理跨域问题的，不是我们本章讨论的。大家感兴趣可以去看看。
        CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
        if (corsConfig != null) {
            corsConfig.validateAllowCredentials();
            this.corsLookup.put(handlerMethod, corsConfig);
        }
        this.registry.put(mapping,
                          new MappingRegistration<>(mapping, handlerMethod, directPaths, name, corsConfig != null));
    }
    finally {
        this.readWriteLock.writeLock().unlock();
    }
}

this.registry.put(mapping,
                          new MappingRegistration<>(mapping, handlerMethod, directPaths, name, corsConfig != null));