/**
 * 解析的開始位置。
 * 由于實現(xiàn)了InitializingBean，初始化Bean的時候調(diào)用這個方法。
 * 源碼位置：org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping.afterPropertiesSet()
 */
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());
	}
	
	// 調(diào)用父類的afterPropertiesSet方法
	super.afterPropertiesSet();
}

/**
 * 父類的afterPropertiesSet方法。
 * 源碼位置：org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.afterPropertiesSet()
 */
public void afterPropertiesSet() {
	initHandlerMethods();
}

/**
 * 解析@RequestMapping方法
 * 源碼位置：org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.initHandlerMethods()
 */
protected void initHandlerMethods() {
	// 獲得所有候選beanName—— 當前容器所有的beanName
	for (String beanName : getCandidateBeanNames()) {
		// BeanName不是scopedTarget.開頭的
		if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
			// *處理候選bean——即解析@RequestMapping和映射路徑
			processCandidateBean(beanName);
		}
	}
	// 解析完所有@RequestMapping的時候調(diào)用
	handlerMethodsInitialized(getHandlerMethods());
}

/**
 * 處理候選bean——即解析@RequestMapping和映射路徑
 * 源碼位置：org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.processCandidateBean(String)
 */
protected void processCandidateBean(String beanName) {
	Class<?> beanType = null;
	try {
		// 得到當前BeanName得到這個Bean的類型
		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);
		}
	}
	// 這一步判斷是關鍵：是否有Controller 或 RequestMapping注解
	if (beanType != null && isHandler(beanType)) {
		// 解析HandlerMethods
		detectHandlerMethods(beanName);
	}
}

/**
 * 解析HandlerMethods
 * 源碼位置：org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.detectHandlerMethods(Object)
 */
protected void detectHandlerMethods(Object handler) {
	Class<?> handlerType = (handler instanceof String ?
			obtainApplicationContext().getType((String) handler) : handler.getClass());

	if (handlerType != null) {
		Class<?> userType = ClassUtils.getUserClass(handlerType);
		// 循環(huán)所有方法
		Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
				(MethodIntrospector.MetadataLookup<T>) method -> {
					try {
						// 根據(jù)Method得到Mapping映射
						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));
		}
		// 遍歷每一個方法，這里是所有Bean的所有方法
		methods.forEach((method, mapping) -> {
			Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
			// pathLookup放入：key為路徑，值為mapping（RequestMappingInfo）
			registerHandlerMethod(handler, invocableMethod, mapping);
		});
	}
}

/**
 * 根據(jù)Method得到Mapping映射
 * 源碼位置：org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping.getMappingForMethod(Method, Class<?>)
 */
protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
	// 如果方法上面有@RequestMapping：解析出RequestMappingInfo
	// RequestMappingInfo 是用來在請求的時候做匹對的
	RequestMappingInfo info = createRequestMappingInfo(method);
	if (info != null) {
		// 如果方法上面有@RequestMapping，看看類上面是不是有@RequestMapping
		RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
		// 類上面也有@RequestMapping  那就合并
		// 比如 類：/user  方法：/info 合并為 /user/info
		if (typeInfo != null) {
			info = typeInfo.combine(info);
		}

		// 合并前綴   5.1新增  默認null
		// 可通過 WebMvcConfigurer#configurePathMatch 進行定制
		String prefix = getPathPrefix(handlerType);
		if (prefix != null) {
			info = RequestMappingInfo.paths(prefix).options(this.config).build().combine(info);
		}
	}
	return info;
}

/**
 * 創(chuàng)建請求映射信息的外部邏輯
 * 源碼位置：org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping.createRequestMappingInfo(AnnotatedElement)
 */
private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
	// 獲取RequestMapping注解信息
	RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(element, RequestMapping.class);
	// 獲取請求調(diào)解：[可擴展]， 如果有：該條件會在請求時匹對
	RequestCondition<?> condition = (element instanceof Class ?
			getCustomTypeCondition((Class<?>) element) : getCustomMethodCondition((Method) element));
	// 如果有RequestMapping注解，封裝成RequestMappingInfo
	return (requestMapping != null ? createRequestMappingInfo(requestMapping, condition) : null);
}

/**
 * 創(chuàng)建請求映射信息的內(nèi)部邏輯
 * 源碼位置：org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping.createRequestMappingInfo(RequestMapping, RequestCondition<?>)
 */
protected RequestMappingInfo createRequestMappingInfo(
		RequestMapping requestMapping, @Nullable RequestCondition<?> customCondition) {
	// 將@RequestMapping注解屬性的值構(gòu)建成一個 RequestMappingInfo
	RequestMappingInfo.Builder builder = RequestMappingInfo
			//構(gòu)建路徑
			.paths(resolveEmbeddedValuesInPatterns(requestMapping.path()))
			//構(gòu)建方法(get還是post等)
			.methods(requestMapping.method())
			//參數(shù) 對應http request parameter
			.params(requestMapping.params())
			//頭部
			.headers(requestMapping.headers())
			//request的提交內(nèi)容類型content type,如application/json, text/html
			.consumes(requestMapping.consumes())
			//指定返回的內(nèi)容類型的content type，僅當request請求頭中的(Accept)類型中包含該指定類型才返回
			.produces(requestMapping.produces())
			.mappingName(requestMapping.name());
	if (customCondition != null) {
		builder.customCondition(customCondition);
	}
	// 構(gòu)造RequestMappingInfo：將上面的屬性構(gòu)建成一個個的RequestCondition對象方便在請求的時候組合匹對
	return builder.options(this.config).build();
}

/**
 * 得到所有的方法
 * 源碼位置：org.springframework.core.MethodIntrospector.selectMethods(Class<?>, MetadataLookup<T>)
 */
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;
	//獲取原始的class對象
	if (!Proxy.isProxyClass(targetType)) {
		specificHandlerType = ClassUtils.getUserClass(targetType);
		handlerTypes.add(specificHandlerType);
	}
	//獲取class的接口
	handlerTypes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetType));
	//循環(huán)我們的class集合
	for (Class<?> currentHandlerType : handlerTypes) {
		final Class<?> targetClass = (specificHandlerType != null ? specificHandlerType : currentHandlerType);

		ReflectionUtils.doWithMethods(currentHandlerType, method -> {
			//獲取具體的方法對象
			Method specificMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
			 /**回調(diào) 即解析@RequestMapping 返回RequestMappingInfo
			  * @see org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping#getMappingForMethod(java.lang.reflect.Method, java.lang.Class)*/
			T result = metadataLookup.inspect(specificMethod);
			if (result != null) {
				// 看看有沒有橋接方法：泛型實現(xiàn)類jvm會自動生成橋接類
				Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
				if (bridgedMethod == specificMethod || metadataLookup.inspect(bridgedMethod) == null) {
					//把方法對象作為key,RequestMappingInfo對象作為value保存到map中
					methodMap.put(specificMethod, result);
				}
			}
		}, ReflectionUtils.USER_DECLARED_METHODS);
	}

	return methodMap;
}

/**
 * 獲取@RequestMapping映射
 * 源碼位置：org.springframework.web.servlet.handler.AbstractHandlerMapping.getHandler(HttpServletRequest)
 */
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
	// 獲取當前請求對應的HandlerMethod
	Object handler = getHandlerInternal(request);
	
	// 獲取默認的handler
	if (handler == null) {
		handler = getDefaultHandler();
	}
	
	// 還是沒有handler的時候返回null，404了
	if (handler == null) {
		return null;
	}
	// Bean name or resolved handler?
	// String類型？獲取Bean
	if (handler instanceof String) {
		String handlerName = (String) handler;
		handler = obtainApplicationContext().getBean(handlerName);
	}

	// Ensure presence of cached lookupPath for interceptors and others
	if (!ServletRequestPathUtils.hasCachedPath(request)) {
		initLookupPath(request);
	}

	// 獲取攔截器相關的調(diào)用鏈
	HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);

	if (logger.isTraceEnabled()) {
		logger.trace("Mapped to " + handler);
	}
	else if (logger.isDebugEnabled() && !DispatcherType.ASYNC.equals(request.getDispatcherType())) {
		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;
}

/**
 * 獲取當前請求對應的HandlerMethod
 * 源碼位置：org.springframework.web.servlet.mvc.method.RequestMappingInfoHandlerMapping.getHandlerInternal(HttpServletRequest)
 */
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
	request.removeAttribute(PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
	try {
		// 直接調(diào)用父類的getHandlerInternal方法
		return super.getHandlerInternal(request);
	}
	finally {
		ProducesRequestCondition.clearMediaTypesAttribute(request);
	}
}
/**
 * 獲取當前請求對應的HandlerMethod---父類的
 * 源碼位置：org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.getHandlerInternal(HttpServletRequest)
 */
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
	// 通過UrlPathHelper對象，用于來解析從們的request中解析出請求映射路徑
	String lookupPath = initLookupPath(request);
	this.mappingRegistry.acquireReadLock();
	try {
		// 通過lookupPath解析最終的handler——HandlerMethod對象
		HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
		return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
	}
	finally {
		this.mappingRegistry.releaseReadLock();
	}
}

/**
 * 通過lookupPath解析最終的handler
 * 源碼位置：org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.lookupHandlerMethod(String, HttpServletRequest)
 */
protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
	List<Match> matches = new ArrayList<>();
	// 根據(jù)uri從mappingRegistry.pathLookup獲取 RequestMappingInfo
	// pathLookup<path,RequestMappingInfo>會在初始化階段解析好
	List<T> directPathMatches = this.mappingRegistry.getMappingsByDirectPath(lookupPath);
	if (directPathMatches != null) {
		// 如果根據(jù)path能直接匹配的RequestMappingInfo 則用該mapping進行匹配其他條件(method、header等）
		addMatchingMappings(directPathMatches, matches, request);
	}
	if (matches.isEmpty()) {
		// 如果無path匹配，用所有的RequestMappingInfo  通過AntPathMatcher匹配
		addMatchingMappings(this.mappingRegistry.getRegistrations().keySet(), matches, request);
	}
	if (!matches.isEmpty()) {
		// 選擇第一個為最匹配的
		Match bestMatch = matches.get(0);
		/**
		 * 如果匹配到多個
		 @RequestMapping(value="/mappin?")
		 @RequestMapping(value="/mappin*")
		 @RequestMapping(value="/{xxxx}")
		 @RequestMapping(value="/**")
		 */
		if (matches.size() > 1) {
			//創(chuàng)建MatchComparator的匹配器對象
			Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));

			/** 根據(jù)精準度排序  大概是這樣的： ? > * > {} >**   具體可以去看：
			 * @see org.springframework.util.AntPathMatcher.AntPatternComparator#compare(java.lang.String, java.lang.String)*/
			matches.sort(comparator);

			// 排完序后拿到優(yōu)先級最高的
			bestMatch = matches.get(0);
			if (logger.isTraceEnabled()) {
				logger.trace(matches.size() + " matching mappings: " + matches);
			}
			// 是否配置CORS并且匹配
			if (CorsUtils.isPreFlightRequest(request)) {
				for (Match match : matches) {
					if (match.hasCorsConfig()) {
						return PREFLIGHT_AMBIGUOUS_MATCH;
					}
				}
			}
			else {
				//獲取第二最匹配的
				Match secondBestMatch = matches.get(1);
				//若第一個和第二個是一樣的 拋出異常
				if (comparator.compare(bestMatch, secondBestMatch) == 0) {
					Method m1 = bestMatch.getHandlerMethod().getMethod();
					Method m2 = secondBestMatch.getHandlerMethod().getMethod();
					String uri = request.getRequestURI();
					throw new IllegalStateException(
							"Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
				}
			}
		}
		//把最匹配的設置到request中
		request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.getHandlerMethod());
		handleMatch(bestMatch.mapping, lookupPath, request);
		//返回最匹配的
		return bestMatch.getHandlerMethod();
	}
	else { // return null
		return handleNoMatch(this.mappingRegistry.getRegistrations().keySet(), lookupPath, request);
	}
}