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. /** Pseudo URL prefix for loading from the class path: "classpath:" */
  3. String CLASSPATH_URL_PREFIX = ResourceUtils.CLASSPATH_URL_PREFIX;
  4. Resource getResource(String location);
  5. ClassLoader getClassLoader();
  6. }

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

[java] view plain copy

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

通过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. public ResourceLoader getResourceLoader() {
  5. return this.resourceLoader;
  6. }
  7. //默认情况下
  8. public PathMatchingResourcePatternResolver() {
  9. this.resourceLoader = new DefaultResourceLoader();
  10. }

其实上面这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. return new CompoundEnumeration(tmp);
  10. }

是不是一目了然了？当前类加载器，如果存在父加载器，则向上迭代获取资源， 因此能加到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

时间： 2025-01-02 14:02:12

spring classpath & classpath*的相关文章

Spring core resourc层结构体系及JDK与Spring对classpath中资源的获取方式及结果对比

1. Spring core resourc层结构体系 1.1. Resource相关结构体系 1.2. ResourceLoader相关体系 2. JDK与Spring对classpath中资源的获取方式及结果对比

spring中classpath和classpath*的配置区别

转自:http://www.micmiu.com/j2ee/spring/spring-classpath-start/ —————————————————————————————————————————— 在使用spring时,经常会看到类似 classpth:.classpath*: 这样的前缀,不管是加载spring xml配置文件还是其配置文件中加载资源文件都会看到这两种前缀配置,其实这两种前缀是有区别的,下面将举例详细解释. [一].测试项目准备 我们以spring中加载propert

spring读取classpath目录下的配置文件通过表达式去注入属性值.txt

spring读取配置文件: 1. spring加载配置文件: <context:property-placeholder location="classpath:config/system.properties"/> 2. 配置文件内容: YTZ_SPECIAL_USER_PHONE=13912622596,18721293900,18656253360 YTZ_SPECIAL_USER_PHONE2=13912622596,18721293900,18656253360

Spring 读取classpath下的文件存到map里面

Spring配置文件: <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework

Spring 中classPath：用法

参考文章地址: http://hi.baidu.com/huahua035/item/ac8a27a994b55bad29ce9d39 http://blog.csdn.net/lushuaiyin/article/details/6880640 http://jeiofw.blog.51cto.com/3319919/934413 classpath就是代表  /WEB-INF /classes/  这个路径(如果不理解该路径,就把一个web工程发布为war包,然后用winrar查看其包内路径

Spring的classpath与classpath*通配符加载配置文件

classpath 与 classpath*以及通配符是怎么处理的 Spring加载Resource文件是通过ResourceLoader来进行的,那么我们就先来看看ResourceLoader的继承体系,让我们对这个模块有一个比较系统的认知. 首先,我们来看下ResourceLoader的源码 public interface ResourceLoader { /** Pseudo URL prefix for loading from the class path: "classpath:&

Spring将classpath下的 .properties文件数据读出放到map中,在初始化时加载

因为项目需要需要将配置文件中的键值对读出放到map中 格式为: 001=123456789 Appcontext.xml中添加配置: <bean id="loadKeyFromProperties" class="com.:landau.init.LoadKeyFormProperties"> <property name="keyFileResource"> <value>classpath:keys.pro

spring 配置资源路径时候，classpath:/，classpath:，不带前缀的区别

/** * spring 配置资源路径时候,classpath:/,classpath:,不带前缀的区别, * 其实没区别,spring 规定 "classpath:" pseudo-URL,伪url路径,在处理这种路径前缀 * 时候,会把这个伪url去掉. * @author doctor * * @time 2014年12月2日 下午6:28:12 */ public class DefaultResourceLoaderPractice { @Test public void t

classpath: spring 中的查找方式

Spring可以通过指定classpath*:与classpath:前缀加路径的方式从classpath加载文件,如bean的定义文件.classpath*:的出现是为了从多个jar文件中加载相同的文件.classpath:只能加载找到的第一个文件. 比如 resource1.jar中的package 'com.test.rs' 有一个 'jarAppcontext.xml' 文件,内容如下: <bean name="ProcessorImplA" class="com