Detailed explanation of SpringMVC component HandlerMapping (II)

//Maintain the relationship between mapping and MappingRegistration registration informationprivate final Map<T, MappingRegistration<T>> registry = new HashMap<>();
//Maintain the relationship between mapping and HandlerMethodprivate final Map<T, HandlerMethod> mappingLookup = new LinkedHashMap<>();
//Save the correspondence between the URL and the matching condition (mapping). Key is those URLs that do not contain wildcards. The value corresponds to a list value.private final MultiValueMap<String, T> urlLookup = new LinkedMultiValueMap<>();
//Save the correspondence between name and HandlerMethod (one name can have multiple HandlerMethods)private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();
//Save the relationship between HandlerMethod and cross-domain configurationprivate final Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();
//Read and write lockprivate 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 ((()) && (method)) {
		throw new IllegalStateException("Unsupported suspending handler method detected: " + method);
	}
	//Add write lock	().lock();
	try {
		//Create a HandlerMethod object (constructor creates an object)		HandlerMethod handlerMethod = createHandlerMethod(handler, method);
		//Verify the correspondence between handlerMethod and mapping. If a HandlerMethod object already exists and is different from handlerMethod, an exception "Ambiguous mapping. Cannot map" will be thrown		validateMethodMapping(handlerMethod, mapping);
		//Maintain mappingLookup object and establish mapping relationship between mapping and handlerMethod		(mapping, handlerMethod);
		//Get the matching condition mapping, corresponding URL (those URLs that do not contain wildcards), and the URL is provided by the subclass implementation getMappingPathPatterns() method, but is actually provided by the PatternsRequestCondition. When is the directUrls initialized?  We are analyzing in the future.		List<String> directUrls = getDirectUrls(mapping);
		for (String url : directUrls) {
			(url, mapping);
		}
		String name = null;
		//Get mappingName and maintain the relationship with handlerMethod		if (getNamingStrategy() != null) {
			//The namingStrategy property corresponds to the RequestMappingInfoHandlerMethodMappingNamingStrategy object (set in the subclass RequestMappingInfoHandlerMapping constructor), naming rules: all size characters in the class name + "#" + method name name = getNamingStrategy().getName(handlerMethod, mapping);			addMappingName(name, handlerMethod);
		}
		//Get cross-domain configuration CorsConfiguration object to maintain the relationship with handlerMethod.  initCorsConfiguration() sets the empty method and is rewritten in the RequestMappingHandlerMapping class.		CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
		if (corsConfig != null) {
			(handlerMethod, corsConfig);
		}
		//Maintain the relationship between mapping and MappingRegistration		(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
	}
	finally {
		().unlock();
	}
}

@Override
public void afterPropertiesSet() {
	initHandlerMethods();
}
protected void initHandlerMethods() {
	//Get candidate bean instance	for (String beanName : getCandidateBeanNames()) {
		if (!(SCOPED_TARGET_NAME_PREFIX)) {
			//Transfer subsequent bean instances and process them separately			processCandidateBean(beanName);
		}
	}
	//Just just printed the log, there is no actual processing logic	handlerMethodsInitialized(getHandlerMethods());
}

protected String[] getCandidateBeanNames() {
	//detectHandlerMethodsInAncestorContexts Indicates whether to look for bean instances from the ancestor container	return ( ?
			(obtainApplicationContext(), ) :
			obtainApplicationContext().getBeanNamesForType());
}

protected void processCandidateBean(String beanName) {
	Class<?> beanType = null;
	try {
		//Get the corresponding Class type		beanType = obtainApplicationContext().getType(beanName);
	}
	catch (Throwable ex) {
		// An unresolvable bean type, probably from a lazy bean - let's ignore it.
		if (()) {
			("Could not resolve type for bean '" + beanName + "'", ex);
		}
	}
	//Judge whether beanType is the processor type, and judge through the isHandler() method. This method is implemented in the RequestMappingHandlerMapping class and judges based on whether there are Controller or RequestMapping annotations.	if (beanType != null && isHandler(beanType)) {
		//Get the corresponding processing method in the specified bean instance and register it into the corresponding Map relation map through mappingRegistry		detectHandlerMethods(beanName);
	}
}

protected void detectHandlerMethods(Object handler) {
	//Get the corresponding Class of the processor	Class<?> handlerType = (handler instanceof String ?
			obtainApplicationContext().getType((String) handler) : ());
	if (handlerType != null) {
		//Get the original type defined by the user. In most cases, it is the type itself. It mainly makes additional judgments on cglib and obtains the parent class of the cglib proxy;		Class<?> userType = (handlerType);
		//Find the specified method in the given type userType. The specific judgment conditions are determined by the getMappingForMethod() method.		Map<Method, T> methods = (userType,
				(<T>) method -> {
					try {
						return getMappingForMethod(method, userType);
					}
					catch (Throwable ex) {
						throw new IllegalStateException("Invalid mapping on handler class [" +
								() + "]: " + method, ex);
					}
				});
		if (()) {
			(formatMappings(userType, methods));
		}
		//Register the filtered method into the mapping relationship through registerHandlerMethod()		((method, mapping) -> {
			Method invocableMethod = (method, userType);
			registerHandlerMethod(handler, invocableMethod, mapping);
		});
	}
}

@Override
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
	//Get lookupPath	String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
	//Set "." Parameter	(LOOKUP_PATH, lookupPath);
	//Acquiring the read lock	();
	try {
		//Get the processor corresponding to the request		HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
		//If the processor corresponds to bean name, call createWithResolvedBean() method to create the corresponding bean instance		return (handlerMethod != null ? () : null);
	}
	finally {
		();
	}
}

@Nullable
protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
	List<Match> matches = new ArrayList<>();
	//From the attribute, get the mapping collection corresponding to lookupPath	List<T> directPathMatches = (lookupPath);
	if (directPathMatches != null) {
		//Get the matching mapping and add to the matches variant		addMatchingMappings(directPathMatches, matches, request);
	}
	if (()) {
		// If there is no instance matching lookupPath, iterate through all mappings and find matching mappings		addMatchingMappings(().keySet(), matches, request);
	}
	if (!()) {//Indicate that there are mappings that meet the conditions, there may be multiple mappings		//Get the sorter for matching conditions, get it from the abstract method getMappingComparator() method, which is implemented by the subclass		Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
		//Sort		(comparator);
		Match bestMatch = (0);
		if (() > 1) {// More than one match			if (()) {
				(() + " matching mappings: " + matches);
			}
			if ((request)) {// When OPTIONS requests, directly handle				return PREFLIGHT_AMBIGUOUS_MATCH;
			}
			Match secondBestMatch = (1);
			//If there are multiple processors, the exception will be directly thrown			if ((bestMatch, secondBestMatch) == 0) {
				Method m1 = ();
				Method m2 = ();
				String uri = ();
				throw new IllegalStateException(
						"Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
			}
		}
		//Define the ".bestMatchingHandler" property		(BEST_MATCHING_HANDLER_ATTRIBUTE, );
		//Train the matching processor, here is just adding a ".pathWithinHandlerMapping" property, and the specific implementation is carried out in the subclass.		handleMatch(, lookupPath, request);
		return ;
	}
	else {//When there is no matching bean, call handleNoMatch() method, empty method, and have subclasses to implement it.		return handleNoMatch(().keySet(), lookupPath, request);
	}
}

//Get the URL collection corresponding to RequestMappingInfo@Override
protected Set<String> getMappingPathPatterns(RequestMappingInfo info) {
	return ().getPatterns();
}
//Judge whether the current RequestMappingInfo matches the request. In fact, it is determined by the getMatchingCondition() method of RequestMappingInfo and returns a newly created RequestMappingInfo instance.@Override
protected RequestMappingInfo getMatchingMapping(RequestMappingInfo info, HttpServletRequest request) {
	return (request);
}
//Get the comparator@Override
protected Comparator<RequestMappingInfo> getMappingComparator(final HttpServletRequest request) {
	return (info1, info2) -> (info2, request);
}

// Whether to enable suffix matchingprivate boolean useSuffixPatternMatch = true;
//Whether the suffix pattern matching should only be valid for path extensions explicitly registered in ContentNegotiationManager.private boolean useRegisteredSuffixPatternMatch = false;
//The tail slash matchesprivate boolean useTrailingSlashMatch = true;
//Set the prefix path according to the conditionsprivate Map<String, Predicate<Class<?>>> pathPrefixes = new LinkedHashMap<>();
//Multimedia type judgmentprivate ContentNegotiationManager contentNegotiationManager = new ContentNegotiationManager();
//String parser, processing spring expression@Nullable
private StringValueResolver embeddedValueResolver;
//RequestMappingInfo build configurationprivate  config = new ();

@Override
public void afterPropertiesSet() {
	 = new ();
	(getUrlPathHelper());
	(getPathMatcher());
	();
	();
	();
	(getContentNegotiationManager());
	();
}

@Override
protected boolean isHandler(Class<?> beanType) {
	return ((beanType, ) ||
			(beanType, ));
}

@Override
@Nullable
protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
	RequestMappingInfo info = createRequestMappingInfo(method);
	if (info != null) {
		RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
		if (typeInfo != null) {
			info = (info);
		}
		String prefix = getPathPrefix(handlerType);
		if (prefix != null) {
			info = (prefix).build().combine(info);
		}
	}
	return info;
}
@Nullable
private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
	RequestMapping requestMapping = (element, );
	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) {
	 builder = RequestMappingInfo
			.paths(resolveEmbeddedValuesInPatterns(()))
			.methods(())
			.params(())
			.headers(())
			.consumes(())
			.produces(())
			.mappingName(());
	if (customCondition != null) {
		(customCondition);
	}
	return ().build();
}