SpringMVC学习笔记

     如何根据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中的注册实现代码：

 

Java代码  

1. <span>protected void registerHandlers(Map<String, Object> urlMap) throws BeansException {    
2.         if (urlMap.isEmpty()) {    
3.             logger.warn("Neither 'urlMap' nor 'mappings' set on SimpleUrlHandlerMapping");    
4.         }    
5.         else {    
6. //urlMap信息是根据配置文件注入进来的     
7.             for (Map.Entry<String, Object> entry : urlMap.entrySet()) {    
8.                 String url = entry.getKey();    
9.                 Object handler = entry.getValue();    
10.                 // Prepend with slash if not already present.     
11.                 if (!url.startsWith("/")) {    
12.                     url = "/" + url;    
13.                 }    
14.                 // Remove whitespace from handler bean name.     
15.                 if (handler instanceof String) {    
16.                     handler = ((String) handler).trim();    
17.                 }    
18.                 registerHandler(url, handler);    
19.             }    
20.         }    
21.     }    
22. </span>  

 

AbstractDetectingUrlHandlerMapping中的注册实现代码：

 

Java代码  

1. <span>protected void detectHandlers() throws BeansException {    
2.         if (logger.isDebugEnabled()) {    
3.             logger.debug("Looking for URL mappings in application context: " + getApplicationContext());    
4.         }    
5.         String[] beanNames = (this.detectHandlersInAncestorContexts ?    
6.                 BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :    
7.                 getApplicationContext().getBeanNamesForType(Object.class));    
8.     
9.         // Take any bean name that we can determine URLs for.     
10.         for (String beanName : beanNames) {    
11.             String[] urls = determineUrlsForHandler(beanName);    
12.             if (!ObjectUtils.isEmpty(urls)) {    
13.                 // URL paths found: Let's consider it a handler.     
14.                 registerHandler(urls, beanName);    
15.             }    
16.             else {    
17.                 if (logger.isDebugEnabled()) {    
18.                     logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");    
19.                 }    
20.             }    
21.         }    
22.     }    
23. </span>  

 

单个的映射关系注册是在registerHandler方法中执行的：

 

Java代码  

1. <span>protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {    
2.         Assert.notNull(urlPath, "URL path must not be null");    
3.         Assert.notNull(handler, "Handler object must not be null");    
4.         Object resolvedHandler = handler;    
5.     
6.         // Eagerly resolve handler if referencing singleton via name.     
7. //如果给定的handeler是字符串，则认为是bean name，直接到IoC容器中取得bean instance     
8.         if (!this.lazyInitHandlers && handler instanceof String) {    
9.             String handlerName = (String) handler;    
10.             if (getApplicationContext().isSingleton(handlerName)) {    
11.                 resolvedHandler = getApplicationContext().getBean(handlerName);    
12.             }    
13.         }    
14.     
15.         Object mappedHandler = this.handlerMap.get(urlPath);    
16. //同一path不能对应多个处理对象     
17.         if (mappedHandler != null) {    
18.             if (mappedHandler != resolvedHandler) {    
19.                 throw new IllegalStateException(    
20.                         "Cannot map handler [" + handler + "] to URL path [" + urlPath +    
21.                         "]: There is already handler [" + resolvedHandler + "] mapped.");    
22.             }    
23.         }    
24.         else {    
25.             if (urlPath.equals("/")) {    
26.                 if (logger.isInfoEnabled()) {    
27.                     logger.info("Root mapping to handler [" + resolvedHandler + "]");    
28.                 }    
29.                 setRootHandler(resolvedHandler);    
30.             }    
31.             else if (urlPath.equals("/*")) {    
32.                 if (logger.isInfoEnabled()) {    
33.                     logger.info("Default mapping to handler [" + resolvedHandler + "]");    
34.                 }    
35.                 setDefaultHandler(resolvedHandler);    
36.             }    
37.             else {    
38. //将path和handler放在handlerMap中，保存了它们之间的映射关系     
39.                 this.handlerMap.put(urlPath, resolvedHandler);    
40.                 if (logger.isInfoEnabled()) {    
41.                     logger.info("Mapped URL path [" + urlPath + "] onto handler [" + resolvedHandler + "]");    
42.                 }    
43.             }    
44.         }    
45.     }    
46. </span>  

 

 

通过以上代码，在HandlerMapping对象被创建的时候，即完成了url到handler之间的映射关系的注册。handlerMap已经被赋值，可以被使用了。

        在完成url到handler映射关系的注册后，就可以使用getHandler方法，根据http请求获得handler对象了。下面，首先看一下getHandler方法的调用时序：

 

 

下面就主要关注一下上图中涉及到的方法的代码实现。

 

Java代码  

1. <span>public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {    
2.     Object handler = getHandlerInternal(request);    
3.                //如果没有找到匹配的handler，则使用默认handler     
4.     if (handler == null) {    
5.         handler = getDefaultHandler();    
6.     }    
7.     if (handler == null) {    
8.         return null;    
9.     }    
10.     // Bean name or resolved handler?     
11.                //如果给定的handler是字符串类型，则认为是bean name     
12.     if (handler instanceof String) {    
13.         String handlerName = (String) handler;    
14.         handler = getApplicationContext().getBean(handlerName);    
15.     }    
16.                //如果Handler是HandlerExecutionChain类型，则只是添加拦截器，否则会创建一个新的HandlerExecutionChain     
17.     return getHandlerExecutionChain(handler, request);    
18. }    
19. </span>  

 

将url信息与handler进行匹配查找的操作是在lookupHandler方法中执行的，下面就来看一下lookupHandler方法的实现：

Java代码  

1. <span>//这个方法可能的返回值是HandlerExecutionChain对象或者是null     
2. //在HandlerExecutionChain对象中的handler，是根据handlerMap中取出来的bean name获得到的bean instance     
3. protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {    
4.         // Direct match?     
5.                 //直接匹配     
6.         Object handler = this.handlerMap.get(urlPath);    
7.         if (handler != null) {    
8.             // Bean name or resolved handler?     
9.             if (handler instanceof String) {    
10.                 String handlerName = (String) handler;    
11.                                 //从IoC容器中取出handler     
12.                 handler = getApplicationContext().getBean(handlerName);    
13.             }    
14.             validateHandler(handler, request);    
15.                         //创建一个HandlerExecutionChain对象并返回     
16.             return buildPathExposingHandler(handler, urlPath, urlPath, null);    
17.         }    
18.         // Pattern match?     
19.                 //根据一定的模式匹配规则     
20.         List<String> matchingPatterns = new ArrayList<String>();    
21.         for (String registeredPattern : this.handlerMap.keySet()) {    
22.             if (getPathMatcher().match(registeredPattern, urlPath)) {    
23.                 matchingPatterns.add(registeredPattern);    
24.             }    
25.         }    
26.         String bestPatternMatch = null;    
27.         if (!matchingPatterns.isEmpty()) {    
28.             Collections.sort(matchingPatterns, getPathMatcher().getPatternComparator(urlPath));    
29.             if (logger.isDebugEnabled()) {    
30.                 logger.debug("Matching patterns for request [" + urlPath + "] are " + matchingPatterns);    
31.             }    
32.             bestPatternMatch = matchingPatterns.get(0);    
33.         }    
34.         if (bestPatternMatch != null) {    
35.                         //处理最佳匹配     
36.             handler = this.handlerMap.get(bestPatternMatch);    
37.             // Bean name or resolved handler?     
38.             if (handler instanceof String) {    
39.                 String handlerName = (String) handler;    
40.                 handler = getApplicationContext().getBean(handlerName);    
41.             }    
42.             validateHandler(handler, request);    
43.             String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestPatternMatch, urlPath);    
44.             Map<String, String> uriTemplateVariables =    
45.                     getPathMatcher().extractUriTemplateVariables(bestPatternMatch, urlPath);    
46.                         //返回一个HandlerExecutionChain对象     
47.             return buildPathExposingHandler(handler, bestPatternMatch, pathWithinMapping, uriTemplateVariables);    
48.         }    
49.         // No handler found...     
50.         return null;    
51.     }</span>  

 

最后在关注一下getHandlerInternal的代码实现

 

Java代码  

1. <span>protected Object getHandlerInternal(HttpServletRequest request) throws Exception {    
2.         String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);    
3.                 //查找符合匹配规则的handler。可能的结果是HandlerExecutionChain对象或者是null     
4.         Object handler = lookupHandler(lookupPath, request);    
5.                 //如果没有找到匹配的handler，则需要处理下default handler     
6.         if (handler == null) {    
7.             // We need to care for the default handler directly, since we need to     
8.             // expose the PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE for it as well.     
9.             Object rawHandler = null;    
10.             if ("/".equals(lookupPath)) {    
11.                 rawHandler = getRootHandler();    
12.             }    
13.             if (rawHandler == null) {    
14.                 rawHandler = getDefaultHandler();    
15.             }    
16.                         //在getRootHandler和getDefaultHandler方法中，可能持有的是bean name。     
17.             if (rawHandler != null) {    
18.                 // Bean name or resolved handler?     
19.                 if (rawHandler instanceof String) {    
20.                     String handlerName = (String) rawHandler;    
21.                     rawHandler = getApplicationContext().getBean(handlerName);    
22.                 }    
23.                 validateHandler(rawHandler, request);    
24.                 handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);    
25.             }    
26.         }    
27.                 //如果handler还是为空，则抛出错误。     
28.         if (handler != null && this.mappedInterceptors != null) {    
29.             Set<HandlerInterceptor> mappedInterceptors =    
30.                     this.mappedInterceptors.getInterceptors(lookupPath, this.pathMatcher);    
31.             if (!mappedInterceptors.isEmpty()) {    
32.                 HandlerExecutionChain chain;    
33.                 if (handler instanceof HandlerExecutionChain) {    
34.                     chain = (HandlerExecutionChain) handler;    
35.                 } else {    
36.                     chain = new HandlerExecutionChain(handler);    
37.                 }    
38.                 chain.addInterceptors(mappedInterceptors.toArray(new HandlerInterceptor[mappedInterceptors.size()]));    
39.             }    
40.         }    
41.         if (handler != null && logger.isDebugEnabled()) {    
42.             logger.debug("Mapping [" + lookupPath + "] to handler '" + handler + "'");    
43.         }    
44.         else if (handler == null && logger.isTraceEnabled()) {    
45.             logger.trace("No handler mapping found for [" + lookupPath + "]");    
46.         }    
47.         return handler;    
48.     }  </span>  

 

 

经过上述代码的处理，就可以使用getHandler方法获得到HandlerExecutionChain对象了。DispatcherServlet获得到HandlerExecutionChain对象后，便可以获得真正的handler，调用相应的Controller了。

       这篇文章主要包括两个方面的内容：HandlerMapping中url到handler映射关系的注册和根据url查找handler。第一部分是在HandlerMapping对象创建后，使用IoC容器的回调方法触发的，第二部分是在DispatchServlet中，调用getHandler方法触发的。

 

装载：http://blog.csdn.net/prince2270/article/details/5894456