Spring MVC--请求映射与参数解析

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
           // 对所有的Handler循环,直到找到能够处理的Handler
	for (HandlerMapping hm : this.handlerMappings) {
		if (logger.isTraceEnabled()) {
			logger.trace(
					"Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
		}
		HandlerExecutionChain handler = hm.getHandler(request);
		if (handler != null) {
			return handler;
		}
	}
	return null;
}

@Override
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
           // getHandlerInternal委托给子类实现查找handler的方法
	Object handler = getHandlerInternal(request);
	if (handler == null) {
		handler = getDefaultHandler();
	}
           // 子类找不到则返回null,没有对应的处理器
	if (handler == null) {
		return null;
	}
	// Bean name or resolved handler?
	if (handler instanceof String) {
		String handlerName = (String) handler;
		handler = getApplicationContext().getBean(handlerName);
	}
           // 构造handlerChain,主要是在hander中加入`HandlerInterceptor`拦截器.
	HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
	if (CorsUtils.isCorsRequest(request)) {
		CorsConfiguration globalConfig = this.corsConfigSource.getCorsConfiguration(request);
		CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
		CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
		executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
	}
	return executionChain;
}

protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
		List<Match> matches = new ArrayList<Match>(); // 存放找到的结果
        // 因为URL是确定的,因此直接从映射关系中取,可以拿到一部分.
		List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
		if (directPathMatches != null) {
			addMatchingMappings(directPathMatches, matches, request);
		}
        // 找不到的话则直接全量匹配查找(这里是重点)
		if (matches.isEmpty()) {
			// No choice but to go through all mappings...
			addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
		}
        // 找到的结果可能有多个,因此需要筛选.
		if (!matches.isEmpty()) {
                // 排序规则为org.springframework.web.servlet.mvc.method.RequestMappingInfo#compareTo方法,感兴趣可以研究下
			Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
			Collections.sort(matches, comparator);
			if (logger.isTraceEnabled()) {
				logger.trace("Found " + matches.size() + " matching mapping(s) for [" +
						lookupPath + "] : " + matches);
			}
            // 排序后第一个是最佳匹配
			Match bestMatch = matches.get(0);
			if (matches.size() > 1) {
				if (CorsUtils.isPreFlightRequest(request)) {
					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();
					throw new IllegalStateException("Ambiguous handler methods mapped for HTTP path '" +
							request.getRequestURL() + "': {" + m1 + ", " + m2 + "}");
				}
			}
			handleMatch(bestMatch.mapping, lookupPath, request);
			return bestMatch.handlerMethod;
		}
		else {
			return handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
		}
	}

// k:url  v:对应处理方法,可能多个
private final MultiValueMap<String, T> urlLookup = new LinkedMultiValueMap<String, T>();
public List<T> getMappingsByUrl(String urlPath) {
			return this.urlLookup.get(urlPath);
}

public interface HandlerMethodArgumentResolver {

    // 是否可解析判断
	boolean supportsParameter(MethodParameter parameter);
    // 具体解析方法
	Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception;
}

@Override
public final Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
		NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
           .....省略一些代码
           // 解析,委托给具体的实现类
	Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
           .....省略一些代码
           // 转换流程,委托给WebDataBinder
	if (binderFactory != null) {
		WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
		try {
			arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
		}
               ...
	}
	handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
	return arg;
}

@Override
	public boolean supportsParameter(MethodParameter parameter) {
            // 根据参数是否有该注解判断是否支持
		return (parameter.hasParameterAnnotation(RequestHeader.class) &&
				!Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType()));
	}

	@Override
	protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request) throws Exception {
            // 解析操作直接从header中取出对应的值
		String[] headerValues = request.getHeaderValues(name);
		if (headerValues != null) {
			return (headerValues.length == 1 ? headerValues[0] : headerValues);
		}
		else {
			return null;
		}
	}

WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
       try {
           arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
       }

final class IntegerToEnumConverterFactory implements ConverterFactory<Integer, Enum> {

	@Override
	public <T extends Enum> Converter<Integer, T> getConverter(Class<T> targetType) {
		return new IntegerToEnum(ConversionUtils.getEnumType(targetType));
	}

	private class IntegerToEnum<T extends Enum> implements Converter<Integer, T> {

		private final Class<T> enumType;

		public IntegerToEnum(Class<T> enumType) {
			this.enumType = enumType;
		}

		@Override
		public T convert(Integer source) {
                // 通过ordinal属性来定位到具体的枚举类.
			return this.enumType.getEnumConstants()[source];
		}
	}
}