@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對(duì)應(yīng)的處理器Handler
	Object handler = getHandlerInternal(request);
	if (handler == null) {//如果handler為空，獲取默認(rèn)的handler
		handler = getDefaultHandler();
	}
	if (handler == null) {
		return null;
	}
	// 如果handler是實(shí)例的名稱，需要從容器中獲取對(duì)應(yīng)的Bean實(shí)例
	if (handler instanceof String) {
		String handlerName = (String) handler;
		handler = obtainApplicationContext().getBean(handlerName);
	}
	//根據(jù)Handler獲取對(duì)應(yīng)的executionChain對(duì)象，該過程會(huì)把對(duì)應(yīng)的攔截器添加到executionChain對(duì)象中
	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)) {
		//初始化時(shí)如果有跨域配置，則獲取config 對(duì)象
		CorsConfiguration config = (this.corsConfigurationSource != null ? this.corsConfigurationSource.getCorsConfiguration(request) : null);
		//如果當(dāng)前handler中有跨域配置，獲取handlerConfig對(duì)象
		CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
		//合并配置
		config = (config != null ? config.combine(handlerConfig) : handlerConfig);
		//把跨域處理的攔截器，添加到HandlerExecutionChain對(duì)象中
		executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
	}
	return executionChain;
}

//根處理器，處理“/”的處理器
@Nullable
private Object rootHandler;
//是否匹配尾部的“/”，比如：如果設(shè)置為ture,則"/users"的匹配模式，也會(huì)匹配"/users/"
private boolean useTrailingSlashMatch = false;
//設(shè)置是否延遲加載，只對(duì)單例的處理器有效
private boolean lazyInitHandlers = false;
//保存request和Handler對(duì)應(yīng)關(guān)系的變量
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 對(duì)應(yīng)的handler
	Object handler = lookupHandler(lookupPath, request);
	if (handler == null) {//如果沒有獲取到對(duì)應(yīng)的handler，則進(jìn)行下面處理
		// 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)) {//如果時(shí)根路徑，則獲取根處理器，即屬性rootHandler中保存的處理器
			rawHandler = getRootHandler();
		}
		if (rawHandler == null) {//獲取默認(rèn)處理器，在父類中定義，即父類中的defaultHandler屬性
			rawHandler = getDefaultHandler();
		}
		if (rawHandler != null) {
			// Bean name or resolved handler?
			if (rawHandler instanceof String) {//獲取對(duì)應(yīng)的Bean實(shí)例
				String handlerName = (String) rawHandler;
				rawHandler = obtainApplicationContext().getBean(handlerName);
			}
			//模板方法，校驗(yàn)處理器，交由子類實(shí)現(xiàn)或擴(kuò)展
			validateHandler(rawHandler, request);
			//根據(jù)原始的handler構(gòu)建實(shí)際的handler，主要實(shí)現(xiàn)構(gòu)建HandlerExecutionChain對(duì)象，并在request添加對(duì)應(yīng)的參數(shù)，后續(xù)在詳細(xì)分析
			handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
		}
	}
	return handler;
}

@Nullable
protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
	// urlPath正好對(duì)應(yīng)Map的key，則直接獲取，并進(jìn)行處理
	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中對(duì)應(yīng)的所有可能匹配的模式
	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ù)比較器進(jìn)行排序，最佳handler排在第一個(gè)
		matchingPatterns.sort(patternComparator);
		if (logger.isTraceEnabled() && matchingPatterns.size() > 1) {
			logger.trace("Matching patterns " + matchingPatterns);
		}
		//獲取最佳的handler
		bestMatch = matchingPatterns.get(0);
	}
	if (bestMatch != null) {//獲取最佳處理器對(duì)應(yīng)的key，然后進(jìn)一步處理Handler
		//獲取key對(duì)應(yīng)的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) {//如果時(shí)bean的名稱，則獲取對(duì)應(yīng)的實(shí)例
			String handlerName = (String) handler;
			handler = obtainApplicationContext().getBean(handlerName);
		}
		validateHandler(handler, request);
		String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestMatch, urlPath);
		//最佳匹配可能存在多個(gè)，比如：/book/{id}和/book/{name}，那就再添加一個(gè)UriTemplateVariablesHandlerInterceptor攔截器，并在request設(shè)置一個(gè)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;
}

//第一個(gè)方法：該重載方法，循環(huán)調(diào)用第二種實(shí)現(xiàn)真正的處理器注冊(cè)
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);
	}
}
//第二個(gè)方法：真正實(shí)現(xiàn)處理器的注冊(cè)
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;
	// 加載處理器（當(dāng)處理器是非延時(shí)加載時(shí)進(jìn)行）
	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中存在處理器，且和當(dāng)前的不一樣，就直接拋出異常。
		if (mappedHandler != resolvedHandler) {
			throw new IllegalStateException(
					"Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
					"]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
		}
	}
	else {//當(dāng)前Map不存在處理器
		if (urlPath.equals("/")) {//設(shè)置根處理器
			if (logger.isTraceEnabled()) {
				logger.trace("Root mapping to " + getHandlerDescription(handler));
			}
			setRootHandler(resolvedHandler);
		}
		else if (urlPath.equals("/*")) {//設(shè)置默認(rèn)處理器
			if (logger.isTraceEnabled()) {
				logger.trace("Default mapping to " + getHandlerDescription(handler));
			}
			setDefaultHandler(resolvedHandler);
		}
		else {//在Map中添加urlPath和處理器對(duì)應(yīng)的關(guān)系
			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 實(shí)現(xiàn)了接口 org.springframework.web.servlet.mvc.Controller,
     * 2. 該 bean 沒有使用注解 @Controller,
     * (如果使用了注解@Controller,就會(huì)被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);
	}
}