spring classpath & classpath*

classpath-找到系统类路径下的第一个匹配的配置文件

classpath*-找到系统类路径下的所有符合要求的配置文件

参考资料：http://www.micmiu.com/j2ee/spring/spring-classpath-start/

       <!-- myBatis配置.
            classpath和classpath*的区别，参考文档：http://blog.csdn.net/zl3450341/article/details/9306983.
            classpath只会返回第一个匹配的资源，建议确定路径的单个文档使用classpath；匹配多个文档时使用classpath*.
       -->
       <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"
             p:dataSource-ref="dataSource"
             p:configLocation="classpath:mybatis.xml"
             p:mapperLocations="classpath*:com/*Mapper.xml" />

 

 

 

 本篇文章是由朋友的一篇博客引出的，博客原文地址：http://jinnianshilongnian.iteye.com/blog/1416322

    他这篇博客比较细的讲解了classpath与classpath*，以及通配符的使用，那些配置能成功加载到资源，那些配置加载不了资源。但是我相信仍然有很多同学不明白，为什么是这样的，知其然，不知其所以然，那么本篇文章将慢慢为你揭开神秘的面纱，让你知其然，更知其所以然。

 

    关于Spring Resource的资源类型以及继承体系我们已经在上一篇文件粗略的说了一下。Spring加载Resource文件是通过ResourceLoader来进行的，那么我们就先来看看ResourceLoader的继承体系，让我们对这个模块有一个比较系统的认知。

上图仅右边的继承体系，仅画至AbstractApplicationContext，由于ApplicationContext的继承体系，我们已经在前面章节给出，所以为了避免不必要的复杂性，本章继承体系就不引入ApplicationContext。

  

 

 

我们还是来关注本章的重点————classpath 与 classpath*以及通配符是怎么处理的

 

首先，我们来看下ResourceLoader的源码

 

[java] view plain copy

 

  1. public interface ResourceLoader {  
  2.   
  3.     /** Pseudo URL prefix for loading from the class path: "classpath:" */  
  4.     String CLASSPATH_URL_PREFIX = ResourceUtils.CLASSPATH_URL_PREFIX;  
  5.       
  6.     Resource getResource(String location);  
  7.   
  8.     ClassLoader getClassLoader();  
  9.   
  10. }  

我们发现，其实ResourceLoader接口只提供了classpath前缀的支持。而classpath*的前缀支持是在它的子接口ResourcePatternResolver中。

 

 

[java] view plain copy

 

  1. public interface ResourcePatternResolver extends ResourceLoader {  
  2.   
  3.     /** 
  4.      * Pseudo URL prefix for all matching resources from the class path: "classpath*:" 
  5.      * This differs from ResourceLoader's classpath URL prefix in that it 
  6.      * retrieves all matching resources for a given name (e.g. "/beans.xml"), 
  7.      * for example in the root of all deployed JAR files. 
  8.      * @see org.springframework.core.io.ResourceLoader#CLASSPATH_URL_PREFIX 
  9.      */  
  10.     String CLASSPATH_ALL_URL_PREFIX = "classpath*:";  
  11.   
  12.       
  13.     Resource[] getResources(String locationPattern) throws IOException;  
  14.   
  15. }  

   通过2个接口的源码对比，我们发现ResourceLoader提供 classpath下单资源文件的载入，而ResourcePatternResolver提供了多资源文件的载入。

 

  ResourcePatternResolver有一个实现类：PathMatchingResourcePatternResolver，那我们直奔主题，查看PathMatchingResourcePatternResolver的getResources()

 

[java] view plain copy

 

  1. public Resource[] getResources(String locationPattern) throws IOException {  
  2.         Assert.notNull(locationPattern, "Location pattern must not be null");  
  3.         //是否以classpath*开头  
  4.         if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) {  
  5.             //是否包含?或者*  
  6.             if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) {  
  7.                 // a class path resource pattern  
  8.                 return findPathMatchingResources(locationPattern);  
  9.             }  
  10.             else {  
  11.                 // all class path resources with the given name  
  12.                 return findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()));  
  13.             }  
  14.         }  
  15.         else {  
  16.             // Only look for a pattern after a prefix here  
  17.             // (to not get fooled by a pattern symbol in a strange prefix).  
  18.             int prefixEnd = locationPattern.indexOf(":") + 1;  
  19.             //是否包含?或者*  
  20.             if (getPathMatcher().isPattern(locationPattern.substring(prefixEnd))) {  
  21.                 // a file pattern  
  22.                 return findPathMatchingResources(locationPattern);  
  23.             }  
  24.             else {  
  25.                 // a single resource with the given name  
  26.                 return new Resource[] {getResourceLoader().getResource(locationPattern)};  
  27.             }  
  28.         }  
  29.     }  

由此我们可以看出在加载配置文件时，以是否是以classpath*开头分为2大类处理场景，每大类在又根据路径中是否包括通配符分为2小类进行处理，

 

处理的流程图如下：

从上图看，整个加载资源的场景有三条处理流程

 

  • 以classpath*开头，但路径不包含通配符的

             让我们来看看findAllClassPathResources是怎么处理的

[java] view plain copy

 

  1. protected Resource[] findAllClassPathResources(String location) throws IOException {  
  2.     String path = location;  
  3.     if (path.startsWith("/")) {  
  4.         path = path.substring(1);  
  5.     }  
  6.     Enumeration<URL> resourceUrls = getClassLoader().getResources(path);  
  7.     Set<Resource> result = new LinkedHashSet<Resource>(16);  
  8.     while (resourceUrls.hasMoreElements()) {  
  9.         URL url = resourceUrls.nextElement();  
  10.         result.add(convertClassLoaderURL(url));  
  11.     }  
  12.     return result.toArray(new Resource[result.size()]);  
  13. }  

    我们可以看到，最关键的一句代码是：Enumeration<URL> resourceUrls = getClassLoader().getResources(path); 

[java] view plain copy

 

  1.     public ClassLoader getClassLoader() {  
  2.         return getResourceLoader().getClassLoader();  
  3.     }  
  4.   
  5.   
  6. public ResourceLoader getResourceLoader() {  
  7.         return this.resourceLoader;  
  8.     }  
  9.   
  10. //默认情况下  
  11. public PathMatchingResourcePatternResolver() {  
  12.         this.resourceLoader = new DefaultResourceLoader();  
  13.     }  

其实上面这3个方法不是最关键的，之所以贴出来，是让大家清楚整个调用链，其实这种情况最关键的代码在于ClassLoader的getResources()方法。那么我们同样跟进去，看看源码

[java] view plain copy

 

  1. public Enumeration<URL> getResources(String name) throws IOException {  
  2. Enumeration[] tmp = new Enumeration[2];  
  3. if (parent != null) {  
  4.     tmp[0] = parent.getResources(name);  
  5. } else {  
  6.     tmp[0] = getBootstrapResources(name);  
  7. }  
  8. tmp[1] = findResources(name);  
  9.   
  10. return new CompoundEnumeration(tmp);  
  11.    }  

是不是一目了然了？当前类加载器，如果存在父加载器，则向上迭代获取资源， 因此能加到jar包里面的资源文件。

  • 不以classpath*开头，且路径不包含通配符的

处理逻辑如下           

[java] view plain copy

 

  1. return new Resource[] {getResourceLoader().getResource(locationPattern)};  

上面我们已经贴过getResourceLoader()的逻辑了， 即默认是DefaultResourceLoader()，那我们进去看看getResouce()的实现

[java] view plain copy

 

  1. public Resource getResource(String location) {  
  2.     Assert.notNull(location, "Location must not be null");  
  3.     if (location.startsWith(CLASSPATH_URL_PREFIX)) {  
  4.         return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());  
  5.     }  
  6.     else {  
  7.         try {  
  8.             // Try to parse the location as a URL...  
  9.             URL url = new URL(location);  
  10.             return new UrlResource(url);  
  11.         }  
  12.         catch (MalformedURLException ex) {  
  13.             // No URL -> resolve as resource path.  
  14.             return getResourceByPath(location);  
  15.         }  
  16.     }  
  17. }  

其实很简单，如果以classpath开头，则创建为一个ClassPathResource，否则则试图以URL的方式加载资源，创建一个UrlResource.

  • 路径包含通配符的

             这种情况是最复杂的，涉及到层层递归，那我把加了注释的代码发出来大家看一下，其实主要的思想就是

1.先获取目录，加载目录里面的所有资源

2.在所有资源里面进行查找匹配，找出我们需要的资源

[java] view plain copy

 

  1. protected Resource[] findPathMatchingResources(String locationPattern) throws IOException {  
  2.         //拿到能确定的目录，即拿到不包括通配符的能确定的路径  比如classpath*:/aaa/bbb/spring-*.xml 则返回classpath*:/aaa/bbb/                                     //如果是classpath*:/aaa/*/spring-*.xml，则返回 classpath*:/aaa/  
  3.         String rootDirPath = determineRootDir(locationPattern);  
  4.         //得到spring-*.xml  
  5.         String subPattern = locationPattern.substring(rootDirPath.length());  
  6.         //递归加载所有的根目录资源，要注意的是递归的时候又得考虑classpath,与classpath*的情况，而且还得考虑根路径中是否又包含通配符，参考上面那张流程图  
  7.         Resource[] rootDirResources = getResources(rootDirPath);  
  8.         Set<Resource> result = new LinkedHashSet<Resource>(16);  
  9.         //将根目录所有资源中所有匹配我们需要的资源(如spring-*)加载result中  
  10.         for (Resource rootDirResource : rootDirResources) {  
  11.             rootDirResource = resolveRootDirResource(rootDirResource);  
  12.             if (isJarResource(rootDirResource)) {  
  13.                 result.addAll(doFindPathMatchingJarResources(rootDirResource, subPattern));  
  14.             }  
  15.             else if (rootDirResource.getURL().getProtocol().startsWith(ResourceUtils.URL_PROTOCOL_VFS)) {  
  16.                 result.addAll(VfsResourceMatchingDelegate.findMatchingResources(rootDirResource, subPattern, getPathMatcher()));  
  17.             }  
  18.             else {  
  19.                 result.addAll(doFindPathMatchingFileResources(rootDirResource, subPattern));  
  20.             }  
  21.         }  
  22.         if (logger.isDebugEnabled()) {  
  23.             logger.debug("Resolved location pattern [" + locationPattern + "] to resources " + result);  
  24.         }  
  25.         return result.toArray(new Resource[result.size()]);  
  26.     }  

 

值得注解一下的是determineRootDir()方法的作用，是确定根目录，这个根目录必须是一个能确定的路径，不会包含通配符。如果classpath*:aa/bb*/spring-*.xml，得到的将是classpath*:aa/  可以看下他的源码

 

[java] view plain copy

 

  1. protected String determineRootDir(String location) {  
  2.     int prefixEnd = location.indexOf(":") + 1;  
  3.     int rootDirEnd = location.length();  
  4.     while (rootDirEnd > prefixEnd && getPathMatcher().isPattern(location.substring(prefixEnd, rootDirEnd))) {  
  5.         rootDirEnd = location.lastIndexOf('/', rootDirEnd - 2) + 1;  
  6.     }  
  7.     if (rootDirEnd == 0) {  
  8.         rootDirEnd = prefixEnd;  
  9.     }  
  10.     return location.substring(0, rootDirEnd);  
  11. }  

 

分析到这，结合测试我们可以总结一下：

1.无论是classpath还是classpath*都可以加载整个classpath下（包括jar包里面）的资源文件。

2.classpath只会返回第一个匹配的资源，查找路径是优先在项目中存在资源文件，再查找jar包。

3.文件名字包含通配符资源(如果spring-*.xml，spring*.xml)，   如果根目录为""， classpath加载不到任何资源， 而classpath*则可以加载到classpath中可以匹配的目录中的资源，但是不能加载到jar包中的资源

    

      第1，2点比较好表理解，大家可以自行测试，第三点表述有点绕，举个例，现在有资源文件结构如下：

 

classpath:notice*.txt                                                               加载不到资源

classpath*:notice*.txt                                                            加载到resource根目录下notice.txt

classpath:META-INF/notice*.txt                                          加载到META-INF下的一个资源（classpath是加载到匹配的第一个资源，就算删除classpath下的notice.txt，他仍然可以                                                                                                  加载jar包中的notice.txt）

classpath:META-*/notice*.txt                                              加载不到任何资源

classpath*:META-INF/notice*.txt                                        加载到classpath以及所有jar包中META-INF目录下以notice开头的txt文件

classpath*:META-*/notice*.txt                                             只能加载到classpath下 META-INF目录的notice.txt

 

大家感觉一下吧

http://blog.csdn.net/zl3450341/article/details/9306983

 

时间： 2024-09-20 10:52:21

spring classpath & classpath*的相关文章

远哥跟你说 Spring的 classpath 通配符加载配置文件

  classpath:app-Beans.xml 说明:无通配符,必须完全匹配   classpath:App?-Beans.xml 说明:匹配一个字符,例如 App1-Beans.xml . App2-Beans.xml   classpath:user/*/Base-Beans.xml 说明:匹配零个或多个字符串(只针对名称,不匹配目录分隔符等),例如:user/a/Base-Beans.xml . user/b/Base-Beans.xml ,但是不匹配 user/Base-Beans.

将某一目录下所有的jar文件都加入到CLASSPATH当中的简便写法

将某一目录下所有的jar文件都加入到CLASSPATH当中的简便写法 引用: http://www.javaeye.com/topic/244?page=2 中将某一目录下所有的jar文件都加入到CLASSPATH的写法,比较长:)   Quake Wang 写道 代码 FOR %%i IN ("%HIBERN8IDE%/*.jar") DO CALL "setclasspath.bat" %%i      setclasspath.bat: 代码 SET _CLA

java classpath 批量设置脚本

    linux bash:     YOUR_LIB=your_path     for jar in `ls $YOUR_LIB/*.jar`     do     CLASSPATH="$CLASSPATH:""$jar"     done     windows :     SETLOCAL ENABLEDELAYEDEXPANSION     set LIB=xx     set CLASSPATH=.     FOR %%C IN (LIB*.jar)

分析Java的类加载器与ClassLoader（二）：classpath与查找类字节码的顺序，分析ExtClassLoader与AppClassLoader的源码

先回顾一下classpath classpath的作用:         classpath的作用是指定查找类的路径:当使用java命令执行一个类(类中的main方法)时,会从classpath中进行查找这个类.  指定classpath的方式一:         设置环境变量CLASSPATH,多个路径之间使用英文的分号隔开,也可以指定为jar包路径.          示例:CLASSPATH=c:/myclasses/;c/mylib/aa.jar;c:/mylib/bb.jar;.  

java中path和classpath

Path 路径,是java编译时需要调用的程序(如java,javac等)所在的地方; CLASSPATH的作用是指定查找类的路径:当使用java命令执行一个类(类中的main方法)时,会从classpath中进行查找当前运行class所依赖的其它class文件.,即CLASSPATH ->到哪里找需要执行的.class文件(程序依赖外面Jar,再细一点讲是依赖jar里面的class). Path1. PATH命令可用来设置可执行文件(仅包括:.COM..EXE及.BAT文件)的搜索路径.当您运

Ant详解之-path、classpath和fileset

转自:http://www.cnblogs.com/itech/archive/2011/11/01/2231206.html   一 .<path/> 和 <classpath/> 你可以用":"和";"作为分隔符,指定类似PATH和CLASSPATH的引用.Ant会把分隔符转换为当前系统所用的分隔符.  当需要指定类似路径的值时,可以使用嵌套元素.一般的形式是 <classpath> <pathelement path=

Spring 环境下开发部署RUKU v1.0的过程

通过之前的博文,我们已经验证,Spring环境下完成access数据访问没有问题.下面我们直接在Spring环境下部署我们的升级项目. 1.导入Spring Boot Spring Boot是Spring的子项目,用来解决项目配置复杂性的问题,降低Spring的使用门槛使得开发人员专注于核心业务,而基础设施建设交给Spring Boot. 正如教材所言,使用eclipse构建一个基于maven的web项目,需要在POM中引入spring-mvc spring-webmvc jackson tom

Spring+SpringMVC+MongoDB案例

---------------------------------------------------------------------------------------------[版权申明:本文系作者原创,转载请注明出处] 文章出处:http://blog.csdn.net/sdksdk0/article/details/64948728作者:朱培      ID:sdksdk0     --------------------------------------------------

Spring Test：Spring Test 4 整合 JUnit 4 使用

因为近期在开发没有界面,只有接口的.项目架构如下 SpringMVC + Mybatis 一般来说只要测试Service层即可. 一.所需Jar JUnit 4 Spring Test Spring 相关其他依赖包 二.写测试案例 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 package com.xidian.wq.imaopay.controller.webserv