//維護mapping與MappingRegistration注冊信息的關系
private final Map<T, MappingRegistration<T>> registry = new HashMap<>();
//維護mapping與HandlerMethod的關系
private final Map<T, HandlerMethod> mappingLookup = new LinkedHashMap<>();
//保存著URL與匹配條件（mapping）的對應關系,key是那些不含通配符的URL,value對應的是一個list類型的值。
private final MultiValueMap<String, T> urlLookup = new LinkedMultiValueMap<>();
//保存著name和HandlerMethod的對應關系（一個name可以有多個HandlerMethod）
private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();
//保存HandlerMethod與跨域配置的關系
private final Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();
//讀寫鎖
private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

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 {
		//創(chuàng)建一個HandlerMethod對象（構造函數創(chuàng)建對象）
		HandlerMethod handlerMethod = createHandlerMethod(handler, method);
		//驗證handlerMethod和mapping的對應關系，如果已經存在一個HandlerMethod對象且與handlerMethod不一樣，就會拋出異?！癆mbiguous mapping. Cannot map”
		validateMethodMapping(handlerMethod, mapping);
		//維護mappingLookup對象，建立mapping和handlerMethod的映射關系
		this.mappingLookup.put(mapping, handlerMethod);
		//獲取匹配條件mapping，對應的URL(那些不含通配符的URL)，且URL是由子類實現getMappingPathPatterns()方法提供的，實際上還是由PatternsRequestCondition提供的，那個該directUrls 是什么時候初始化的呢？我們后續(xù)在分析。
		List<String> directUrls = getDirectUrls(mapping);
		for (String url : directUrls) {
			this.urlLookup.add(url, mapping);
		}
		String name = null;
		//獲取mappingName，并維護與handlerMethod的關系
		if (getNamingStrategy() != null) {
			//namingStrategy屬性對應的是RequestMappingInfoHandlerMethodMappingNamingStrategy對象（是在子類RequestMappingInfoHandlerMapping構造函數中進行了設置），命名規(guī)則：類名中全部大小字符+“#”+方法名
			name = getNamingStrategy().getName(handlerMethod, mapping);
			addMappingName(name, handlerMethod);
		}
		//獲取跨域配置CorsConfiguration對象，維護與handlerMethod的關系。initCorsConfiguration()定了空方法，在RequestMappingHandlerMapping類中進行了重寫。
		CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
		if (corsConfig != null) {
			this.corsLookup.put(handlerMethod, corsConfig);
		}
		//維護mapping與MappingRegistration的關系
		this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
	}
	finally {
		this.readWriteLock.writeLock().unlock();
	}
}

@Override
public void afterPropertiesSet() {
	initHandlerMethods();
}
protected void initHandlerMethods() {
	//獲取候選的bean實例
	for (String beanName : getCandidateBeanNames()) {
		if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
			//遍歷后續(xù)的bean實例，并分別進行處理
			processCandidateBean(beanName);
		}
	}
	//只是打印了日志，沒有實際的處理邏輯
	handlerMethodsInitialized(getHandlerMethods());
}

protected String[] getCandidateBeanNames() {
	//detectHandlerMethodsInAncestorContexts 表示是否從祖先容器中查找bean實例
	return (this.detectHandlerMethodsInAncestorContexts ?
			BeanFactoryUtils.beanNamesForTypeIncludingAncestors(obtainApplicationContext(), Object.class) :
			obtainApplicationContext().getBeanNamesForType(Object.class));
}

protected void processCandidateBean(String beanName) {
	Class<?> beanType = null;
	try {
		//獲取對應的Class類型
		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);
		}
	}
	//判斷beanType是不是處理器類型，通過isHandler()方法判斷，該方法在RequestMappingHandlerMapping類中實現，根據是否有Controller或RequestMapping注解進行判斷
	if (beanType != null && isHandler(beanType)) {
		//獲取指定Bean實例中對應的處理方法，并通過mappingRegistry注冊到對應的Map關系映射中
		detectHandlerMethods(beanName);
	}
}

protected void detectHandlerMethods(Object handler) {
	//獲取處理器對應的Class
	Class<?> handlerType = (handler instanceof String ?
			obtainApplicationContext().getType((String) handler) : handler.getClass());
	if (handlerType != null) {
		//獲取用戶定義的本來的類型，大部分情況下就是類型本身，主要針對cglib做了額外的判斷，獲取cglib代理的父類；
		Class<?> userType = ClassUtils.getUserClass(handlerType);
		//查找給定類型userType中的指定方法，具體判斷條件由getMappingForMethod()方法來決定
		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));
		}
		//把篩選出來的方法，通過registerHandlerMethod()注冊到映射關系中
		methods.forEach((method, mapping) -> {
			Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
			registerHandlerMethod(handler, invocableMethod, mapping);
		});
	}
}

@Override
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
	//獲取lookupPath
	String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
	//設置“org.springframework.web.servlet。HandlerMapping.lookupPath”參數
	request.setAttribute(LOOKUP_PATH, lookupPath);
	//獲取讀鎖
	this.mappingRegistry.acquireReadLock();
	try {
		//獲取request對應的處理器
		HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
		//如果處理器對應的是bean name，則調用createWithResolvedBean()方法，創(chuàng)建對應的Bean實例
		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<>();
	//從MappingRegistry.urlLookup屬性中，獲取lookupPath對應的mapping集合
	List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
	if (directPathMatches != null) {
		//獲取匹配的mapping，添加到matches變種
		addMatchingMappings(directPathMatches, matches, request);
	}
	if (matches.isEmpty()) {
		// 如果沒有匹配lookupPath的實例，則遍歷所有的mapping，查找符合條件的mapping
		addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
	}
	if (!matches.isEmpty()) {//說明存在符合條件的mapping，可能是多個
		//獲取匹配條件的排序器，由抽象方法getMappingComparator()方法獲取，該方法由子類實現
		Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
		//排序
		matches.sort(comparator);
		Match bestMatch = matches.get(0);
		if (matches.size() > 1) {//不止一個匹配時
			if (logger.isTraceEnabled()) {
				logger.trace(matches.size() + " matching mappings: " + matches);
			}
			if (CorsUtils.isPreFlightRequest(request)) {//OPTIONS請求時，直接處理
				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 + "}");
			}
		}
		//定義“.bestMatchingHandler”屬性
		request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.handlerMethod);
		//處理匹配的處理器，這里只是添加了一個".pathWithinHandlerMapping"屬性，具體實現在子類中進行。
		handleMatch(bestMatch.mapping, lookupPath, request);
		return bestMatch.handlerMethod;
	}
	else {//不存在匹配的bean時，調用handleNoMatch()方法，空方法，有子類進行實現。
		return handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
	}
}

//獲取RequestMappingInfo 對應的URL集合
@Override
protected Set<String> getMappingPathPatterns(RequestMappingInfo info) {
	return info.getPatternsCondition().getPatterns();
}
//判斷當前的RequestMappingInfo與request是否匹配，實際上是由RequestMappingInfo的getMatchingCondition()方法實現判斷，并返回一個新建的RequestMappingInfo 實例
@Override
protected RequestMappingInfo getMatchingMapping(RequestMappingInfo info, HttpServletRequest request) {
	return info.getMatchingCondition(request);
}
//獲取比較器
@Override
protected Comparator<RequestMappingInfo> getMappingComparator(final HttpServletRequest request) {
	return (info1, info2) -> info1.compareTo(info2, request);
}

//是否啟用后綴匹配
private boolean useSuffixPatternMatch = true;
//后綴模式匹配是否應該只對顯式地在ContentNegotiationManager中注冊的路徑擴展有效。
private boolean useRegisteredSuffixPatternMatch = false;
//尾部斜杠匹配
private boolean useTrailingSlashMatch = true;
//根據條件設置前綴path
private Map<String, Predicate<Class<?>>> pathPrefixes = new LinkedHashMap<>();
//多媒體類型判斷
private ContentNegotiationManager contentNegotiationManager = new ContentNegotiationManager();
//字符串解析器，處理spring表達式
@Nullable
private StringValueResolver embeddedValueResolver;
//RequestMappingInfo構建配置
private RequestMappingInfo.BuilderConfiguration config = new RequestMappingInfo.BuilderConfiguration();

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

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

@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).build().combine(info);
		}
	}
	return info;
}
@Nullable
private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
	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);
}
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();
}