Spring MVC学習ノートのSpring MVCコンポーネントHandlerMapping(二)

//  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 {
     
		//    HandlerMethod  （        ）
		HandlerMethod handlerMethod = createHandlerMethod(handler, method);
		//  handlerMethod mapping     ，        HandlerMethod    handlerMethod   ，      “Ambiguous mapping. Cannot map”
		validateMethodMapping(handlerMethod, mapping);
		//  mappingLookup  ，  mapping handlerMethod     
		this.mappingLookup.put(mapping, handlerMethod);
		//      mapping，   URL(        URL)， URL      getMappingPathPatterns()     ，      PatternsRequestCondition   ，   directUrls           ？       。
		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          ），    ：         +“#”+   
			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)) {
     
			//     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()  ，     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();
}