基于注解的Spring MVC的URL与Controller映射关系提取的实现分析

标签： 注解 spring mvc | 发表时间：2014-01-21 18:27 | 作者：wwcx
出处：http://www.iteye.com

在Spring MVC中，定义了多种URL与Controller映射关系的描述方式。在基于注解的Spring MVC中，采用Java注解的方式描述URL与Controller之间的关系，那么Spring MVC是如何获取这些映射关系，并将其注册到handlerMap中呢？这些问题将是本文研究的重点。

      Spring MVC使用HandlerMapping接口抽象表示通过请求获取Controller的行为，在使用注解驱动的Spring MVC中，HandlerMapping的具体实现类为：DefaultAnnotationHandlerMapping，该类继承自 AbstractDetectingHandlerMapping，在AbstractDetectingHandlerMapping类中，定义了方法 detectHandlers()，这个方法的目的在于取得所有可能的Controller，并将URL与Controller的映射关系注册到 handlerMap中。首先开一下这个方法的代码实现。

[java] view plain copy
  1. //Register all handlers found in the current ApplicationContext.  
  2. protected void detectHandlers() throws BeansException {  
  3.         if (logger.isDebugEnabled()) {  
  4.             logger.debug("Looking for URL mappings in application context: " + getApplicationContext());  
  5.         }  
  6.                 //取得容器中的搜有bean  
  7.         String[] beanNames = (this.detectHandlersInAncestorContexts ?  
  8.                 BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :  
  9.                 getApplicationContext().getBeanNamesForType(Object.class));  
  10.   
  11.         // Take any bean name that we can determine URLs for.  
  12.         for (String beanName : beanNames) {  
  13.                         //取得每个bean可以处理的url  
  14.             String[] urls = determineUrlsForHandler(beanName);  
  15.             if (!ObjectUtils.isEmpty(urls)) {  
  16.                 // URL paths found: Let's consider it a handler.  
  17.                                 //注册，将url与controller的映射关系注册到handlerMap中  
  18.                 registerHandler(urls, beanName);  
  19.             }  
  20.             else {  
  21.                 if (logger.isDebugEnabled()) {  
  22.                     logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");  
  23.                 }  
  24.             }  
  25.         }  
  26.     }  

 

      在AbstractDetectingHandlerMapping中，determineUrlsForHandler(String beanName)是一个抽象方法，由具体的子类给出实现，这里我们需要关注的是DefaultAnnotationHandlerMapping类是如何实现该方法的。代码如下：

[java] view plain copy
  1. protected String[] determineUrlsForHandler(String beanName) {  
  2.         ApplicationContext context = getApplicationContext();  
  3.         Class<?> handlerType = context.getType(beanName);  
  4.                 //取得该bean类级别的RequestMapping注解  
  5.         RequestMapping mapping = context.findAnnotationOnBean(beanName, RequestMapping.class);  
  6.         if (mapping != null) {  
  7.             // @RequestMapping found at type level  
  8.             this.cachedMappings.put(handlerType, mapping);  
  9.             Set<String> urls = new LinkedHashSet<String>();  
  10.             String[] typeLevelPatterns = mapping.value();  
  11.             if (typeLevelPatterns.length > 0) {  
  12.                 // @RequestMapping specifies paths at type level  
  13.                                 //获取方法中RequestMapping中定义的URL。（RequestMapping可以定义在类上，也可以定义在方法上）  
  14.                 String[] methodLevelPatterns = determineUrlsForHandlerMethods(handlerType);  
  15.                 for (String typeLevelPattern : typeLevelPatterns) {  
  16.                     if (!typeLevelPattern.startsWith("/")) {  
  17.                         typeLevelPattern = "/" + typeLevelPattern;  
  18.                     }  
  19.                                         //将类级别定义的URL与方法级别定义的URL合并（合并规则后面再详解），合并后添加到该bean可以处理的URL集合中  
  20.                     for (String methodLevelPattern : methodLevelPatterns) {  
  21.                         String combinedPattern = getPathMatcher().combine(typeLevelPattern, methodLevelPattern);  
  22.                         addUrlsForPath(urls, combinedPattern);  
  23.                     }  
  24.                                         //将类级别定义的URL添加到该bean可以处理的URL集合中  
  25.                     addUrlsForPath(urls, typeLevelPattern);  
  26.                 }  
  27.                 return StringUtils.toStringArray(urls);  
  28.             }  
  29.             else {  
  30.                 // actual paths specified by @RequestMapping at method level  
  31.                                 //如果类级别的RequestMapping没有指定URL，则返回方法中RequestMapping定义的URL  
  32.                 return determineUrlsForHandlerMethods(handlerType);  
  33.             }  
  34.         }  
  35.         else if (AnnotationUtils.findAnnotation(handlerType, Controller.class) != null) {  
  36.             // @RequestMapping to be introspected at method level  
  37.                         //如果类级别没有定义RequestMapping，但是定义了Controller注解，将返回方法中RequestMapping定义的URL     
  38.             return determineUrlsForHandlerMethods(handlerType);  
  39.         }  
  40.         else {  
  41.                         //类级别即没有定义RequestMapping，也没有定义Controller，则返回null  
  42.             return null;  
  43.         }  
  44.     }  

 

      上述代码是Spring处理类级别的RequestMapping注解，但是RequestMapping注解也可以定义在方法级别上，determineUrlsForHandlerMethods()方法是获取该类中定义了RequestMapping注解的方法能够处理的所有 URL。下面看一下该方法的实现。

[java] view plain copy
  1. protected String[] determineUrlsForHandlerMethods(Class<?> handlerType) {  
  2.         final Set<String> urls = new LinkedHashSet<String>();  
  3.                 //类型有可能是代理类，如果是代理类，则取得它的所有接口  
  4.         Class<?>[] handlerTypes =  
  5.                 Proxy.isProxyClass(handlerType) ? handlerType.getInterfaces() : new Class<?>[]{handlerType};  
  6.         for (Class<?> currentHandlerType : handlerTypes){  
  7.                         //依次处理该类的所有方法  
  8.             ReflectionUtils.doWithMethods(currentHandlerType, new ReflectionUtils.MethodCallback() {  
  9.                 public void doWith(Method method) {  
  10.                                         //取得方法界别的RequestMapping  
  11.                     RequestMapping mapping = AnnotationUtils.findAnnotation(method, RequestMapping.class);  
  12.                     if (mapping != null) {  
  13.                                                 //获取可以处理的URL  
  14.                         String[] mappedPaths = mapping.value();  
  15.                                                 //将这些URL放入到可处理的URL集合中  
  16.                         for (String mappedPath : mappedPaths) {  
  17.                             addUrlsForPath(urls, mappedPath);  
  18.                         }  
  19.                     }  
  20.                 }  
  21.             });  
  22.         }  
  23.         return StringUtils.toStringArray(urls);  
  24.     }  

 

       分别获取了类和方法级别的RequestMapping中定义的URL后，基本上完成了URL的提取工作，但是有一种情况需要处理：类和方法中同时定义了URL，这两个URL是如何合并的呢？规则又是怎样的呢？看一下URL合并代码：

[java] view plain copy
  1. public String combine(String pattern1, String pattern2) {  
  2.         if (!StringUtils.hasText(pattern1) && !StringUtils.hasText(pattern2)) {  
  3.                         //如果两个URL都为空，那么返回空  
  4.             return "";  
  5.         }  
  6.         else if (!StringUtils.hasText(pattern1)) {  
  7.                         //如果第一个为空，返回第二个  
  8.             return pattern2;  
  9.         }  
  10.         else if (!StringUtils.hasText(pattern2)) {  
  11.                         //如果第二个为空，则返回第一个  
  12.             return pattern1;  
  13.         }  
  14.         else if (match(pattern1, pattern2)) {  
  15.                         //如果两个URL匹配，则返回第二个  
  16.             return pattern2;  
  17.         }  
  18.         else if (pattern1.endsWith("/*")) {  
  19.             if (pattern2.startsWith("/")) {  
  20.                 // /hotels/* + /booking -> /hotels/booking  
  21.                 return pattern1.substring(0, pattern1.length() - 1) + pattern2.substring(1);  
  22.             }  
  23.             else {  
  24.                 // /hotels/* + booking -> /hotels/booking  
  25.                 return pattern1.substring(0, pattern1.length() - 1) + pattern2;  
  26.             }  
  27.         }  
  28.         else if (pattern1.endsWith("/**")) {  
  29.             if (pattern2.startsWith("/")) {  
  30.                 // /hotels/** + /booking -> /hotels/**/booking  
  31.                 return pattern1 + pattern2;  
  32.             }  
  33.             else {  
  34.                 // /hotels/** + booking -> /hotels/**/booking  
  35.                 return pattern1 + "/" + pattern2;  
  36.             }  
  37.         }  
  38.         else {  
  39.             int dotPos1 = pattern1.indexOf('.');  
  40.             if (dotPos1 == -1) {  
  41.                 // simply concatenate the two patterns  
  42.                 if (pattern1.endsWith("/") || pattern2.startsWith("/")) {  
  43.                     return pattern1 + pattern2;  
  44.                 }  
  45.                 else {  
  46.                     return pattern1 + "/" + pattern2;  
  47.                 }  
  48.             }  
  49.             String fileName1 = pattern1.substring(0, dotPos1);  
  50.             String extension1 = pattern1.substring(dotPos1);  
  51.             String fileName2;  
  52.             String extension2;  
  53.             int dotPos2 = pattern2.indexOf('.');  
  54.             if (dotPos2 != -1) {  
  55.                 fileName2 = pattern2.substring(0, dotPos2);  
  56.                 extension2 = pattern2.substring(dotPos2);  
  57.             }  
  58.             else {  
  59.                 fileName2 = pattern2;  
  60.                 extension2 = "";  
  61.             }  
  62.             String fileName = fileName1.endsWith("*") ? fileName2 : fileName1;  
  63.             String extension = extension1.startsWith("*") ? extension2 : extension1;  
  64.   
  65.             return fileName + extension;  
  66.         }  
  67.     }  

 

           通过以上的处理，基本上完成了bean可以处理的URL信息的提取，在代码中有个方法经常出现：addUrlsForPath()，该方法的目的是将 RequestMapping中定义的path添加的URL集合中，如果指定PATH不是以默认的方式结尾，那么Spring将默认的结尾添加到该 path上，并将处理结果添加到url集合中。

[java] view plain copy
  1. protected void addUrlsForPath(Set<String> urls, String path) {  
  2.         urls.add(path);  
  3.         if (this.useDefaultSuffixPattern && path.indexOf('.') == -1 && !path.endsWith("/")) {  
  4.             urls.add(path + ".*");  
  5.             urls.add(path + "/");  
  6.         }  
  7.     }  


已有 0 人发表留言，猛击->> 这里<<-参与讨论


ITeye推荐



相关 [注解 spring mvc] 推荐：

spring MVC 使用注解返回json

- - ITeye博客
使用spring MVC框架时,如何使用注解返回json呢?.  注意:使用如下方式也可以把内容添加到json中. 已有 0 人发表留言，猛击->> 这里<<-参与讨论. —软件人才免语言低担保 赴美带薪读研.

Spring MVC 和 Struts2

- - CSDN博客架构设计推荐文章
Web层面的框架学习了三个Struts1和2，SpringMVC，那他们之间肯定存在一个优劣和适用的环境，Struts1和2的异同点我已经做过对比《 Struts1和Struts2》，这篇将对比下Struts2和SpringMVC的异同，下面数据基本来源于网络，本人是搜集整理所得，供大家参考. 一个项目使用什么样的技术，决定的因素很多，我所能想到的有：对系统的性能、开发的效率、团队学习的成本、业务场景等，下面尽量从这几个方面入手，来分析比较下他们之间存在的优劣.

详解Spring MVC 4常用的那些注解

- - 开源软件 - ITeye博客
Spring从2.5版本开始在编程中引入注解，用户可以使用@RequestMapping， @RequestParam， @ModelAttribute等等这样类似的注解. 到目前为止，Spring的版本虽然发生了很大的变化，但注解的特性却是一直延续下来，并不断扩展，让广大的开发人员的双手变的更轻松起来，这都离不开Annotation的强大作用，今天我们就一起来看看Spring MVC 4中常用的那些注解吧.

基于注解的 Spring MVC 简单入门

- - 行业应用 - ITeye博客
原文地址： http://www.oschina.net/question/84460_9608. 以下内容是经过自己整理资料、官方文档所得：. 加载/WEB-INF/spring-mvc/目录下的所有XML作为Spring MVC的配置文件.

Spring MVC handler method 参数绑定常用的注解

- - 开源软件 - ITeye博客
参考链接：http://csjava.blog.163.com/blog/static/1904700332012102742025948/?COLLCC=3184617125&COLLCC=1892771493&COLLCC=1691444901. 请求路径上有个id的变量值，可以通过@PathVariable来获取  @RequestMapping(value = "/page/{id}", method = RequestMethod.GET).

spring mvc +spring aop结合注解的 用户操作日志记录

- - 行业应用 - ITeye博客
参考了网上的一些 文章 但是他们写的不是很全  自己也是经过了一些摸索  可以实现 记录 spring mvc controller层操作记录. 一个关注点的模块化，这个关注点可能会横切多个对象. 事务管理是J2EE应用中一个关于横切关注点的很好的例子. AOP中，切面可以使用通用类（基于模式的风格） 或者在普通类中以 @Aspect 注解（@AspectJ风格）来实现.

Spring MVC 3 深入总结

- - 企业架构 - ITeye博客
大家好，Spring3 MVC是非常优秀的MVC框架，由其是在3.0版本发布后，现在有越来越多的团队选择了Spring3 MVC了. Spring3 MVC结构简单，应了那句话简单就是美，而且他强大不失灵活，性能也很优秀. 官方的下载网址是： http://www.springsource.org/download   （本文使用是的Spring 3.0.5版本）.

Spring MVC 与 web开发

- - 码蜂笔记
项目组用了 Spring MVC 进行开发，觉得对里面的使用方式不是很满意，就想，如果是我来搭建开发环境，我会怎么做. 下面就是我的想法，只关注于 MVC 的 View 层. 现在基本上都是用 ajax 来调用后台接口，拿到 json格式的数据再展示，有的人直接返回数据，却没有考虑异常的情况，我觉得返回的报文里必须包含表示可能的异常信息的数据和业务响应数据.

Spring MVC的常见错误

- - Java译站
10年前我开始自己的职业生涯的时候，Struts还是市场上的主流标准. 然而多年过后，我发现Spring MVC已经越来越流行了. 对我而言这并不意外，因为它能和Spring容器无缝集成，同时它还提供了灵活性及扩展性. 从我迄今为止对Spring的经验来看，我发现有不少人在配置Spring的时候经常会犯一些常见的错误.

spring mvc 异常处理（转）

- - 编程语言 - ITeye博客
链接：http://gaojiewyh.iteye.com/blog/1297746 （附源码）. 链接：http://zywang.iteye.com/blog/983801 . 链接：http://www.cnblogs.com/xguo/p/3163519.html . 链接：http://fuliang.iteye.com/blog/947191 .