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.

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

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

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文件。