handlerMapping和handlerAdapter前面几篇文章或多或少都已经提及，此篇文章一方面是为了加深印象，另一方面通过部分源码再进一步了解深入。
一、Spring MVC中的handlerMapping
我们知道Spring MVC 使用HandlerMapping来找到并保存url请求和处理函数间的mapping关系，即根据http请求选择合适的controller。以DefaultAnnotationHandlerMapping为例来具体看HandlerMapping的作用：DefaultAnnotationHandlerMapping将扫描当前所有已经注册的spring beans中的@requestmapping标注以找出url 和 handler method处理函数的关系并予以关联。
如果当前的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方法触发的。
下面具体看下两个常用handlerMapping的配置：
BeanNameUrlHandlerMapping: 查找spring容器中和请求的url同名的bean.这个映射器不需要配置,因为spring在找不到handlerMapping的情况下会使用BeanNameUrlHandlerMapping.如果一定要配置,像下面这样就行了:
<bean class=”org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping” />
比如有一个请求/index.htm, 则就会找到一个名叫/index.htm的bean来处理这个请求; 这种做法让我们可以做出虚拟目录的效果:
<bean name=”/user/index.htm” class=”controller.TestController” />
<bean name=”/admin/index.htm” class=”controller.TestController” />
SimpleUrlHandlerMapping: 这个handlerMapping可以配置请求的url和handler的映射关系。
<bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="interceptors">
<list>
<ref bean="localeChangeInterceptor"/>
<ref bean="someOtherCheckInterceptor"/>
</list>
</property>
<property name="mappings">
<props>
<prop key="/project.htm">projectController</prop>
<prop key="/manage.htm">managementController</prop>
<prop key="/user.htm">userController</prop>
<prop key="/upload.htm">fileUploadController</prop>
</props>
</property>
</bean> 二、Spring MVC中的Handleradapter
Spring MVC通过HandlerAdapter来实际调用处理函数。
以AnnotationMethodHandlerAdapter为例：
DispatcherServlet中根据handlermapping找到对应的handler后，首先检查当前工程中注册的所有可用的handlerAdapter,根据handlerAdapter中的supports方法找到可以使用的handlerAdapter。通过调用handlerAdapter中的handle方法来处理及准备handler method中的参数及annotation(这就是spring mvc如何将reqeust中的参数变成handle method中的输入参数的地方)，最终调用实际的handle method。
detectAllHandlerMappings：
缺省情况下spring mvc 将加载 当前系统中所有实现了HandlerMapping接口的bean。如果只期望spring mvc加载指定的handlermapping时，可以修改web.xml中的DispatcherServlet的初始参数，将detectAllHandlerMappings的值设置为false。
<init-param>
<param-name>detectAllHandlerMappings</param-name>
<param-value>false</param-value>
</init-param> 此时spring mvc将查找名 为“handlerMapping”的bean并作为当前系统中唯一的handlermapping。如果没有定义handlerMapping的话，则spring mvc将按照org.springframework.web.servlet.DispatcherServlet所在目录下的DispatcherServlet.properties中所定义的org.springframework.web.servlet.HandlerMapping的内容来加载缺省的handlerMapping（用户没有自定义Strategies的情况下）。
detectAllHandlerAdapters：
作用和detectAllHandlerMappings类似，只不过作用对象为handlerAdapter。亦可通过
<init-param>
<param-name>detectAllHandlerAdapters</param-name>
<param-value>false</param-value>
</init-param> 来强制系统只加载bean name 为” handlerAdapter”handlerAdapter。加载不到的情况下将按照DispatcherServlet.properties中所定义的org.springframework.web.servlet.HandlerAdapter的内容来加载缺省的handlerAdapter。
