@Override
protected void initApplicationContext() throws BeansException {
	extendInterceptors(this.interceptors);
	detectMappedInterceptors(this.adaptedInterceptors);
	initInterceptors();
}

protected void detectMappedInterceptors(List<HandlerInterceptor> mappedInterceptors) {
	mappedInterceptors.addAll(
			BeanFactoryUtils.beansOfTypeIncludingAncestors(
					obtainApplicationContext(), MappedInterceptor.class, true, false).values());
}

protected void initInterceptors() {
	if (!this.interceptors.isEmpty()) {
		for (int i = 0; i < this.interceptors.size(); i++) {
			Object interceptor = this.interceptors.get(i);
			if (interceptor == null) {
				throw new IllegalArgumentException("Entry number " + i + " in interceptors array is null");
			}
			this.adaptedInterceptors.add(adaptInterceptor(interceptor));
		}
	}
}
protected HandlerInterceptor adaptInterceptor(Object interceptor) {
	if (interceptor instanceof HandlerInterceptor) {
		return (HandlerInterceptor) interceptor;
	}
	else if (interceptor instanceof WebRequestInterceptor) {
		return new WebRequestHandlerInterceptorAdapter((WebRequestInterceptor) interceptor);
	}
	else {
		throw new IllegalArgumentException("Interceptor type not supported: " + interceptor.getClass().getName());
	}
}

@Override
@Nullable
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
	//調(diào)用模板方法，獲取request對應的處理器Handler
	Object handler = getHandlerInternal(request);
	if (handler == null) {//如果handler為空，獲取默認的handler
		handler = getDefaultHandler();
	}
	if (handler == null) {
		return null;
	}
	// 如果handler是實例的名稱，需要從容器中獲取對應的Bean實例
	if (handler instanceof String) {
		String handlerName = (String) handler;
		handler = obtainApplicationContext().getBean(handlerName);
	}
	//根據(jù)Handler獲取對應的executionChain對象，該過程會把對應的攔截器添加到executionChain對象中
	HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
	if (logger.isTraceEnabled()) {
		logger.trace("Mapped to " + handler);
	}
	else if (logger.isDebugEnabled() && !request.getDispatcherType().equals(DispatcherType.ASYNC)) {
		logger.debug("Mapped to " + executionChain.getHandler());
	}
	//處理跨域問題
	if (hasCorsConfigurationSource(handler)) {
		//初始化時如果有跨域配置，則獲取config 對象
		CorsConfiguration config = (this.corsConfigurationSource != null ? this.corsConfigurationSource.getCorsConfiguration(request) : null);
		//如果當前handler中有跨域配置，獲取handlerConfig對象
		CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
		//合并配置
		config = (config != null ? config.combine(handlerConfig) : handlerConfig);
		//把跨域處理的攔截器，添加到HandlerExecutionChain對象中
		executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
	}
	return executionChain;
}

//根處理器，處理“/”的處理器
@Nullable
private Object rootHandler;
//是否匹配尾部的“/”，比如：如果設置為ture,則"/users"的匹配模式，也會匹配"/users/"
private boolean useTrailingSlashMatch = false;
//設置是否延遲加載，只對單例的處理器有效
private boolean lazyInitHandlers = false;
//保存request和Handler對應關系的變量
private final Map<String, Object> handlerMap = new LinkedHashMap<>();

@Override
@Nullable
protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
	//獲取lookupPath，并保存到request屬性中
	String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
	request.setAttribute(LOOKUP_PATH, lookupPath);
	//獲取lookupPath 對應的handler
	Object handler = lookupHandler(lookupPath, request);
	if (handler == null) {//如果沒有獲取到對應的handler，則進行下面處理
		// We need to care for the default handler directly, since we need to
		// expose the PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE for it as well.
		Object rawHandler = null;
		if ("/".equals(lookupPath)) {//如果時根路徑，則獲取根處理器，即屬性rootHandler中保存的處理器
			rawHandler = getRootHandler();
		}
		if (rawHandler == null) {//獲取默認處理器，在父類中定義，即父類中的defaultHandler屬性
			rawHandler = getDefaultHandler();
		}
		if (rawHandler != null) {
			// Bean name or resolved handler?
			if (rawHandler instanceof String) {//獲取對應的Bean實例
				String handlerName = (String) rawHandler;
				rawHandler = obtainApplicationContext().getBean(handlerName);
			}
			//模板方法，校驗處理器，交由子類實現(xiàn)或擴展
			validateHandler(rawHandler, request);
			//根據(jù)原始的handler構建實際的handler，主要實現(xiàn)構建HandlerExecutionChain對象，并在request添加對應的參數(shù)，后續(xù)在詳細分析
			handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
		}
	}
	return handler;
}

@Nullable
protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
	// urlPath正好對應Map的key，則直接獲取，并進行處理
	Object handler = this.handlerMap.get(urlPath);
	if (handler != null) {
		// Bean name or resolved handler?
		if (handler instanceof String) {
			String handlerName = (String) handler;
			handler = obtainApplicationContext().getBean(handlerName);
		}
		validateHandler(handler, request);
		return buildPathExposingHandler(handler, urlPath, urlPath, null);
	}
	// 模式匹配，獲取handlerMap中對應的所有可能匹配的模式
	List<String> matchingPatterns = new ArrayList<>();
	for (String registeredPattern : this.handlerMap.keySet()) {
		if (getPathMatcher().match(registeredPattern, urlPath)) {
			matchingPatterns.add(registeredPattern);
		}
		else if (useTrailingSlashMatch()) {
			if (!registeredPattern.endsWith("/") && getPathMatcher().match(registeredPattern + "/", urlPath)) {
				matchingPatterns.add(registeredPattern + "/");
			}
		}
	}
	String bestMatch = null;
	//定義最佳匹配的比較器，為了獲取最佳的處理器Handler
	Comparator<String> patternComparator = getPathMatcher().getPatternComparator(urlPath);
	if (!matchingPatterns.isEmpty()) {
		//根據(jù)比較器進行排序，最佳handler排在第一個
		matchingPatterns.sort(patternComparator);
		if (logger.isTraceEnabled() && matchingPatterns.size() > 1) {
			logger.trace("Matching patterns " + matchingPatterns);
		}
		//獲取最佳的handler
		bestMatch = matchingPatterns.get(0);
	}
	if (bestMatch != null) {//獲取最佳處理器對應的key，然后進一步處理Handler
		//獲取key對應的Handler
		handler = this.handlerMap.get(bestMatch);
		if (handler == null) {//如果沒有獲取到，則移除尾部的斜桿繼續(xù)嘗試
			if (bestMatch.endsWith("/")) {
				handler = this.handlerMap.get(bestMatch.substring(0, bestMatch.length() - 1));
			}
			if (handler == null) {//還是獲取不到，直接拋出異常
				throw new IllegalStateException(
						"Could not find handler for best pattern match [" + bestMatch + "]");
			}
		}
		// Bean name or resolved handler?
		if (handler instanceof String) {//如果時bean的名稱，則獲取對應的實例
			String handlerName = (String) handler;
			handler = obtainApplicationContext().getBean(handlerName);
		}
		validateHandler(handler, request);
		String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestMatch, urlPath);
		//最佳匹配可能存在多個，比如：/book/{id}和/book/{name}，那就再添加一個UriTemplateVariablesHandlerInterceptor攔截器，并在request設置一個key為 org.springframework.web.servlet.HandlerMapping.uriTemplateVariables的變量。
		Map<String, String> uriTemplateVariables = new LinkedHashMap<>();
		for (String matchingPattern : matchingPatterns) {
			if (patternComparator.compare(bestMatch, matchingPattern) == 0) {
				Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(matchingPattern, urlPath);
				Map<String, String> decodedVars = getUrlPathHelper().decodePathVariables(request, vars);
				uriTemplateVariables.putAll(decodedVars);
			}
		}
		if (logger.isTraceEnabled() && uriTemplateVariables.size() > 0) {
			logger.trace("URI variables " + uriTemplateVariables);
		}
		return buildPathExposingHandler(handler, bestMatch, pathWithinMapping, uriTemplateVariables);
	}
	// No handler found...
	return null;
}

protected Object buildPathExposingHandler(Object rawHandler, String bestMatchingPattern,
	String pathWithinMapping, @Nullable Map<String, String> uriTemplateVariables) {
	HandlerExecutionChain chain = new HandlerExecutionChain(rawHandler);
	chain.addInterceptor(new PathExposingHandlerInterceptor(bestMatchingPattern, pathWithinMapping));
	if (!CollectionUtils.isEmpty(uriTemplateVariables)) {
		chain.addInterceptor(new UriTemplateVariablesHandlerInterceptor(uriTemplateVariables));
	}
	return chain;
}

//第一個方法：該重載方法，循環(huán)調(diào)用第二種實現(xiàn)真正的處理器注冊
protected void registerHandler(String[] urlPaths, String beanName) throws BeansException, IllegalStateException {
	Assert.notNull(urlPaths, "URL path array must not be null");
	for (String urlPath : urlPaths) {
		registerHandler(urlPath, beanName);
	}
}
//第二個方法：真正實現(xiàn)處理器的注冊
protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {
	Assert.notNull(urlPath, "URL path must not be null");
	Assert.notNull(handler, "Handler object must not be null");
	Object resolvedHandler = handler;
	// 加載處理器（當處理器是非延時加載時進行）
	if (!this.lazyInitHandlers && handler instanceof String) {
		String handlerName = (String) handler;
		ApplicationContext applicationContext = obtainApplicationContext();
		if (applicationContext.isSingleton(handlerName)) {
			resolvedHandler = applicationContext.getBean(handlerName);
		}
	}
	Object mappedHandler = this.handlerMap.get(urlPath);
	if (mappedHandler != null) {//如果Map中存在處理器，且和當前的不一樣，就直接拋出異常。
		if (mappedHandler != resolvedHandler) {
			throw new IllegalStateException(
					"Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
					"]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
		}
	}
	else {//當前Map不存在處理器
		if (urlPath.equals("/")) {//設置根處理器
			if (logger.isTraceEnabled()) {
				logger.trace("Root mapping to " + getHandlerDescription(handler));
			}
			setRootHandler(resolvedHandler);
		}
		else if (urlPath.equals("/*")) {//設置默認處理器
			if (logger.isTraceEnabled()) {
				logger.trace("Default mapping to " + getHandlerDescription(handler));
			}
			setDefaultHandler(resolvedHandler);
		}
		else {//在Map中添加urlPath和處理器對應的關系
			this.handlerMap.put(urlPath, resolvedHandler);
			if (logger.isTraceEnabled()) {
				logger.trace("Mapped [" + urlPath + "] onto " + getHandlerDescription(handler));
			}
		}
	}
}

public class TestController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)   {
        ModelAndView mav = new ModelAndView("test");
        mav.addObject("context", “test”);
        return mav;
    }
}

@Configuration
public class ControllerBeanConfig {
    /**
     * 注意 :
     * 1. 該 bean 實現(xiàn)了接口 org.springframework.web.servlet.mvc.Controller,
     * 2. 該 bean 沒有使用注解 @Controller,
     * (如果使用了注解@Controller,就會被RequestMappingHandlerMapping接管，而不是由BeanNameUrlHandlerMapping處理)
     * 3. 映射到匹配 /test/* 的url
     * @return
     */
    @Bean(name = "/test/*")
    public TestController beanTestController() {
        return new TestController();
    }
}

@Override
public void initApplicationContext() throws ApplicationContextException {
	super.initApplicationContext();
	detectHandlers();
}

protected void detectHandlers() throws BeansException {
	ApplicationContext applicationContext = obtainApplicationContext();
	String[] beanNames = (this.detectHandlersInAncestorContexts ?
			BeanFactoryUtils.beanNamesForTypeIncludingAncestors(applicationContext, Object.class) :
			applicationContext.getBeanNamesForType(Object.class));
	// Take any bean name that we can determine URLs for.
	for (String beanName : beanNames) {
		String[] urls = determineUrlsForHandler(beanName);
		if (!ObjectUtils.isEmpty(urls)) {
			// URL paths found: Let's consider it a handler.
			registerHandler(urls, beanName);
		}
	}
	if ((logger.isDebugEnabled() && !getHandlerMap().isEmpty()) || logger.isTraceEnabled()) {
		logger.debug("Detected " + getHandlerMap().size() + " mappings in " + formatMappingName());
	}
}

public class BeanNameUrlHandlerMapping extends AbstractDetectingUrlHandlerMapping {
	@Override
	protected String[] determineUrlsForHandler(String beanName) {
		List<String> urls = new ArrayList<>();
		if (beanName.startsWith("/")) {
			urls.add(beanName);
		}
		String[] aliases = obtainApplicationContext().getAliases(beanName);
		for (String alias : aliases) {
			if (alias.startsWith("/")) {
				urls.add(alias);
			}
		}
		return StringUtils.toStringArray(urls);
	}
}