详解SpringMVC组件之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();
}