如何根據http請求選擇合适的controller是MVC中一項十分關鍵的功能，在Spring MVC中，HandlerMapping接口是這一活動的抽象。同時，Spring MVC也提供了一系列HandlerMapping的實作，根據一定的規則選擇controller。如果目前的HandlerMappign實作中沒有能夠滿足你所需要的規則時，可以通過實作HandlerMapping接口進行擴充。下面，就來看一下HandlerMapping相關的類圖：
在Spring MVC中，關于HandlerMapping的使用，主要包括兩個部分：注冊和查找。在HandlerMapping的實作中，持有一個handlerMap這樣一個HashMap<String, Object>，其中key是http請求的path資訊，value可以是一個字元串，或者是一個處理請求的HandlerExecutionChain，如果是String類型，則會将其視為Spring的bean名稱。在HandlerMapping對象的建立中，IoC容器執行了一個容器回調方法setApplicationContext，在這個方法中調用initApplicationContext方法進行初始化，各個子類可以根據需求的不同覆寫這個方法。關于handlerMap資訊的注冊就是在initApplicationContext方法中被執行的。下面就來看一下注冊url到controller映射資訊的實作：
SimpleUrlHandlerMapping中的注冊實作代碼：
protected void registerHandlers(Map<String, Object> urlMap) throws BeansException {
if (urlMap.isEmpty()) {
logger.warn("Neither 'urlMap' nor 'mappings' set on SimpleUrlHandlerMapping");
}
else {
//urlMap資訊是根據配置檔案注入進來的
for (Map.Entry<String, Object> entry : urlMap.entrySet()) {
String url = entry.getKey();
Object handler = entry.getValue();
// Prepend with slash if not already present.
if (!url.startsWith("/")) {
url = "/" + url;
}
// Remove whitespace from handler bean name.
if (handler instanceof String) {
handler = ((String) handler).trim();
}
registerHandler(url, handler);
}
}
}
AbstractDetectingUrlHandlerMapping中的注冊實作代碼：
protected void detectHandlers() throws BeansException {
if (logger.isDebugEnabled()) {
logger.debug("Looking for URL mappings in application context: " + getApplicationContext());
}
String[] beanNames = (this.detectHandlersInAncestorContexts ?
BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
getApplicationContext().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);
}
else {
if (logger.isDebugEnabled()) {
logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");
}
}
}
}
單個的映射關系注冊是在registerHandler方法中執行的：
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.
//如果給定的handeler是字元串，則認為是bean name，直接到IoC容器中取得bean instance
if (!this.lazyInitHandlers && handler instanceof String) {
String handlerName = (String) handler;
if (getApplicationContext().isSingleton(handlerName)) {
resolvedHandler = getApplicationContext().getBean(handlerName);
}
}
Object mappedHandler = this.handlerMap.get(urlPath);
//同一path不能對應多個處理對象
if (mappedHandler != null) {
if (mappedHandler != resolvedHandler) {
throw new IllegalStateException(
"Cannot map handler [" + handler + "] to URL path [" + urlPath +
"]: There is already handler [" + resolvedHandler + "] mapped.");
}
}
else {
if (urlPath.equals("/")) {
if (logger.isInfoEnabled()) {
logger.info("Root mapping to handler [" + resolvedHandler + "]");
}
setRootHandler(resolvedHandler);
}
else if (urlPath.equals("/*")) {
if (logger.isInfoEnabled()) {
logger.info("Default mapping to handler [" + resolvedHandler + "]");
}
setDefaultHandler(resolvedHandler);
}
else {
//将path和handler放在handlerMap中，儲存了它們之間的映射關系
this.handlerMap.put(urlPath, resolvedHandler);
if (logger.isInfoEnabled()) {
logger.info("Mapped URL path [" + urlPath + "] onto handler [" + resolvedHandler + "]");
}
}
}
}
通過以上代碼，在HandlerMapping對象被建立的時候，即完成了url到handler之間的映射關系的注冊。handlerMap已經被指派，可以被使用了。
在完成url到handler映射關系的注冊後，就可以使用getHandler方法，根據http請求獲得handler對象了。下面，首先看一下getHandler方法的調用時序：
下面就主要關注一下上圖中涉及到的方法的代碼實作。
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
Object handler = getHandlerInternal(request);
//如果沒有找到比對的handler，則使用預設handler
if (handler == null) {
handler = getDefaultHandler();
}
if (handler == null) {
return null;
}
// Bean name or resolved handler?
//如果給定的handler是字元串類型，則認為是bean name
if (handler instanceof String) {
String handlerName = (String) handler;
handler = getApplicationContext().getBean(handlerName);
}
//如果Handler是HandlerExecutionChain類型，則隻是添加攔截器，否則會建立一個新的HandlerExecutionChain
return getHandlerExecutionChain(handler, request);
}
将url資訊與handler進行比對查找的操作是在lookupHandler方法中執行的，下面就來看一下lookupHandler方法的實作：
//這個方法可能的傳回值是HandlerExecutionChain對象或者是null
//在HandlerExecutionChain對象中的handler，是根據handlerMap中取出來的bean name獲得到的bean instance
protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
// Direct match?
//直接比對
Object handler = this.handlerMap.get(urlPath);
if (handler != null) {
// Bean name or resolved handler?
if (handler instanceof String) {
String handlerName = (String) handler;
//從IoC容器中取出handler
handler = getApplicationContext().getBean(handlerName);
}
validateHandler(handler, request);
//建立一個HandlerExecutionChain對象并傳回
return buildPathExposingHandler(handler, urlPath, urlPath, null);
}
// Pattern match?
//根據一定的模式比對規則
List<String> matchingPatterns = new ArrayList<String>();
for (String registeredPattern : this.handlerMap.keySet()) {
if (getPathMatcher().match(registeredPattern, urlPath)) {
matchingPatterns.add(registeredPattern);
}
}
String bestPatternMatch = null;
if (!matchingPatterns.isEmpty()) {
Collections.sort(matchingPatterns, getPathMatcher().getPatternComparator(urlPath));
if (logger.isDebugEnabled()) {
logger.debug("Matching patterns for request [" + urlPath + "] are " + matchingPatterns);
}
bestPatternMatch = matchingPatterns.get(0);
}
if (bestPatternMatch != null) {
//處理最佳比對
handler = this.handlerMap.get(bestPatternMatch);
// Bean name or resolved handler?
if (handler instanceof String) {
String handlerName = (String) handler;
handler = getApplicationContext().getBean(handlerName);
}
validateHandler(handler, request);
String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestPatternMatch, urlPath);
Map<String, String> uriTemplateVariables =
getPathMatcher().extractUriTemplateVariables(bestPatternMatch, urlPath);
//傳回一個HandlerExecutionChain對象
return buildPathExposingHandler(handler, bestPatternMatch, pathWithinMapping, uriTemplateVariables);
}
// No handler found...
return null;
}
最後在關注一下getHandlerInternal的代碼實作
protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
//查找符合比對規則的handler。可能的結果是HandlerExecutionChain對象或者是null
Object handler = lookupHandler(lookupPath, request);
//如果沒有找到比對的handler，則需要處理下default handler
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();
}
//在getRootHandler和getDefaultHandler方法中，可能持有的是bean name。
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);
}
}
//如果handler還是為空，則抛出錯誤。
if (handler != null && this.mappedInterceptors != null) {
Set<HandlerInterceptor> mappedInterceptors =
this.mappedInterceptors.getInterceptors(lookupPath, this.pathMatcher);
if (!mappedInterceptors.isEmpty()) {
HandlerExecutionChain chain;
if (handler instanceof HandlerExecutionChain) {
chain = (HandlerExecutionChain) handler;
} else {
chain = new HandlerExecutionChain(handler);
}
chain.addInterceptors(mappedInterceptors.toArray(new HandlerInterceptor[mappedInterceptors.size()]));
}
}
if (handler != null && logger.isDebugEnabled()) {
logger.debug("Mapping [" + lookupPath + "] to handler '" + handler + "'");
}
else if (handler == null && logger.isTraceEnabled()) {
logger.trace("No handler mapping found for [" + lookupPath + "]");
}
return handler;
}
經過上述代碼的處理，就可以使用getHandler方法獲得到HandlerExecutionChain對象了。DispatcherServlet獲得到HandlerExecutionChain對象後，便可以獲得真正的handler，調用相應的Controller了。
這篇文章主要包括兩個方面的内容：HandlerMapping中url到handler映射關系的注冊和根據url查找handler。第一部分是在HandlerMapping對象建立後，使用IoC容器的回調方法觸發的，第二部分是在DispatchServlet中，調用getHandler方法觸發的。