9.Spring之Resource（2）

柔情只为你懂 2021-09-29 02:08 213阅读 0赞

### ResourceLoader接口 ###

ResourceLoader接口用于返回Resource对象；其实现可以看作是一个生产Resource的工厂类。

public interface ResourceLoader {
        Resource getResource(String location);
        ClassLoader getClassLoader();
    }

getResource接口用于根据提供的location参数返回相应的Resource对象；而getClassLoader则返回加载这些Resource的ClassLoader。

Spring提供了一个适用于所有环境的DefaultResourceLoader实现，可以返回ClassPathResource、UrlResource；还提供一个用于web环境的ServletContextResourceLoader，它继承了DefaultResourceLoader的所有功能，又额外提供了获取ServletContextResource的支持。

ResourceLoader在进行加载资源时需要使用前缀来指定需要加载：“classpath:path”表示返回ClasspathResource，“http://path”和“file:path”表示返回UrlResource资源，如果不加前缀则需要根据当前上下文来决定，DefaultResourceLoader默认实现可以加载classpath资源，看个例子：

@Test
    public void testResourceLoad() {
        ResourceLoader loader = new DefaultResourceLoader();
        Resource resource = loader.getResource("classpath:com/spring/res/test1.txt");
        //验证返回的是ClassPathResource
        assertEquals(ClassPathResource.class, resource.getClass());
        
        Resource resource2 = loader.getResource("file:com/spring/res/test1.txt");
        //验证返回的是ClassPathResource
        assertEquals(FileUrlResource.class, resource2.getClass());
        
        Resource resource3 = loader.getResource("com/spring/res/test1.txt");
        //验证返默认可以加载ClasspathResource
        assertTrue(resource3 instanceof ClassPathResource);
        
    }

对于目前所有ApplicationContext都实现了ResourceLoader，因此可以使用其来加载资源。

ClassPathXmlApplicationContext：不指定前缀将返回默认的ClassPathResource资源，否则将根据前缀来加载资源；

FileSystemXmlApplicationContext：不指定前缀将返回FileSystemResource，否则将根据前缀来加载资源；

WebApplicationContext：不指定前缀将返回ServletContextResource，否则将根据前缀来加载资源；

其他：不指定前缀根据当前上下文返回Resource实现，否则将根据前缀来加载资源。

### ResourceLoaderAware接口 ###

ResourceLoaderAware是一个标记接口，用于通过ApplicationContext上下文注入ResourceLoader。

public interface ResourceLoaderAware {
        void setResourceLoader(ResourceLoader resourceLoader);
    }

让我们看下测试代码吧：

1） 首先准备测试Bean，我们的测试Bean还简单只需实现ResourceLoaderAware接口，然后通过回调将ResourceLoader保存下来就可以了：

public class ResourceBean implements ResourceLoaderAware {
        
        private ResourceLoader resourceLoader;
        
        @Override
        public void setResourceLoader(ResourceLoader resourceLoader) {
            this.resourceLoader = resourceLoader;
        }
        
        public ResourceLoader getResourceLoader() {
            return resourceLoader;
        }
    }

2） 配置Bean定义：

3）测试

@Test
    public void test() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("res/resourceLoaderAware.xml");
        ResourceBean resourceBean = ctx.getBean(ResourceBean.class);
        ResourceLoader loader = resourceBean.getResourceLoader();
        Assert.assertTrue(loader instanceof ApplicationContext);
    
        ResourceBean2 resourceBean2 = ctx.getBean(ResourceBean2.class);
        Assert.assertTrue(resourceBean2.getResourceLoader() instanceof ApplicationContext);
    }

注意此处“loader instanceof ApplicationContext”，说明了ApplicationContext就是个ResoureLoader。

由于上述实现回调接口注入ResourceLoader的方式属于侵入式，所以不推荐上述方法，可以采用更好的自动注入方式，如“byType”和“constructor”

### 注入Resource ###

通过回调或注入方式注入“ResourceLoader”，然后再通过“ResourceLoader”再来加载需要的资源对于只需要加载某个固定的资源是不是很麻烦，有没有更好的方法类似于前边实例中注入“java.io.File”类似方式呢？

Spring提供了一个PropertyEditor “ResourceEditor”用于在注入的字符串和Resource之间进行转换。因此可以使用注入方式注入Resource。

ResourceEditor完全使用ApplicationContext根据注入的路径字符串获取相应的Resource，说白了还是自己做还是容器帮你做的问题。

接下让我们看下示例：

1）准备Bean：

public class ResourceBean3 {
        
        private Resource resource;
        
        public Resource getResource() {
            return resource;
        }
        public void setResource(Resource resource) {
            this.resource = resource;
        }
    }

2）准备配置文件

注意此处“resourceBean1”注入的路径没有前缀表示根据使用的ApplicationContext实现进行选择Resource实现。

### 注入Resource数组 ###

Spring还支持注入Resource数组，直接看配置如下：

<bean id="resourceBean1" class="com.spring.res.ResourceBean4">
        <property name="resources">
            <array>
              <value>test1.properties</value>
              <value>log4j.xml</value>
            </array>
        </property>
    </bean>
    <bean id="resourceBean2" class="com.spring.res.ResourceBean4">
        <property name="resources" value="classpath*:META-INF/INDEX.LIST"/>
    </bean>
    <bean id="resourceBean3" class="com.spring.res.ResourceBean4">
        <property name="resources">
            <array>
              <value>test1.properties</value>
              <value>classpath*:META-INF/INDEX.LIST</value>
            </array>
        </property>
    </bean>

### 使用路径通配符加载Resource ###

前面介绍的资源路径都是非常简单的一个路径匹配一个资源，Spring还提供了一种更强大的Ant模式通配符匹配，从能一个路径匹配一批资源。Spring提供AntPathMatcher来进行Ant风格的路径匹配。

Ant路径通配符支持“？”、“”、“\*”，注意通配符匹配不包括目录分隔符“/”：

“?”：匹配一个字符，如“config?.xml”将匹配“config1.xml”；

“\*”：匹配零个或多个字符串，如“cn/\*/config.xml”将匹配“cn/javass/config.xml”，但不匹配“cn/config.xml”；而“cn/config-\*.xml”将匹配“cn/config-dao.xml”；

“”：匹配路径中的零个或多个目录，如“cn//config.xml”将匹配“cn /config.xml”，也匹配“cn/javass/spring/config.xml”；而“cn/javass/config-.xml”将匹配“cn/javass/config-dao.xml”，即把“”当做两个“\*”处理。

Spring在加载类路径资源时除了提供前缀“classpath:”来支持加载一个Resource，还提供一个前缀“classpath\*:”来支持加载所有匹配的类路径Resource。

Spring提供了ResourcePatternResolver接口来加载多个Resource，该接口继承了ResourceLoader并添加了“Resource\[\] getResources(String locationPattern)”方法用来加载多个Resource：

public interface ResourcePatternResolver extends ResourceLoader {
        String CLASSPATH_ALL_URL_PREFIX = "classpath*:";
        Resource[] getResources(String var1) throws IOException;
    }

Spring提供了一个ResourcePatternResolver实现类——PathMatchingResourcePatternResolver，它是基于模式匹配的，默认使用AntPathMatcher进行路径匹配，它除了支持ResourceLoader支持的前缀外，还额外支持“classpath\*:”用于加载所有匹配的类路径Resource。

首先做下准备工作，在项目的“resources”创建“META-INF”目录，然后在其下创建一个“INDEX.LIST”文件。

一、“classpath”： 用于加载类路径（包括jar包）中的一个且仅一个资源；对于多个匹配的也只返回一个，所以如果需要多个匹配的请考虑“classpath\*:”前缀；

@Test
        public void testClasspathPrefix() throws IOException {
            ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            
            //只加载一个绝对匹配Resource，且通过ResourceLoader.getResource进行加载
            Resource[] resources = resolver.getResources("classpath:META-INF/INDEX.LIST");
            assertEquals(1, resources.length);
    
            //只加载一个匹配的Resource，且通过ResourceLoader.getResource进行加载
            resources = resolver.getResources("classpath:META-INF/*.LIST");
            System.out.println(resources.length);
    
            //只加载一个绝对匹配Resource，且通过ResourceLoader.getResource进行加载
            resources = resolver.getResources("classpath:META-INF/MANIFEST.MF");
            assertEquals(1, resources.length);
        }

二、“classpath\*”： 用于加载类路径（包括jar包）中的所有匹配的资源。带通配符的classpath使用“ClassLoader”的“<> ( name)”方法来查找通配符之前的资源，然后通过模式匹配来获取匹配的资源。如“classpath:META-INF/\*.LIST”将首先加载通配符之前的目录“META-INF”，然后再遍历路径进行子路径匹配从而获取匹配的资源。

@Test
    public void testClasspathAsteriskPrefix() throws IOException {
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        
        //将加载多个绝对匹配的所有Resource
        //将首先通过ClassLoader.getResources("META-INF")加载非模式路径部分
        //然后进行遍历模式匹配
        Resource[] resources = resolver.getResources("classpath*:META-INF/INDEX.LIST");
        assertTrue(resources.length > 1);
        
        //将加载多个模式匹配的Resource
        resources = resolver.getResources("classpath*:META-INF/*.LIST");
        assertTrue(resources.length > 1);
    
    }

三、“file”：加载一个或多个文件系统中的Resource。如“file:D:/\*.txt”将返回D盘下的所有txt文件；

四、无前缀：通过ResourceLoader实现加载一个资源。

AppliacationContext提供的getResources方法将获取资源委托给ResourcePatternResolver实现，默认使用PathMatchingResourcePatternResolver。

### AppliacationContext实现对各种Resource的支持 ###

一、ClassPathXmlApplicationContext：默认将通过classpath进行加载返回ClassPathResource，提供两类构造器方法：

//1通过ResourcePatternResolver实现根据configLocation获取资源

public ClassPathXmlApplicationContext(String configLocation);

public ClassPathXmlApplicationContext(String... configLocations)；

public ClassPathXmlApplicationContext(String\[\] configLocations, ……);

//2）通过直接根据path直接返回ClasspathResource

public ClassPathXmlApplicationContext(String path, Class clazz);

public ClassPathXmlApplicationContext(String\[\] paths, Class clazz);

public ClassPathXmlApplicationContext(String\[\] paths, Class clazz, ……);

第一类构造器是根据提供的配置文件路径使用“ResourcePatternResolver”的“getResources()”接口通过匹配获取资源；即如“classpath:config.xml”第二类构造器则是根据提供的路径和clazz来构造ClassResource资源。即采用“public ClassPathResource(String path, Class<?> clazz)”构造器获取资源。

二、FileSystemXmlApplicationContext：将加载相对于当前工作目录的“configLocation”位置的资源，注意在linux系统上不管“configLocation”是否带“/”，都作为相对路径；而在window系统上如“D:/resourceInject.xml”是绝对路径。因此在除非很必要的情况下，不建议使用该

ApplicationContext。

public class FileSystemXmlApplicationContext\{

public FileSystemXmlApplicationContext(String configLocation);

public FileSystemXmlApplicationContext(String... configLocations,……);

//linux系统，以下全是相对于当前vm路径进行加载

new FileSystemXmlApplicationContext("res/config.xml");

new FileSystemXmlApplicationContext("/res/confg.xml");

//windows系统，第一个将相对于当前vm路径进行加载；

//第二个则是绝对路径方式加载

new FileSystemXmlApplicationContext("res/config.xml");

new FileSystemXmlApplicationContext("d:/res/confg.xml");

此处还需要注意：在linux系统上，构造器使用的是相对路径，而ctx.getResource()方法如果以“/”开头则表示获取绝对路径资源，而不带前导“/”将返回相对路径资源。如下：