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

classpath 与 classpath*以及通配符是怎么处理的

Spring加载Resource文件是通过ResourceLoader来进行的，那么我们就先来看看ResourceLoader的继承体系，让我们对这个模块有一个比较系统的认知。

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

    public interface ResourceLoader {  
      
        /** Pseudo URL prefix for loading from the class path: "classpath:" */  
        String CLASSPATH_URL_PREFIX = ResourceUtils.CLASSPATH_URL_PREFIX;  
          
        Resource getResource(String location);  
      
        ClassLoader getClassLoader();  
      
    }

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

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

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

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

public Resource[] getResources(String locationPattern) throws IOException {  
        Assert.notNull(locationPattern, "Location pattern must not be null");  
        //是否以classpath*开头  
        if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) {  
            //是否包含?或者*  
            if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) {  
                // a class path resource pattern  
                return findPathMatchingResources(locationPattern);  
            }  
            else {  
                // all class path resources with the given name  
                return findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()));  
            }  
        }  
        else {  
            // Only look for a pattern after a prefix here  
            // (to not get fooled by a pattern symbol in a strange prefix).  
            int prefixEnd = locationPattern.indexOf(":") + 1;  
            //是否包含?或者*  
            if (getPathMatcher().isPattern(locationPattern.substring(prefixEnd))) {  
                // a file pattern  
                return findPathMatchingResources(locationPattern);  
            }  
            else {  
                // a single resource with the given name  
                return new Resource[] {getResourceLoader().getResource(locationPattern)};  
            }  
        }  
    }

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

处理的流程图如下：

其实很简单

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

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

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

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

好了，说了这么多，看下面的例子：

classpath:spring-servlet.xml

说明：无通配符，必须完全匹配

classpath:spring-servlet？.xml

说明：匹配一个字符，例如 spring-servlet1.xml 、 spring-servlet2.xml

classpath:config/*/spring-servlet.xml

说明：匹配零个或多个字符串（只针对名称，不匹配目录分隔符等），例如：config/a/spring-servlet.xml 、 user/b/spring-servlet.xml ，但是不匹配 user/spring-servlet.xml

classpath:config/**/spring-servlet.xml

说明：匹配路径中的零个或多个目录，例如：config/a/ab/abc/spring-servlet.xml，同时也能匹配 config/spring-servlet.xml

classpath:**/*.xml

说明：表示在所有的类路径中查找和加载文件名以“.xml”结尾的配置文件，但重复的文件名只加载其中一个，视加载顺序决定

classpath*:config/**/*.xml

classpath*:**/*.xml

说明：“classpath*:”表示加载多个资源文件，即使重名也会被加载，j包括jar包里的重复的xml文件。