public interface HandlerMapping {
   // 返回請求的一個處理程序handler和攔截器interceptors
   @Nullable
   HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;
}

private void initHandlerMappings(ApplicationContext context) {
    this.handlerMappings = null;
    //默認為true，可通過DispatcherServlet的init-param參數(shù)進行設置
    if (this.detectAllHandlerMappings) {
        //在ApplicationContext中找到所有的handlerMapping, 包括父級上下文
        Map<String, HandlerMapping> matchingBeans =
                BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
        if (!matchingBeans.isEmpty()) {
            this.handlerMappings = new ArrayList<>(matchingBeans.values());
            //排序，可通過指定order屬性進行設置，order的值為int型，數(shù)越小優(yōu)先級越高
            AnnotationAwareOrderComparator.sort(this.handlerMappings);
        }
    } else {
        try {
            //從ApplicationContext中取id（或name）="handlerMapping"的bean,此時為空
            HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
            // 將hm轉(zhuǎn)換成list，并賦值給屬性handlerMappings
            this.handlerMappings = Collections.singletonList(hm);
        } catch (NoSuchBeanDefinitionException ex) {
        }
    }
    //如果沒有自定義則使用默認的handlerMappings
    //默認的HandlerMapping在DispatcherServlet.properties屬性文件中定義，
    // 該文件是在DispatcherServlet的static靜態(tài)代碼塊中加載的
    // 默認的是：BeanNameUrlHandlerMapping和RequestMappingHandlerMapping
    if (this.handlerMappings == null) {
        this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);//默認策略
        if (logger.isTraceEnabled()) {
            logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
                    "': using default strategies from DispatcherServlet.properties");
        }
    }
}

protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
    String key = strategyInterface.getName();//HandlerMappings
    //獲取HandlerMappings為key的value值,defaultStrategies在static塊中讀取DispatcherServlet.properties
    String value = defaultStrategies.getProperty(key);
    if (value != null) {
        //逗號，分割成數(shù)組
        String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
        List<T> strategies = new ArrayList<>(classNames.length);
        for (String className : classNames) {
            try {
                //反射加載并存儲strategies
                Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
                //通過容器創(chuàng)建bean 觸發(fā)后置處理器    
                Object strategy = createDefaultStrategy(context, clazz);
                strategies.add((T) strategy);
            }
     。。。
        }
        return strategies;
    }
    else {
        return new LinkedList<>();
    }
}
protected Object createDefaultStrategy(ApplicationContext context, Class<?> clazz) {
    //通過容器創(chuàng)建bean
    return context.getAutowireCapableBeanFactory().createBean(clazz);
}

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
   org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
   org.springframework.web.servlet.function.support.RouterFunctionMapping

protected void initApplicationContext() throws BeansException {
	//模板方法，用于給子類提供一個添加Interceptors的入口。
	extendInterceptors(this.interceptors);
	//將SpringMvc容器和父容器中所有的MappedInterceptor類型的Bean添加到mappedInterceptors的屬性
	detectMappedInterceptors(this.mappedInterceptors);
    //用于初始化Interceptor,將Interceptors屬性里所包含的對象按類型添加到mappedInterceptors和adaptedInterceptors.
	initInterceptors();
}

public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
	//getHandlerInternal(request)方法為抽象方法，供子類實現(xiàn)
	//獲取到的handler對象一般為bean/HandlerMethod
	Object handler = getHandlerInternal(request);
	//上述找不到則使用默認的處理類，沒有設定則返回null，則會返回前臺404錯誤
	if (handler == null) {
		handler = getDefaultHandler();
	}
	if (handler == null) {
		return null;
	}
	// Bean name or resolved handler?
	if (handler instanceof String) {
		String handlerName = (String) handler;
		handler = getApplicationContext().getBean(handlerName);
	}
	//創(chuàng)建處理鏈對象
	HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
	//針對cros跨域請求的處理，此處就不分析了
	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;
}
//針對HandlerMethod的獲取
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
	//獲取訪問的路徑，一般類似于request.getServletPath()返回不含contextPath的訪問路徑
	String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
	//獲取讀鎖
	this.mappingRegistry.acquireReadLock();
	try {
		//獲取HandlerMethod作為handler對象,這里涉及到路徑匹配的優(yōu)先級
		//優(yōu)先級：精確匹配>最長路徑匹配>擴展名匹配
		HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
		//HandlerMethod內(nèi)部含有bean對象，其實指的是對應的Controller
		return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
	}
	finally {
		//釋放讀鎖
		this.mappingRegistry.releaseReadLock();
	}
}
//針對beanName的獲取
protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
	String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
	//從handlerMap查找路徑對應的beanName
	Object handler = lookupHandler(lookupPath, request);
	if (handler == null) {
		// 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)) {
			rawHandler = getRootHandler();
		}
		if (rawHandler == null) {
			rawHandler = getDefaultHandler();
		}
		if (rawHandler != null) {
			// Bean name or resolved handler?
			if (rawHandler instanceof String) {
				String handlerName = (String) rawHandler;
				rawHandler = getApplicationContext().getBean(handlerName);
			}
			validateHandler(rawHandler, request);
			handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
		}
	}
	return handler;
}

//容器啟動時會運行此方法，完成handlerMethod的注冊操作  
@Override  
public void afterPropertiesSet() {  
	initHandlerMethods();  
}

protected void initHandlerMethods() {
   //獲取上下文中所有bean的name，不包含父容器
   for (String beanName : getCandidateBeanNames()) {
      if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
         processCandidateBean(beanName);
      }
   }
   //日志記錄HandlerMethods的總數(shù)量
   handlerMethodsInitialized(getHandlerMethods());
}

protected void processCandidateBean(String beanName) {
   Class<?> beanType = null;
   try {
      //根據(jù)name找出bean的類型
      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);
      }
   }
   //處理Controller和RequestMapping
   if (beanType != null && isHandler(beanType)) {
      detectHandlerMethods(beanName);
   }
}

//整個controller類的解析過程
protected void detectHandlerMethods(Object handler) {
   //根據(jù)name找出bean的類型
   Class<?> handlerType = (handler instanceof String ?
         obtainApplicationContext().getType((String) handler) : handler.getClass());
   if (handlerType != null) {
      //獲取真實的controller，如果是代理類獲取父類
      Class<?> userType = ClassUtils.getUserClass(handlerType);
      //對真實的controller所有的方法進行解析和處理  key為方法對象，T為注解封裝后的對象RequestMappingInfo
      Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
            (MethodIntrospector.MetadataLookup<T>) method -> {
               try {
                  // 調(diào)用子類RequestMappingHandlerMapping的getMappingForMethod方法進行處理，
                  // 即根據(jù)RequestMapping注解信息創(chuàng)建匹配條件RequestMappingInfo對象
                  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));
      }
      methods.forEach((method, mapping) -> {
         //找出controller中可外部調(diào)用的方法
         Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
         //注冊處理方法
         registerHandlerMethod(handler, invocableMethod, mapping);
      });
   }
}
后續(xù)主要是通過RequestMappingHandlerMapping  完成：

//注冊url和Bean的map,將具體的Handler注入到url對應的map中
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;
   // Eagerly resolve handler if referencing singleton via name.
   // 不是懶加載，默認為false，即不是，通過配置SimpleUrlHandlerMapping屬性lazyInitHandlers的值進行控制
   // 如果不是懶加載并且handler為單例，即從上下文中查詢實例處理，此時resolvedHandler為handler實例對象；
   // 如果是懶加載或者handler不是單例，即resolvedHandler為handler邏輯名
   if (!this.lazyInitHandlers && handler instanceof String) {
      String handlerName = (String) handler;
      ApplicationContext applicationContext = obtainApplicationContext();
      // 如果handler是單例，通過bean的scope控制
      if (applicationContext.isSingleton(handlerName)) {
         resolvedHandler = applicationContext.getBean(handlerName);
      }
   }
   Object mappedHandler = this.handlerMap.get(urlPath);
   if (mappedHandler != null) {
      if (mappedHandler != resolvedHandler) {
         throw new IllegalStateException(
               "Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
               "]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
      }
   }
   else {
      if (urlPath.equals("/")) {
         if (logger.isTraceEnabled()) {
            logger.trace("Root mapping to " + getHandlerDescription(handler));
         }
         //"/"-->設置為roothandler
         setRootHandler(resolvedHandler);
      }
      else if (urlPath.equals("/*")) {
         if (logger.isTraceEnabled()) {
            logger.trace("Default mapping to " + getHandlerDescription(handler));
         }
         //對"/*"的匹配設置默認的handler
         setDefaultHandler(resolvedHandler);
      }
      else {
         //其余的路徑綁定關(guān)系則存入handlerMap
         this.handlerMap.put(urlPath, resolvedHandler);
         if (logger.isTraceEnabled()) {
            logger.trace("Mapped [" + urlPath + "] onto " + getHandlerDescription(handler));
         }
      }
   }
}

@Override
protected boolean isHandler(Class<?> beanType) {
   //獲取@Controller和@RequestMapping
   return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
         AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
}
public static boolean hasAnnotation(AnnotatedElement element, Class<? extends Annotation> annotationType) {
		// Shortcut: directly present on the element, with no merging needed?
		if (AnnotationFilter.PLAIN.matches(annotationType) ||
				AnnotationsScanner.hasPlainJavaAnnotationsOnly(element)) {
			return element.isAnnotationPresent(annotationType);
		}
		// Exhaustive retrieval of merged annotations...
		return findAnnotations(element).isPresent(annotationType);
	}

protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
   RequestMappingInfo info = createRequestMappingInfo(method);
   if (info != null) {
      //解析方法所在類上的requestMapping
      RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
      if (typeInfo != null) {
         info = typeInfo.combine(info);//合并類和方法上的路徑,比如Controller類上有@RequestMapping("/demo")，方法的@RequestMapping("/demo1")，結(jié)果為"/demo/demo1"
      }
      String prefix = getPathPrefix(handlerType);//合并前綴
      if (prefix != null) {
         info = RequestMappingInfo.paths(prefix).options(this.config).build().combine(info);
      }
   }
   return info;
}
private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
		//找到方法上的RequestMapping注解
		RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(element, RequestMapping.class);
		//獲取自定義的類型條件(自定義的RequestMapping注解)
		RequestCondition<?> condition = (element instanceof Class ?
				getCustomTypeCondition((Class<?>) element) : getCustomMethodCondition((Method) element));
		return (requestMapping != null ? createRequestMappingInfo(requestMapping, condition) : null);
	}

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 {
      //beanName和method封裝成HandlerMethod對象
      HandlerMethod handlerMethod = createHandlerMethod(handler, method);
      //驗證RequestMappingInfo是否有對應不同的method，有則拋出異常
      validateMethodMapping(handlerMethod, mapping);
      //RequestMappingInfo和handlerMethod綁定
      this.mappingLookup.put(mapping, handlerMethod);
      List<String> directUrls = getDirectUrls(mapping);//可以配置多個url
      for (String url : directUrls) {
         //url和RequestMappingInfo綁定   可以根據(jù)url找到RequestMappingInfo，再找到handlerMethod
         this.urlLookup.add(url, mapping);
      }
      String name = null;
      if (getNamingStrategy() != null) {
         name = getNamingStrategy().getName(handlerMethod, mapping);
         addMappingName(name, handlerMethod);//方法名和Method綁定
      }
      CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
      if (corsConfig != null) {
         this.corsLookup.put(handlerMethod, corsConfig);
      }
      this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
   }
   finally {
      this.readWriteLock.writeLock().unlock();
   }
}

public class HelloController implements Controller {
    public ModelAndView handleRequest(HttpServletRequest request,
                                      HttpServletResponse response) throws Exception {
        ModelAndView mav = new ModelAndView("index");
        mav.addObject("message", "默認的映射處理器示例");
        return mav;
    }

<bean id="resourceView"
    class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/"></property>
    <property name="suffix" value=".jsp"></property>
</bean>
<bean id="/name.do" class="com.zy.mvc.controller.HelloController"></bean>

//向上繼承自ApplicationObjectSupport實現(xiàn)ApplicationContextAware接口
public abstract class ApplicationObjectSupport implements ApplicationContextAware {
    protected final Log logger = LogFactory.getLog(this.getClass());
    @Nullable
    private ApplicationContext applicationContext;
    ...
    public final void setApplicationContext(@Nullable ApplicationContext context) throws BeansException {
        if (context == null && !this.isContextRequired()) {
            this.applicationContext = null;
            this.messageSourceAccessor = null;
        } else if (this.applicationContext == null) {
            if (!this.requiredContextClass().isInstance(context)) {
                throw new ApplicationContextException("Invalid application context: needs to be of type [" + this.requiredContextClass().getName() + "]");
            }
            this.applicationContext = context;
            this.messageSourceAccessor = new MessageSourceAccessor(context);
            this.initApplicationContext(context);//模板方法，調(diào)子類
        } else if (this.applicationContext != context) {
            throw new ApplicationContextException("Cannot reinitialize with different application context: current one is [" + this.applicationContext + "], passed-in one is [" + context + "]");
        }
    }
    ...
}
	//AbstractDetectingUrlHandlerMapping
    @Override
    public void initApplicationContext() throws ApplicationContextException {
        super.initApplicationContext();//加載攔截器
        // 處理url和bean name，具體注冊調(diào)用父類AbstractUrlHandlerMapping類完成
        detectHandlers();
    }
    //建立當前ApplicationContext中controller和url的對應關(guān)系
    protected void detectHandlers() throws BeansException {
        // 獲取應用上下文
        ApplicationContext applicationContext = obtainApplicationContext();
        //獲取ApplicationContext中的所有bean的name(也是id，即@Controller的屬性值)
        String[] beanNames = (this.detectHandlersInAncestorContexts ?
                BeanFactoryUtils.beanNamesForTypeIncludingAncestors(applicationContext,Object.class) : applicationContext.getBeanNamesForType(Object.class));
        //遍歷所有beanName
        for (String beanName : beanNames) {
            // 通過模板方法模式調(diào)用BeanNameUrlHandlerMapping子類處理
            String[] urls = determineUrlsForHandler(beanName);//判斷是否以/開始
            if (!ObjectUtils.isEmpty(urls)) {
                //調(diào)用父類AbstractUrlHandlerMapping將url與handler存入map
                registerHandler(urls, beanName);
            }
        }
    }
    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;
        // Eagerly resolve handler if referencing singleton via name.
        if (!this.lazyInitHandlers && handler instanceof String) {
            String handlerName = (String) handler;
            ApplicationContext applicationContext = obtainApplicationContext();
            if (applicationContext.isSingleton(handlerName)) {
                resolvedHandler = applicationContext.getBean(handlerName);
            }
        }
        //已存在且指向不同的Handler拋異常
        Object mappedHandler = this.handlerMap.get(urlPath);
        if (mappedHandler != null) {
            if (mappedHandler != resolvedHandler) {
                throw new IllegalStateException(
                        "Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
                                "]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
            }
        }
        else {
            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 {
                this.handlerMap.put(urlPath, resolvedHandler);//注冊進map
                if (logger.isTraceEnabled()) {
                    logger.trace("Mapped [" + urlPath + "] onto " + getHandlerDescription(handler));
                }
            }
        }
    }

public class SimpleUrlHandlerMapping extends AbstractUrlHandlerMapping {
    // 存儲url和bean映射
    private final Map<String, Object> urlMap = new LinkedHashMap<>();
    // 注入property的name為mappings映射
    public void setMappings(Properties mappings) {
        CollectionUtils.mergePropertiesIntoMap(mappings, this.urlMap);
    }
    // 注入property的name為urlMap映射
    public void setUrlMap(Map<String, ?> urlMap) {
        this.urlMap.putAll(urlMap);
    }
    public Map<String, ?> getUrlMap() {
        return this.urlMap;
    }
    // 實例化本類實例入口
    @Override
    public void initApplicationContext() throws BeansException {
        // 調(diào)用父類AbstractHandlerMapping的initApplicationContext方法，只要完成攔截器的注冊
        super.initApplicationContext();
        // 處理url和bean name，具體注冊調(diào)用父類完成
        registerHandlers(this.urlMap);
    }
    // 注冊映射關(guān)系，及將property中的值解析到map對象中，key為url，value為bean id或name
    protected void registerHandlers(Map<String, Object> urlMap) throws BeansException {
        if (urlMap.isEmpty()) {
            logger.warn("Neither 'urlMap' nor 'mappings' set on SimpleUrlHandlerMapping");
        } else {
            urlMap.forEach((url, handler) -> {
                // 增加以"/"開頭
                if (!url.startsWith("/")) {
                    url = "/" + url;
                }
                // 去除handler bean名稱的空格
                if (handler instanceof String) {
                    handler = ((String) handler).trim();
                }
                // 調(diào)用父類AbstractUrlHandlerMapping完成映射
                registerHandler(url, handler);
            });
        }
    }
}