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

[java] view plain copy print ?

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.     }  

//Register all handlers found in the current ApplicationContext. protected void detectHandlers() throws BeansException { if (logger.isDebugEnabled()) { logger.debug("Looking for URL mappings in application context: " + getApplicationContext()); } //取得容器中的搜有bean 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) { //取得每个bean可以处理的url String[] urls = determineUrlsForHandler(beanName); if (!ObjectUtils.isEmpty(urls)) { // URL paths found: Let's consider it a handler. //注册，将url与controller的映射关系注册到handlerMap中 registerHandler(urls, beanName); } else { if (logger.isDebugEnabled()) { logger.debug("Rejected bean name '" + beanName + "': no URL paths identified"); } } } }

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

[java] view plain copy print ?

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.     }  

protected String[] determineUrlsForHandler(String beanName) { ApplicationContext context = getApplicationContext(); Class<?> handlerType = context.getType(beanName); //取得该bean类级别的RequestMapping注解 RequestMapping mapping = context.findAnnotationOnBean(beanName, RequestMapping.class); if (mapping != null) { // @RequestMapping found at type level this.cachedMappings.put(handlerType, mapping); Set<String> urls = new LinkedHashSet<String>(); String[] typeLevelPatterns = mapping.value(); if (typeLevelPatterns.length > 0) { // @RequestMapping specifies paths at type level //获取方法中RequestMapping中定义的URL。（RequestMapping可以定义在类上，也可以定义在方法上） String[] methodLevelPatterns = determineUrlsForHandlerMethods(handlerType); for (String typeLevelPattern : typeLevelPatterns) { if (!typeLevelPattern.startsWith("/")) { typeLevelPattern = "/" + typeLevelPattern; } //将类级别定义的URL与方法级别定义的URL合并（合并规则后面再详解），合并后添加到该bean可以处理的URL集合中 for (String methodLevelPattern : methodLevelPatterns) { String combinedPattern = getPathMatcher().combine(typeLevelPattern, methodLevelPattern); addUrlsForPath(urls, combinedPattern); } //将类级别定义的URL添加到该bean可以处理的URL集合中 addUrlsForPath(urls, typeLevelPattern); } return StringUtils.toStringArray(urls); } else { // actual paths specified by @RequestMapping at method level //如果类级别的RequestMapping没有指定URL，则返回方法中RequestMapping定义的URL return determineUrlsForHandlerMethods(handlerType); } } else if (AnnotationUtils.findAnnotation(handlerType, Controller.class) != null) { // @RequestMapping to be introspected at method level //如果类级别没有定义RequestMapping，但是定义了Controller注解，将返回方法中RequestMapping定义的URL return determineUrlsForHandlerMethods(handlerType); } else { //类级别即没有定义RequestMapping，也没有定义Controller，则返回null return null; } }

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

[java] view plain copy print ?

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.     }  

protected String[] determineUrlsForHandlerMethods(Class<?> handlerType) { final Set<String> urls = new LinkedHashSet<String>(); //类型有可能是代理类，如果是代理类，则取得它的所有接口 Class<?>[] handlerTypes = Proxy.isProxyClass(handlerType) ? handlerType.getInterfaces() : new Class<?>[]{handlerType}; for (Class<?> currentHandlerType : handlerTypes){ //依次处理该类的所有方法 ReflectionUtils.doWithMethods(currentHandlerType, new ReflectionUtils.MethodCallback() { public void doWith(Method method) { //取得方法界别的RequestMapping RequestMapping mapping = AnnotationUtils.findAnnotation(method, RequestMapping.class); if (mapping != null) { //获取可以处理的URL String[] mappedPaths = mapping.value(); //将这些URL放入到可处理的URL集合中 for (String mappedPath : mappedPaths) { addUrlsForPath(urls, mappedPath); } } } }); } return StringUtils.toStringArray(urls); }

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

[java] view plain copy print ?

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.     }  

public String combine(String pattern1, String pattern2) { if (!StringUtils.hasText(pattern1) && !StringUtils.hasText(pattern2)) { //如果两个URL都为空，那么返回空 return ""; } else if (!StringUtils.hasText(pattern1)) { //如果第一个为空，返回第二个 return pattern2; } else if (!StringUtils.hasText(pattern2)) { //如果第二个为空，则返回第一个 return pattern1; } else if (match(pattern1, pattern2)) { //如果两个URL匹配，则返回第二个 return pattern2; } else if (pattern1.endsWith("/*")) { if (pattern2.startsWith("/")) { // /hotels/* + /booking -> /hotels/booking return pattern1.substring(0, pattern1.length() - 1) + pattern2.substring(1); } else { // /hotels/* + booking -> /hotels/booking return pattern1.substring(0, pattern1.length() - 1) + pattern2; } } else if (pattern1.endsWith("/**")) { if (pattern2.startsWith("/")) { // /hotels/** + /booking -> /hotels/**/booking return pattern1 + pattern2; } else { // /hotels/** + booking -> /hotels/**/booking return pattern1 + "/" + pattern2; } } else { int dotPos1 = pattern1.indexOf('.'); if (dotPos1 == -1) { // simply concatenate the two patterns if (pattern1.endsWith("/") || pattern2.startsWith("/")) { return pattern1 + pattern2; } else { return pattern1 + "/" + pattern2; } } String fileName1 = pattern1.substring(0, dotPos1); String extension1 = pattern1.substring(dotPos1); String fileName2; String extension2; int dotPos2 = pattern2.indexOf('.'); if (dotPos2 != -1) { fileName2 = pattern2.substring(0, dotPos2); extension2 = pattern2.substring(dotPos2); } else { fileName2 = pattern2; extension2 = ""; } String fileName = fileName1.endsWith("*") ? fileName2 : fileName1; String extension = extension1.startsWith("*") ? extension2 : extension1; return fileName + extension; } }

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

[java] view plain copy print ?

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.     }