`

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

 
阅读更多

在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中。首先开一下这个方法的代码实现。

  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类是如何实现该方法的。代码如下:

  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。下面看一下该方法的实现。

  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合并代码:

  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集合中。

  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.     }  
分享到:
评论

相关推荐

    全面掌握Spring MVC:从基础到高级的实践指南

    Spring MVC基于Model-View-Controller(MVC)架构模式,优化了Web应用程序的设计和开发。在Spring MVC中,DispatcherServlet作为前端控制器,负责请求的接收和响应结果的处理。处理器映射器(HandlerMapping)和...

    spring mvc 3.2 参考文档

    Spring Web model-view-controller (MVC)框架是围绕 DispatcherServlet 设计的,并分发请求到处理程序(handler),Spring MVC支持可配置的处理程序映射(handler mapping),视图解析(view resolution)、 区域设置...

    SpringMVC教程

    也包含新版Spring3.0,3.1 基于注解的MVC配置方法 总之绝对值得下载 学习 并以后查阅 目录 第一章 Web MVC简介.pdf 第二章 Spring MVC入门 .pdf 第三章 DispatcherServlet详解.pdf 第四章 Controller接口控制器详解...

    spring_MVC源码

    -- 启动Spring MVC的注解功能,完成请求和注解POJO的映射 --&gt; 14. &lt;bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /&gt; 15. 16. &lt;!-- 对模型视图名称的解析...

    Java之Spring Boot详解

     Spring Boot 是由 Pivotal 团队提供的全新框架,其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置,从而使开发人员不再需要定义样板化的配置。简单的来说 Spring ...

    spring 注解开发说明

    spring在2.5以后也对MVC进行了大幅度改进,现在你无须让 Controller 继承任何接口,无需在 XML 配置文件中定义请求和 Controller 的映射关系,仅仅使用注解就可以让一个 POJO 具有 Controller 的绝大部分功能。

    Java基于SSM(Spring+SpringMVC+MyBatis)作业提交与批改程序.zip

    基于java的实现MVC设计模式的请求驱动类型的轻量级Web框架,通过注解,无需实现任何接口,处理请求,支持restful。 三层结构:表现层、业务层、持久层 设计模式:Model(模型)、View(视图)、Controller(控制器) ...

    Java基于SSM(Spring+SpringMVC+MyBatis)在线个人网站.zip

    基于java的实现MVC设计模式的请求驱动类型的轻量级Web框架,通过注解,无需实现任何接口,处理请求,支持restful。 三层结构:表现层、业务层、持久层 设计模式:Model(模型)、View(视图)、Controller(控制器) ...

    Spring面试题含答案.pdf

    9. 解释对象/关系映射集成模块 10. 解释 WEB 模块 12. Spring 配置文件 13. 什么是 Spring IOC 容器? 14. IOC 的优点是什么? 15. ApplicationContext 通常的实现是什么? 16. Bean 工厂和 Application contexts ...

    Java基于SSM(Spring+SpringMVC+MyBatis)在线健身网.zip

    基于java的实现MVC设计模式的请求驱动类型的轻量级Web框架,通过注解,无需实现任何接口,处理请求,支持restful。 三层结构:表现层、业务层、持久层 设计模式:Model(模型)、View(视图)、Controller(控制器) ...

    Java基于SSM(Spring+SpringMVC+MyBatis)团员管理系统.zip

    基于java的实现MVC设计模式的请求驱动类型的轻量级Web框架,通过注解,无需实现任何接口,处理请求,支持restful。 三层结构:表现层、业务层、持久层 设计模式:Model(模型)、View(视图)、Controller(控制器) ...

    Java基于SSM(Spring+SpringMVC+MyBatis)医院收费系统.zip

    基于java的实现MVC设计模式的请求驱动类型的轻量级Web框架,通过注解,无需实现任何接口,处理请求,支持restful。 三层结构:表现层、业务层、持久层 设计模式:Model(模型)、View(视图)、Controller(控制器) ...

    Java基于SSM(Spring+SpringMVC+MyBatis)互助养老系统.zip

    基于java的实现MVC设计模式的请求驱动类型的轻量级Web框架,通过注解,无需实现任何接口,处理请求,支持restful。 三层结构:表现层、业务层、持久层 设计模式:Model(模型)、View(视图)、Controller(控制器) ...

    Java基于SSM(Spring+SpringMVC+MyBatis)新疆旅游管理系统.zip

    基于java的实现MVC设计模式的请求驱动类型的轻量级Web框架,通过注解,无需实现任何接口,处理请求,支持restful。 三层结构:表现层、业务层、持久层 设计模式:Model(模型)、View(视图)、Controller(控制器) ...

    Java基于SSM(Spring+SpringMVC+MyBatis)在线汽车交易系统.zip

    基于java的实现MVC设计模式的请求驱动类型的轻量级Web框架,通过注解,无需实现任何接口,处理请求,支持restful。 三层结构:表现层、业务层、持久层 设计模式:Model(模型)、View(视图)、Controller(控制器) ...

    Java基于SSM(Spring+SpringMVC+MyBatis)家政预约管理系统.zip

    基于java的实现MVC设计模式的请求驱动类型的轻量级Web框架,通过注解,无需实现任何接口,处理请求,支持restful。 三层结构:表现层、业务层、持久层 设计模式:Model(模型)、View(视图)、Controller(控制器) ...

    Java基于SSM(Spring+SpringMVC+MyBatis)在线物业管理系统.zip

    基于java的实现MVC设计模式的请求驱动类型的轻量级Web框架,通过注解,无需实现任何接口,处理请求,支持restful。 三层结构:表现层、业务层、持久层 设计模式:Model(模型)、View(视图)、Controller(控制器) ...

    Java基于SSM(Spring+SpringMVC+MyBatis)小说阅读网站书城.zip

    基于java的实现MVC设计模式的请求驱动类型的轻量级Web框架,通过注解,无需实现任何接口,处理请求,支持restful。 三层结构:表现层、业务层、持久层 设计模式:Model(模型)、View(视图)、Controller(控制器) ...

    Java基于SSM(Spring+SpringMVC+MyBatis)健身房众筹系统.zip

    基于java的实现MVC设计模式的请求驱动类型的轻量级Web框架,通过注解,无需实现任何接口,处理请求,支持restful。 三层结构:表现层、业务层、持久层 设计模式:Model(模型)、View(视图)、Controller(控制器) ...

    Java基于SSM(Spring+SpringMVC+MyBatis)快餐店点餐系统.zip

    基于java的实现MVC设计模式的请求驱动类型的轻量级Web框架,通过注解,无需实现任何接口,处理请求,支持restful。 三层结构:表现层、业务层、持久层 设计模式:Model(模型)、View(视图)、Controller(控制器) ...

Global site tag (gtag.js) - Google Analytics