SpringMVC常见组件之HandlerMapping分析

//  返回HandlerInterceptor数组
protected final HandlerInterceptor[] getAdaptedInterceptors() {}
// 返回 HandlerExecutionChain 其包括handler HandlerInterceptor
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {}
// 返回所有配置的MappedInterceptor
protected final MappedInterceptor[] getMappedInterceptors() {}
// 抽象方法供子类实现 ，返回一个handler
protected abstract Object getHandlerInternal(HttpServletRequest request) throws Exception;

@Override
@Nullable
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
  // 这里会走到具体子类的实现
  Object handler = getHandlerInternal(request);
  if (handler == null) {
    handler = getDefaultHandler();
  }
  if (handler == null) {
    return null;
  }
  // Bean name or resolved handler?
  if (handler instanceof String) {
    String handlerName = (String) handler;
    handler = obtainApplicationContext().getBean(handlerName);
  }
  // 根据handler request获取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 = getCorsConfiguration(handler, request);
    if (getCorsConfigurationSource() != null) {
      CorsConfiguration globalConfig = getCorsConfigurationSource().getCorsConfiguration(request);
      config = (globalConfig != null ? globalConfig.combine(config) : config);
    }
    if (config != null) {
      config.validateAllowCredentials();
    }
    executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
  }
  return executionChain;
}

protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
  HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
      (HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
  for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
    if (interceptor instanceof MappedInterceptor) {
      MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
      if (mappedInterceptor.matches(request)) {
        chain.addInterceptor(mappedInterceptor.getInterceptor());
      }
    }
    else {
      chain.addInterceptor(interceptor);
    }
  }
  return chain;
}

protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
  String lookupPath = initLookupPath(request);
  Object handler;
  if (usesPathPatterns()) {
    RequestPath path = ServletRequestPathUtils.getParsedRequestPath(request);
    handler = lookupHandler(path, lookupPath, request);
  }
  else {
    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 (StringUtils.matchesCharacter(lookupPath, '/')) {
      rawHandler = getRootHandler();
    }
    if (rawHandler == null) {
      rawHandler = getDefaultHandler();
    }
    if (rawHandler != null) {
      // Bean name or resolved handler?
      if (rawHandler instanceof String) {
        String handlerName = (String) rawHandler;
        rawHandler = obtainApplicationContext().getBean(handlerName);
      }
      // 这里默认是空方法
      validateHandler(rawHandler, request);
      handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
    }
  }
  return handler;
}

@Nullable
protected Object lookupHandler(String lookupPath, HttpServletRequest request) throws Exception {
  Object handler = getDirectMatch(lookupPath, request);
  if (handler != null) {
    return handler;
  }
  // Pattern match? 也就是通配符匹配
  List<String> matchingPatterns = new ArrayList<>();
  for (String registeredPattern : this.handlerMap.keySet()) {
    if (getPathMatcher().match(registeredPattern, lookupPath)) {
      matchingPatterns.add(registeredPattern);
    }
    else if (useTrailingSlashMatch()) {
      if (!registeredPattern.endsWith("/") && getPathMatcher().match(registeredPattern + "/", lookupPath)) {
        matchingPatterns.add(registeredPattern + "/");
      }
    }
  }
  String bestMatch = null;
  // AntPathMatcher.AntPatternComparator
  Comparator<String> patternComparator = getPathMatcher().getPatternComparator(lookupPath);
  if (!matchingPatterns.isEmpty()) {
    matchingPatterns.sort(patternComparator);
    if (logger.isTraceEnabled() && matchingPatterns.size() > 1) {
      logger.trace("Matching patterns " + matchingPatterns);
    }
    bestMatch = matchingPatterns.get(0);
  }
  if (bestMatch != null) {
    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, lookupPath);
    // There might be multiple 'best patterns', let's make sure we have the correct URI template variables
    // for all of them
    Map<String, String> uriTemplateVariables = new LinkedHashMap<>();
    for (String matchingPattern : matchingPatterns) {
      if (patternComparator.compare(bestMatch, matchingPattern) == 0) {
        Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(matchingPattern, lookupPath);
        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);
  }
  // No handler found...
  return null;
}

@Override
public void initApplicationContext() throws ApplicationContextException {
  super.initApplicationContext();
  detectHandlers();
}

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)) {
        resolvedHandler = applicationContext.getBean(handlerName);
      }
    }
    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 (getPatternParser() != null) {
          this.pathPatternHandlerMap.put(getPatternParser().parse(urlPath), resolvedHandler);
        }
        if (logger.isTraceEnabled()) {
          logger.trace("Mapped [" + urlPath + "] onto " + getHandlerDescription(handler));
        }
      }
    }
  }

private final Map<String, Object> urlMap = new LinkedHashMap<>();
// 空的构造函数
public SimpleUrlHandlerMapping() {
}
//根据urlMap 初始化  final Map<String, Object> urlMap
public SimpleUrlHandlerMapping(Map<String, ?> urlMap) {
  setUrlMap(urlMap);
}
// 在前者的基础上并设置当前handleMapping的order
public SimpleUrlHandlerMapping(Map<String, ?> urlMap, int order) {
  setUrlMap(urlMap);
  setOrder(order);
}

@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.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());
    }
  }
}

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

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
     <property name="urlMap">
         <map>
             <entry key="/hello" value="helloController"/>
         </map>
     </property>
     <!--或者如下配置-->
     <property name="mappings">
        <props>
             <prop key="/hello">helloController</prop>
         </props>
     </property>
     <!--或者如下配置-->
     <property name="mappings">
        <value>
       /hello=helloController
    </value>
     </property>
 </bean>

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

/**=org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler#0

protected void detectHandlers() throws BeansException {
  ApplicationContext applicationContext = obtainApplicationContext();
  String[] beanNames = (this.detectHandlersInAncestorContexts ?
      BeanFactoryUtils.beanNamesForTypeIncludingAncestors(applicationContext, Object.class) :
      applicationContext.getBeanNamesForType(Object.class));
  // Take any bean name that we can determine URLs for.
  for (String beanName : beanNames) {
    String[] urls = determineUrlsForHandler(beanName);
    if (!ObjectUtils.isEmpty(urls)) {
      // URL paths found: Let's consider it a handler.
      registerHandler(urls, beanName);
    }
  }
// ... 这里是无需关注的日志打印
}
prote

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

@org.springframework.stereotype.Controller("/helloController")
public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.out.println(request.getRequestURI());
        System.out.println(this.getClass().getName());
        ModelAndView modelAndView=new ModelAndView();
        modelAndView.setViewName("success");
        return modelAndView;
    }
}

//RequestMappingInfoHandlerMapping实现
protected abstract T getMatchingMapping(T mapping, HttpServletRequest request);
//RequestMappingInfoHandlerMapping实现
protected abstract Comparator<T> getMappingComparator(HttpServletRequest request);
//RequestMappingHandlerMapping实现
protected abstract boolean isHandler(Class<?> beanType);
//RequestMappingHandlerMapping实现
protected abstract T getMappingForMethod(Method method, Class<?> handlerType);

@Override
@SuppressWarnings("deprecation")
public void afterPropertiesSet() {
  this.config = new RequestMappingInfo.BuilderConfiguration();
  this.config.setTrailingSlashMatch(useTrailingSlashMatch());
  this.config.setContentNegotiationManager(getContentNegotiationManager());
  if (getPatternParser() != null) {
    this.config.setPatternParser(getPatternParser());
    Assert.isTrue(!this.useSuffixPatternMatch && !this.useRegisteredSuffixPatternMatch,
        "Suffix pattern matching not supported with PathPatternParser.");
  }
  else {
    this.config.setSuffixPatternMatch(useSuffixPatternMatch());
    this.config.setRegisteredSuffixPatternMatch(useRegisteredSuffixPatternMatch());
    this.config.setPathMatcher(getPathMatcher());
  }
  super.afterPropertiesSet();
}

@Override
public void afterPropertiesSet() {
  initHandlerMethods();
}

@Override
public void afterPropertiesSet() {
  initHandlerMethods();
}

① initHandlerMethods
initHandlerMethods方法源码如下：
// 在Ap

protected void processCandidateBean(String beanName) {
Class<?> beanType = null;
  try {
    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);
    }
  }
  if (beanType != null && isHandler(beanType)) {
      // 注意，这里是核心
    detectHandlerMethods(beanName);
  }
}

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

 // 返回只读的map  mapping ：HandlerMethod
public Map<T, HandlerMethod> getHandlerMethods() {
 // private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  this.mappingRegistry.acquireReadLock();
  try {
    return Collections.unmodifiableMap(
        this.mappingRegistry.getRegistrations().entrySet().stream()
            .collect(Collectors.toMap(Map.Entry::getKey, entry -> entry.getValue().handlerMethod)));
  }
  finally {
    this.mappingRegistry.releaseReadLock();
  }
}

@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;
}

@Nullable
private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
// //获取方法method上的@RequestMapping实例。
  RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(element, RequestMapping.class);
// 这里始终为null  
  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();
}

@org.s@org.springframework.web.bind.annotation.RequestMapping(consumes=[], headers=[], method=[], name=, params=[], path=[/**/testInterceptor], produces=[], value=[/**/testInterceptor])

@Override
public RequestMappingInfo combine(RequestMappingInfo other) {
  String name = combineNames(other);
  PathPatternsRequestCondition pathPatterns =
      (this.pathPatternsCondition != null && other.pathPatternsCondition != null ?
          this.pathPatternsCondition.combine(other.pathPatternsCondition) : null);
  PatternsRequestCondition patterns =
      (this.patternsCondition != null && other.patternsCondition != null ?
          this.patternsCondition.combine(other.patternsCondition) : null);
  RequestMethodsRequestCondition methods = this.methodsCondition.combine(other.methodsCondition);
  ParamsRequestCondition params = this.paramsCondition.combine(other.paramsCondition);
  HeadersRequestCondition headers = this.headersCondition.combine(other.headersCondition);
  ConsumesRequestCondition consumes = this.consumesCondition.combine(other.consumesCondition);
  ProducesRequestCondition produces = this.producesCondition.combine(other.producesCondition);
  RequestConditionHolder custom = this.customConditionHolder.combine(other.customConditionHolder);
  return new RequestMappingInfo(
      name, pathPatterns, patterns, methods, params, headers, consumes, produces, custom);
}

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 = createHandlerMethod(handler, method);
    // 这里mapping就是RequestMappingInfo实例 
    validateMethodMapping(handlerMethod, mapping);
    // 获取请求URL  ，然后往pathLookup放入path与mapping
    Set<String> directPaths = AbstractHandlerMethodMapping.this.getDirectPaths(mapping);
    for (String path : directPaths) {
      this.pathLookup.add(path, mapping);
    }
    // 获取name，然后往nameLookup中放入name=List<HandlerMethod>
    String name = null;
    if (getNamingStrategy() != null) {
      name = getNamingStrategy().getName(handlerMethod, mapping);
      addMappingName(name, handlerMethod);
    }
    CorsConfiguration config = initCorsConfiguration(handler, method, mapping);
    if (config != null) {
      config.validateAllowCredentials();
      this.corsLookup.put(handlerMethod, config);
    }
    this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directPaths, name));
  }
  finally {
    this.readWriteLock.writeLock().unlock();
  }
}

@Nullable
protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
  List<Match> matches = new ArrayList<>();
  // 从 MappingRegistry.pathLookup中获取 RequestMappingInfo实例集合
  List<T> directPathMatches = this.mappingRegistry.getMappingsByDirectPath(lookupPath);
  if (directPathMatches != null) {
    addMatchingMappings(directPathMatches, matches, request);
  }
  if (matches.isEmpty()) {
    addMatchingMappings(this.mappingRegistry.getRegistrations().keySet(), matches, request);
  }
  if (!matches.isEmpty()) {
    Match bestMatch = matches.get(0);
    if (matches.size() > 1) {
      Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
      matches.sort(comparator);
      bestMatch = matches.get(0);
      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.getRegistrations().keySet(), lookupPath, request);
  }
}

// org.springframework.web.servlet.HandlerMapping.bestMatchingHandler
String BEST_MATCHING_HANDLER_ATTRIBUTE = HandlerMapping.class.getName() + ".bestMatchingHandler";
// org.springframework.web.servlet.HandlerMapping.pathWithinHandlerMapping
String PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE = HandlerMapping.class.getName() + ".pathWithinHandlerMapping";

protected RequestMappingInfo getMatchingMapping(RequestMappingInfo info, HttpServletRequest request) {
  return info.getMatchingCondition(request);
}
//RequestMappingInfo#getMatchingCondition
public RequestMappingInfo getMatchingCondition(HttpServletRequest request) {
RequestMethodsRequestCondition methods = this.methodsCondition.getMatchingCondition(request);
  if (methods == null) {
    return null;
  }
  ParamsRequestCondition params = this.paramsCondition.getMatchingCondition(request);
  if (params == null) {
    return null;
  }
  HeadersRequestCondition headers = this.headersCondition.getMatchingCondition(request);
  if (headers == null) {
    return null;
  }
  ConsumesRequestCondition consumes = this.consumesCondition.getMatchingCondition(request);
  if (consumes == null) {
    return null;
  }
  ProducesRequestCondition produces = this.producesCondition.getMatchingCondition(request);
  if (produces == null) {
    return null;
  }
  PathPatternsRequestCondition pathPatterns = null;
  if (this.pathPatternsCondition != null) {
    pathPatterns = this.pathPatternsCondition.getMatchingCondition(request);
    if (pathPatterns == null) {
      return null;
    }
  }
  PatternsRequestCondition patterns = null;
  if (this.patternsCondition != null) {
    patterns = this.patternsCondition.getMatchingCondition(request);
    if (patterns == null) {
      return null;
    }
  }
  RequestConditionHolder custom = this.customConditionHolder.getMatchingCondition(request);
  if (custom == null) {
    return null;
  }
  return new RequestMappingInfo(
      this.name, pathPatterns, patterns, methods, params, headers, consumes, produces, custom);
}

// 一个逻辑分离 (' || ') 请求条件，它根据一组 URL 路径模式匹配请求。这里使用已解析的PathPatterns
private static final PathPatternsRequestCondition EMPTY_PATH_PATTERNS = new PathPatternsRequestCondition();
// Patterns 也就是请求URL，PathPatternsRequestCondition 不同，这里使用String 字符串模式
private static final PatternsRequestCondition EMPTY_PATTERNS = new PatternsRequestCondition();
// 请求限制http method
private static final RequestMethodsRequestCondition EMPTY_REQUEST_METHODS = new RequestMethodsRequestCondition();
// @RequestMapping注解中的param
private static final ParamsRequestCondition EMPTY_PARAMS = new ParamsRequestCondition();
// @RequestMapping注解中的header
private static final HeadersRequestCondition EMPTY_HEADERS = new HeadersRequestCondition();
// @RequestMapping注解中的consume
private static final ConsumesRequestCondition EMPTY_CONSUMES = new ConsumesRequestCondition();
// @RequestMapping注解中的produce
private static final ProducesRequestCondition EMPTY_PRODUCES = new ProducesRequestCondition();
// 自定义条件
private static final RequestConditionHolder EMPTY_CUSTOM = new RequestConditionHolder(null);
@Nullable
private final String name;
@Nullable
private final PathPatternsRequestCondition pathPatternsCondition;
@Nullable
private final PatternsRequestCondition patternsCondition;
private final RequestMethodsRequestCondition methodsCondition;
private final ParamsRequestCondition paramsCondition;
private final HeadersRequestCondition headersCondition;
private final ConsumesRequestCondition consumesCondition;
private final ProducesRequestCondition producesCondition;
private final RequestConditionHolder customConditionHolder;
private final int hashCode;

private final Object bean;
@Nullable
private final BeanFactory beanFactory;
private final Class<?> beanType;
private final Method method;
private final Method bridgedMethod;
private final MethodParameter[] parameters;
@Nullable
private HttpStatus responseStatus;
@Nullable
private String responseStatusReason;
@Nullable
private HandlerMethod resolvedFromHandlerMethod;
@Nullable
private volatile List<Annotation[][]> interfaceParameterAnnotations;
private final String description;

void setApplicationContext(ApplicationContext applicationContext) throws BeansException;

@Override
public final void setApplicationContext(@Nullable ApplicationContext context) throws BeansException {
  if (context == null && !isContextRequired()) {
    // Reset internal context state.
    this.applicationContext = null;
    this.messageSourceAccessor = null;
  }
  else if (this.applicationContext == null) {
    // Initialize with passed-in context.
    if (!requiredContextClass().isInstance(context)) {
      throw new ApplicationContextException(
          "Invalid application context: needs to be of type [" + requiredContextClass().getName() + "]");
    }
    this.applicationContext = context;
    this.messageSourceAccessor = new MessageSourceAccessor(context);
    // 这里是核心
    initApplicationContext(context);
  }
  else {
    // Ignore reinitialization if same context passed in.
    if (this.applicationContext != context) {
      throw new ApplicationContextException(
          "Cannot reinitialize with different application context: current one is [" +
          this.applicationContext + "], passed-in one is [" + context + "]");
    }
  }
}