public interface HandlerMapping {
    HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;
}

protected void initStrategies(ApplicationContext context) {
        this.initMultipartResolver(context);
        this.initLocaleResolver(context);
        this.initThemeResolver(context);
        this.initHandlerMappings(context);
        this.initHandlerAdapters(context);
        this.initHandlerExceptionResolvers(context);
        this.initRequestToViewNameTranslator(context);
        this.initViewResolvers(context);
        this.initFlashMapManager(context);
}

public class DispatcherServlet extends FrameworkServlet {
  private void initHandlerMappings(ApplicationContext context) {...}
}
private void initHandlerMappings(ApplicationContext context) {
        this.handlerMappings = null;
    	//private boolean detectAllHandlerMappings = true; 
    	//該值默認(rèn)為 true,查詢所有的handlerMapping
    	// 如果設(shè)置為 false , Spring MVC就只會(huì)查找名為“handlerMapping”的bean，并作為當(dāng)前系統(tǒng)的唯一的HandlerMapping
        if (this.detectAllHandlerMappings) {
            //在ApplicationContext中查找所有handler映射，包括父類上下文。
            Map<String, HandlerMapping> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
            //存在Handler
            if (!matchingBeans.isEmpty()) {
                //將獲取的 HandlerMapping 轉(zhuǎn)換成集合并排序
                this.handlerMappings = new ArrayList(matchingBeans.values());
                AnnotationAwareOrderComparator.sort(this.handlerMappings);
            }
        } else {
            //沒(méi)有找到
            try {
                //查找名為“handlerMapping”的bean，并作為當(dāng)前系統(tǒng)的唯一的HandlerMapping，確保至少有一個(gè)HandlerMapping
                HandlerMapping hm = (HandlerMapping)context.getBean("handlerMapping", HandlerMapping.class);
                this.handlerMappings = Collections.singletonList(hm);
            } catch (NoSuchBeanDefinitionException var4) {
            }
        }
            this.handlerMappings = this.getDefaultStrategies(context, HandlerMapping.class);
        }
        Iterator var6 = this.handlerMappings.iterator();
		//迭代HandlerMapping
        while(var6.hasNext()) {
            HandlerMapping mapping = (HandlerMapping)var6.next();
            //判斷HandlerMapping實(shí)例是否啟用了解析的PathPatterns
            //如果啟用則DispatcherServlet會(huì)自動(dòng)解析RequestPath，以便在HandlerMappings，HandlerInterceptors和其他組件中訪問(wèn)
            if (mapping.usesPathPatterns()) {
                this.parseRequestPath = true;
                break;
            }
        }
    }

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
	mappedHandler = this.getHandler(processedRequest);
}

//返回一個(gè)HandlerExecutionChain對(duì)象
@Nullable
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        if (this.handlerMappings != null) {
            Iterator var2 = this.handlerMappings.iterator();
			//遍歷所有的初始化的HandlerMapping列表
            while(var2.hasNext()) {
                HandlerMapping mapping = (HandlerMapping)var2.next();
                //獲取一個(gè)HandlerExecutionChain對(duì)象，它包含了處理請(qǐng)求的handler對(duì)象和任何配置的攔截器
                //接口方法
                HandlerExecutionChain handler = mapping.getHandler(request);
                //匹配到就進(jìn)行返回
                if (handler != null) {
                    return handler;
                }
            }
        }
        return null;
}

public abstract class AbstractHandlerMapping extends WebApplicationObjectSupport implements HandlerMapping, Ordered, BeanNameAware {
    public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {……};
}
@Nullable
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    	// 根據(jù)請(qǐng)求從緩存中查找handler，如果沒(méi)有則調(diào)用子類實(shí)現(xiàn)的getHandlerInternal()方法
    	該方法在本類中有定義，是一個(gè)protected型的抽象方法
        Object handler = this.getHandlerInternal(request);
    	// 沒(méi)有找到，則會(huì)使用getDefaultHandler()方法獲取默認(rèn)的處理器
        if (handler == null) {
            handler = this.getDefaultHandler();
        }
        if (handler == null) {
            return null;
        } else {
            //檢查handler對(duì)象是否是一個(gè)字符串類型。如果是的話，就從應(yīng)用上下文中根據(jù)字符串名稱獲取對(duì)應(yīng)的bean作為handler對(duì)象
            if (handler instanceof String) {
                String handlerName = (String)handler;
                handler = this.obtainApplicationContext().getBean(handlerName);
            }
			//如果請(qǐng)求對(duì)象中沒(méi)有緩存的路徑信息，就調(diào)用initLookupPath方法來(lái)解析請(qǐng)求的路徑信息，并且保存在請(qǐng)求對(duì)象的一個(gè)屬性中
            if (!ServletRequestPathUtils.hasCachedPath(request)) {
                this.initLookupPath(request);
            }
			//根據(jù)handler對(duì)象和請(qǐng)求創(chuàng)建一個(gè)HandlerExecutionChain對(duì)象,包含處理器對(duì)象和攔截器列表
            HandlerExecutionChain executionChain = this.getHandlerExecutionChain(handler, request);
            return executionChain;
        }
}

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="mappings">
        <props>
            <prop key="/test.do">testController</prop>
        </props>
    </property>
</bean>
<bean id="testController" class="com.example.TestController"/>

@Controller
@RequestMapping("/test")
public class TestController {
    @RequestMapping("/do")
    public String doSomething() {
        // ...
    }
}

//根據(jù)用戶請(qǐng)求信息中的URL查找handler
protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
    	//初始化請(qǐng)求的查找路徑，也就是去掉上下文路徑和后綴名的URL路徑
        String lookupPath = this.initLookupPath(request);
        Object handler;
    	//是否使用路徑模式來(lái)選擇不同的查找handler的方法
    	//
        if (this.usesPathPatterns()) {
            //獲取請(qǐng)求的RequestPath對(duì)象，它封裝了請(qǐng)求的URL路徑、上下文路徑、后綴名等信息。
            RequestPath path = ServletRequestPathUtils.getParsedRequestPath(request);
            //根據(jù)RequestPath對(duì)象、查找路徑和請(qǐng)求對(duì)象，調(diào)用lookupHandler()方法來(lái)查找匹配的handler
            handler = this.lookupHandler(path, lookupPath, request);
        } else {
            handler = this.lookupHandler(lookupPath, request);
        }
    	//沒(méi)有找到匹配的handler時(shí)，嘗試獲取根handler或者默認(rèn)handler，并進(jìn)行驗(yàn)證和包裝。
        if (handler == null) {
            Object rawHandler = null;
            if (StringUtils.matchesCharacter(lookupPath, '/')) {
                rawHandler = this.getRootHandler();
            }
            if (rawHandler == null) {
                rawHandler = this.getDefaultHandler();
            }
            if (rawHandler != null) {
                if (rawHandler instanceof String) {
                    String handlerName = (String)rawHandler;
                    rawHandler = this.obtainApplicationContext().getBean(handlerName);
                }
                this.validateHandler(rawHandler, request);
                handler = this.buildPathExposingHandler(rawHandler, lookupPath, lookupPath, (Map)null);
            }
        }
		//返回獲取到的handler對(duì)象
        return handler;
}

protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
    	//初始化請(qǐng)求的查找路徑，也就是去掉上下文路徑和后綴名的URL路徑
        String lookupPath = this.initLookupPath(request);
    	//獲取映射注冊(cè)表的讀鎖，以保證線程安全
        this.mappingRegistry.acquireReadLock();
        HandlerMethod var4;
    	//獲取讀鎖后，嘗試查找匹配的handler方法，并在最后釋放讀鎖
        try {
            //根據(jù)查找路徑和請(qǐng)求對(duì)象，在映射注冊(cè)表中查找匹配的handler方法
            HandlerMethod handlerMethod = this.lookupHandlerMethod(lookupPath, request);
            //判斷是否找到了handler方法
            //如果找到了，則調(diào)用createWithResolvedBean()方法來(lái)創(chuàng)建一個(gè)新的HandlerMethod實(shí)例，并解析其關(guān)聯(lián)的bean對(duì)象；
            //如果沒(méi)有找到，則返回null。
            var4 = handlerMethod != null ? handlerMethod.createWithResolvedBean() : null;
        } finally {
            this.mappingRegistry.releaseReadLock();
        }
		//返回獲取到的handler對(duì)象
        return var4;
}

@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/{id}")
    public String getUser(@PathVariable int id, Model model) {
        User user = userRepository.findById(id);
        model.addAttribute("user", user);
        return "user";
    }
}

public void afterPropertiesSet() {
    	//……
        super.afterPropertiesSet();
}

//父類AbstractHandlerMethodMapping 的方法
public void afterPropertiesSet() {
        this.initHandlerMethods();
}
//掃描容器中的bean，檢測(cè)和注冊(cè)handler方法
protected void initHandlerMethods() {
    	//獲取候選的bean名稱數(shù)組
        String[] var1 = this.getCandidateBeanNames();
        int var2 = var1.length;
		//遍歷
        for(int var3 = 0; var3 < var2; ++var3) {
            String beanName = var1[var3];
            //用于過(guò)濾掉以"scopedTarget."開(kāi)頭的bean名稱的。
            //這些bean名稱是由Spring創(chuàng)建的代理對(duì)象，用于支持不同作用域的bean
            //例如session或request。這些代理對(duì)象不是真正的handler，所以要排除掉。
            if (!beanName.startsWith("scopedTarget.")) {
                //處理候選的bean,判斷候選的bean是否是一個(gè)handler，也就是是否有@Controller注解或者@RequestMapping注解
                //如果是的話，就調(diào)用detectHandlerMethods方法，用于檢測(cè)和注冊(cè)handler方法
                this.processCandidateBean(beanName);
            }
        }
		//初始化handler方法, 對(duì)所有handler方法進(jìn)行排序和日志輸出
        this.handlerMethodsInitialized(this.getHandlerMethods());
}
//檢測(cè)和注冊(cè)handler方法
protected void detectHandlerMethods(Object handler) {
    	//存儲(chǔ)handler對(duì)象的類信息
    	//如果handler是一個(gè)字符串，那么就使用應(yīng)用程序上下文來(lái)獲取對(duì)應(yīng)的類類型；否則就直接使用handler.getClass()方法來(lái)獲取類類型。
        Class<?> handlerType = handler instanceof String ? this.obtainApplicationContext().getType((String)handler) : handler.getClass();
        if (handlerType != null) {
            //存儲(chǔ)handlerType去除代理和增強(qiáng)后的原始類類型。這是為了避免AOP對(duì)方法檢測(cè)造成干擾。
            Class<?> userType = ClassUtils.getUserClass(handlerType);
            //存儲(chǔ)userType中所有帶有映射注解（如@RequestMapping）的方法及其對(duì)應(yīng)的映射信息
            Map<Method, T> methods = MethodIntrospector.selectMethods(userType, (method) -> {
                try {
                    //獲取每個(gè)方法上定義或繼承的映射信息
                    return this.getMappingForMethod(method, userType);
                } catch (Throwable var4) {
                    throw new IllegalStateException("Invalid mapping on handler class [" + userType.getName() + "]: " + method, var4);
                }
            });
            //遍歷methods中每個(gè)鍵值對(duì)（即每個(gè)方法及其映射信息）
            methods.forEach((method, mapping) -> {
                //存儲(chǔ)經(jīng)過(guò)AopUtils.selectInvocableMethod()方法處理后可以被調(diào)用（即沒(méi)有被final修飾）
                //且與userType匹配（即沒(méi)有被覆蓋） 的原始或橋接（即泛型擦除后生成） 方法
                Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
                //注冊(cè)到處理器映射
                this.registerHandlerMethod(handler, invocableMethod, mapping);
            });
        }
 }

//根據(jù)處理器類和方法上的@RequestMapping注解來(lái)創(chuàng)建一個(gè)RequestMappingInfo對(duì)象(封裝了請(qǐng)求映射的信息，如請(qǐng)求路徑、請(qǐng)求方法、請(qǐng)求參數(shù)、請(qǐng)求頭等)
protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
	    //獲取方法上定義或繼承的@RequestMapping注解，并將其轉(zhuǎn)換為一個(gè)RequestMappingInfo對(duì)象
        RequestMappingInfo info = this.createRequestMappingInfo(method);
        if (info != null) {
            //獲取處理器類上定義或繼承的@RequestMapping注解，并將其轉(zhuǎn)換為另一個(gè)RequestMappingInfo對(duì)象
            RequestMappingInfo typeInfo = this.createRequestMappingInfo(handlerType);
            if (typeInfo != null) {
                //合并兩個(gè)RequestMappingInfo對(duì)象
                info = typeInfo.combine(info);
            }
			//獲取處理器類上定義或繼承的@PathPrefix注解，并將其轉(zhuǎn)換為一個(gè)字符串前綴
            String prefix = this.getPathPrefix(handlerType);
            if (prefix != null) {
                //根據(jù)指定的路徑前綴和配置選項(xiàng)來(lái)構(gòu)建一個(gè)新的請(qǐng)求映射信息，并且與原有信息進(jìn)行合并
                info = RequestMappingInfo.paths(new String[]{prefix}).options(this.config).build().combine(info);
            }
        }
        return info;
}

protected void registerHandlerMethod(Object handler, Method method, RequestMappingInfo mapping) {
        super.registerHandlerMethod(handler, method, mapping);
        this.updateConsumesCondition(mapping, method);
}
//AbstractHandlerMethodMapping類中的方法
protected void registerHandlerMethod(Object handler, Method method, T mapping) {
        this.mappingRegistry.register(mapping, handler, method);
}
public void register(T mapping, Object handler, Method method) {
            try {
                // 創(chuàng)建HandlerMethod對(duì)象
                HandlerMethod handlerMethod = AbstractHandlerMethodMapping.this.createHandlerMethod(handler, method);
                this.validateMethodMapping(handlerMethod, mapping);
                //獲取匹配條件對(duì)應(yīng)的直接路徑，添加到pathLookup中
                Set<String> directPaths = AbstractHandlerMethodMapping.this.getDirectPaths(mapping);
                Iterator var6 = directPaths.iterator();
                while(var6.hasNext()) {
                    String path = (String)var6.next();
                    this.pathLookup.add(path, mapping);
                }
				//如果有命名策略，獲取handler方法的名稱，添加到nameLookup中
                String name = null;
                if (AbstractHandlerMethodMapping.this.getNamingStrategy() != null) {
                    name = AbstractHandlerMethodMapping.this.getNamingStrategy().getName(handlerMethod, mapping);
                    this.addMappingName(name, handlerMethod);
                }
				//將匹配條件和MappingRegistration對(duì)象（封裝了handler方法、直接路徑、名稱、跨域配置等信息）添加到registry中
                this.registry.put(mapping, new AbstractHandlerMethodMapping.MappingRegistration(mapping, handlerMethod, directPaths, name, corsConfig != null));
            } finally {
            }
}

protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
    	// 創(chuàng)建一個(gè)空的Match列表，用來(lái)存放匹配的RequestMappingInfo和HandlerMethod對(duì)象
        List<AbstractHandlerMethodMapping<T>.Match> matches = new ArrayList();
    	// 從mappingRegistry中獲取直接路徑匹配（即沒(méi)有通配符或變量）的RequestMappingInfo列表
        List<T> directPathMatches = this.mappingRegistry.getMappingsByDirectPath(lookupPath);
        if (directPathMatches != null) {
            // 調(diào)用addMatchingMappings方法，判斷直接路徑匹配的RequestMappingInfo是否與請(qǐng)求條件匹配
            //如果匹配，就添加到matches列表中
            this.addMatchingMappings(directPathMatches, matches, request);
        }
        if (matches.isEmpty()) {
             // 如果matches列表為空，說(shuō)明沒(méi)有直接路徑匹配的RequestMappingInfo與請(qǐng)求條件匹配
            //那么就從mappingRegistry中獲取所有注冊(cè)過(guò)的RequestMappingInfo，
            //并調(diào)用addMatchingMappings方法判斷是否與請(qǐng)求條件匹配
            //如果匹配，就添加到matches列表中
            this.addMatchingMappings(this.mappingRegistry.getRegistrations().keySet(), matches, request);
        }
        if (matches.isEmpty()) {
             // 如果matches列表仍然為空，說(shuō)明沒(méi)有任何一個(gè)RequestMappingInfo與請(qǐng)求條件匹配
            //那么就調(diào)用handleNoMatch方法處理沒(méi)有匹配結(jié)果的情況，并返回null或拋出異常
            return this.handleNoMatch(this.mappingRegistry.getRegistrations().keySet(), lookupPath, request);
        } else {
            // 如果matches列表不為空，說(shuō)明至少有一個(gè)RequestMappingInfo與請(qǐng)求條件匹配
        	// 那么就從matches列表中獲取第一個(gè)Match對(duì)象（即最先添加進(jìn)去的），作為最佳匹配結(jié)果
            AbstractHandlerMethodMapping<T>.Match bestMatch = (AbstractHandlerMethodMapping.Match)matches.get(0);
            if (matches.size() > 1) {
                // 如果matches列表中有多個(gè)Match對(duì)象（即有多個(gè)RequestMappingInfo與請(qǐng)求條件匹配）
                //那么就需要進(jìn)行排序和篩選
            	// 首先創(chuàng)建一個(gè)比較器comparator，根據(jù)getMappingComparator方法返回的比較器對(duì)每個(gè)Match對(duì)象進(jìn)行比較（主要比較它們包含的RequestMappingInfo）
                Comparator<AbstractHandlerMethodMapping<T>.Match> comparator = new AbstractHandlerMethodMapping.MatchComparator(this.getMappingComparator(request));
                 // 然后對(duì)matches列表進(jìn)行排序，根據(jù)comparator比較器確定每個(gè)Match對(duì)象之間的優(yōu)先級(jí)和順序
                matches.sort(comparator);
            	// 再次從matches列表中獲取第一個(gè)Match對(duì)象（即排序后最優(yōu)先級(jí)最高、順序最靠前、
                //最符合請(qǐng)求條件、最具體化、最少參數(shù)化等等）作為最佳匹配結(jié)果
                bestMatch = (AbstractHandlerMethodMapping.Match)matches.get(0);
                }
            }
            request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.getHandlerMethod());
            this.handleMatch(bestMatch.mapping, lookupPath, request);
            return bestMatch.getHandlerMethod();
        }
    }

public class MySimpleUrlHandlerMapping extends SimpleUrlHandlerMapping {
    public MySimpleUrlHandlerMapping() {
        Properties mappings = new Properties();
        mappings.setProperty("/hello", "helloController");
        setMappings(mappings);
    }
}

public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView mav = new ModelAndView("hello");
        mav.addObject("message", "Hello, World!");
        return mav;
    }
}

MySimpleUrlHandlerMapping handlerMapping = new MySimpleUrlHandlerMapping();
Map<String, Object> urlMap = new HashMap<>();
urlMap.put("/hello", new HelloController());
handlerMapping.setUrlMap(urlMap);

protected void registerHandlers(Map<String, Object> urlMap) throws BeansException {
        if (urlMap.isEmpty()) {
            //不作操作
        } else {
            //遍歷urlMap中的每一對(duì)鍵值對(duì)，鍵是URL模式，值是handler對(duì)象
            urlMap.forEach((url, handler) -> {
                //對(duì)于每一個(gè)URL模式，如果它沒(méi)有以斜杠（/）開(kāi)頭，則在前面加上一個(gè)斜杠
                if (!url.startsWith("/")) {
                    url = "/" + url;
                }
				//對(duì)于每一個(gè)handler對(duì)象，如果它是一個(gè)字符串，則去掉字符串兩端的空白字符
                if (handler instanceof String) {
                    handler = ((String)handler).trim();
                }
				//調(diào)用父類AbstractUrlHandlerMapping的registerHandler方法，將URL模式和handler對(duì)象注冊(cè)到內(nèi)部的handlerMap中
                this.registerHandler(url, handler);
            });
        }
    }

@Controller
public class MyController {
    @Autowired
    private HandlerMapping handlerMapping;
    @RequestMapping("/my/path")
    public String handleRequest(HttpServletRequest request) throws Exception {
        HandlerExecutionChain chain = handlerMapping.getHandler(request);
        Object handler = chain.getHandler();
        // ...
    }
}