spring6-资源操作:Resources
作者:mmseoamin日期:2023-12-05

资源操作:Resources

      • 1、Spring Resources概述
      • 2、Resource接口
      • 3、Resource的实现类
        • 3.1、UrlResource访问网络资源
        • 3.2、ClassPathResource 访问类路径下资源
        • 3.3、FileSystemResource 访问文件系统资源
        • 3.4、ServletContextResource
        • 3.5、InputStreamResource
        • 3.6、ByteArrayResource
        • 4、Resource类图
        • 5、ResourceLoader 接口
          • 5.1、ResourceLoader 概述
          • 5.2、使用演示
          • 5.3、ResourceLoader 总结
          • 6、ResourceLoaderAware 接口
          • 7、使用Resource 作为属性
          • 8、应用程序上下文和资源路径
            • 8.1、概述
            • 8.2、ApplicationContext实现类指定访问策略
            • 8.3、使用前缀指定访问策略
            • 1、Spring Resources概述

              spring6-资源操作:Resources,在这里插入图片描述,第1张

              spring6-资源操作:Resources,在这里插入图片描述,第2张

              Java的标准java.net.URL类和各种URL前缀的标准处理程序无法满足所有对low-level资源的访问,比如:没有标准化的 URL 实现可用于访问需要从类路径或相对于 ServletContext 获取的资源。并且缺少某些Spring所需要的功能,例如检测某资源是否存在等。而Spring的Resource声明了访问low-level资源的能力。

              2、Resource接口

              Spring 的 Resource 接口位于 org.springframework.core.io 中。 旨在成为一个更强大的接口,用于抽象对低级资源的访问。以下显示了Resource接口定义的方法

              public interface Resource extends InputStreamSource {
                  boolean exists();
                  boolean isReadable();
                  boolean isOpen();
                  boolean isFile();
                  URL getURL() throws IOException;
                  URI getURI() throws IOException;
                  File getFile() throws IOException;
                  ReadableByteChannel readableChannel() throws IOException;
                  long contentLength() throws IOException;
                  long lastModified() throws IOException;
                  Resource createRelative(String relativePath) throws IOException;
                  String getFilename();
                  String getDescription();
              }
              

              Resource接口继承了InputStreamSource接口,提供了很多InputStreamSource所没有的方法。InputStreamSource接口,只有一个方法:

              public interface InputStreamSource {
                  InputStream getInputStream() throws IOException;
              }
              

              其中一些重要的方法:

              getInputStream(): 找到并打开资源,返回一个InputStream以从资源中读取。预计每次调用都会返回一个新的InputStream(),调用者有责任关闭每个流

              exists(): 返回一个布尔值,表明某个资源是否以物理形式存在

              isOpen: 返回一个布尔值,指示此资源是否具有开放流的句柄。如果为true,InputStream就不能够多次读取,只能够读取一次并且及时关闭以避免内存泄漏。对于所有常规资源实现,返回false,但是InputStreamResource除外。

              getDescription(): 返回资源的描述,用来输出错误的日志。这通常是完全限定的文件名或资源的实际URL。

              其他方法:

              isReadable(): 表明资源的目录读取是否通过getInputStream()进行读取。

              isFile(): 表明这个资源是否代表了一个文件系统的文件。

              getURL(): 返回一个URL句柄,如果资源不能够被解析为URL,将抛出IOException

              getURI(): 返回一个资源的URI句柄

              getFile(): 返回某个文件,如果资源不能够被解析称为绝对路径,将会抛出FileNotFoundException

              lastModified(): 资源最后一次修改的时间戳

              createRelative(): 创建此资源的相关资源

              getFilename(): 资源的文件名是什么 例如:最后一部分的文件名 myfile.txt

              3、Resource的实现类

              Resource 接口是 Spring 资源访问策略的抽象,它本身并不提供任何资源访问实现,具体的资源访问由该接口的实现类完成——每个实现类代表一种资源访问策略。Resource一般包括这些实现类:UrlResource、ClassPathResource、FileSystemResource、ServletContextResource、InputStreamResource、ByteArrayResource

              3.1、UrlResource访问网络资源

              Resource的一个实现类,用来访问网络资源,它支持URL的绝对路径。

              http:------该前缀用于访问基于HTTP协议的网络资源。

              ftp:------该前缀用于访问基于FTP协议的网络资源

              file: ------该前缀用于从文件系统中读取资源

              实验:访问基于HTTP协议的网络资源

              创建一个maven子模块spring6-resources,配置Spring依赖(参考前面)

              spring6-资源操作:Resources,在这里插入图片描述,第3张

              package com.atguigu.spring6.resources;
              import org.springframework.core.io.UrlResource;
              public class UrlResourceDemo {
                  public static void loadAndReadUrlResource(String path){
                      // 创建一个 Resource 对象
                      UrlResource url = null;
                      try {
                          url = new UrlResource(path);
                          // 获取资源名
                          System.out.println(url.getFilename());
                          System.out.println(url.getURI());
                          // 获取资源描述
                          System.out.println(url.getDescription());
                          //获取资源内容
                          System.out.println(url.getInputStream().read());
                      } catch (Exception e) {
                          throw new RuntimeException(e);
                      }
                  }
                  
                  public static void main(String[] args) {
                      //访问网络资源
                      loadAndReadUrlResource("http://www.baidu.com");
                  }
              }
              

              实验二:在项目根路径下创建文件,从文件系统中读取资源

              方法不变,修改调用传递路径

              public static void main(String[] args) {
                  //1 访问网络资源
              	//loadAndReadUrlResource("http://www.atguigu.com");
                  
                  //2 访问文件系统资源
                  loadAndReadUrlResource("file:atguigu.txt");
              }
              
              3.2、ClassPathResource 访问类路径下资源

              ClassPathResource 用来访问类加载路径下的资源,相对于其他的 Resource 实现类,其主要优势是方便访问类加载路径里的资源,尤其对于 Web 应用,ClassPathResource 可自动搜索位于 classes 下的资源文件,无须使用绝对路径访问。

              实验:在类路径下创建文件atguigu.txt,使用ClassPathResource 访问

              spring6-资源操作:Resources,在这里插入图片描述,第4张

              package com.atguigu.spring6.resources;
              import org.springframework.core.io.ClassPathResource;
              import java.io.InputStream;
              public class ClassPathResourceDemo {
                  public static void loadAndReadUrlResource(String path) throws Exception{
                      // 创建一个 Resource 对象
                      ClassPathResource resource = new ClassPathResource(path);
                      // 获取文件名
                      System.out.println("resource.getFileName = " + resource.getFilename());
                      // 获取文件描述
                      System.out.println("resource.getDescription = "+ resource.getDescription());
                      //获取文件内容
                      InputStream in = resource.getInputStream();
                      byte[] b = new byte[1024];
                      while(in.read(b)!=-1) {
                          System.out.println(new String(b));
                      }
                  }
                  public static void main(String[] args) throws Exception {
                      loadAndReadUrlResource("atguigu.txt");
                  }
              }
              

              ClassPathResource实例可使用ClassPathResource构造器显式地创建,但更多的时候它都是隐式地创建的。当执行Spring的某个方法时,该方法接受一个代表资源路径的字符串参数,当Spring识别该字符串参数中包含classpath:前缀后,系统会自动创建ClassPathResource对象。

              3.3、FileSystemResource 访问文件系统资源

              Spring 提供的 FileSystemResource 类用于访问文件系统资源,使用 FileSystemResource 来访问文件系统资源并没有太大的优势,因为 Java 提供的 File 类也可用于访问文件系统资源。

              实验:使用FileSystemResource 访问文件系统资源

              package com.atguigu.spring6.resources;
              import org.springframework.core.io.FileSystemResource;
              import java.io.InputStream;
              public class FileSystemResourceDemo {
                  public static void loadAndReadUrlResource(String path) throws Exception{
                      //相对路径
                      FileSystemResource resource = new FileSystemResource("atguigu.txt");
                      //绝对路径
                      //FileSystemResource resource = new FileSystemResource("C:\\atguigu.txt");
                      // 获取文件名
                      System.out.println("resource.getFileName = " + resource.getFilename());
                      // 获取文件描述
                      System.out.println("resource.getDescription = "+ resource.getDescription());
                      //获取文件内容
                      InputStream in = resource.getInputStream();
                      byte[] b = new byte[1024];
                      while(in.read(b)!=-1) {
                          System.out.println(new String(b));
                      }
                  }
                  public static void main(String[] args) throws Exception {
                      loadAndReadUrlResource("atguigu.txt");
                  }
              }
              

              FileSystemResource实例可使用FileSystemResource构造器显示地创建,但更多的时候它都是隐式创建。执行Spring的某个方法时,该方法接受一个代表资源路径的字符串参数,当Spring识别该字符串参数中包含file:前缀后,系统将会自动创建FileSystemResource对象。

              3.4、ServletContextResource

              这是ServletContext资源的Resource实现,它解释相关Web应用程序根目录中的相对路径。它始终支持流(stream)访问和URL访问,但只有在扩展Web应用程序存档且资源实际位于文件系统上时才允许java.io.File访问。无论它是在文件系统上扩展还是直接从JAR或其他地方(如数据库)访问,实际上都依赖于Servlet容器。

              3.5、InputStreamResource

              InputStreamResource 是给定的输入流(InputStream)的Resource实现。它的使用场景在没有特定的资源实现的时候使用(感觉和@Component 的适用场景很相似)。与其他Resource实现相比,这是已打开资源的描述符。 因此,它的isOpen()方法返回true。如果需要将资源描述符保留在某处或者需要多次读取流,请不要使用它。

              3.6、ByteArrayResource

              字节数组的Resource实现类。通过给定的数组创建了一个ByteArrayInputStream。它对于从任何给定的字节数组加载内容非常有用,而无需求助于单次使用的InputStreamResource。

              4、Resource类图

              上述Resource实现类与Resource顶级接口之间的关系可以用下面的UML关系模型来表示

              spring6-资源操作:Resources,在这里插入图片描述,第5张

              5、ResourceLoader 接口

              5.1、ResourceLoader 概述

              Spring 提供如下两个标志性接口:

              (1)ResourceLoader : 该接口实现类的实例可以获得一个Resource实例。

              (2) ResourceLoaderAware : 该接口实现类的实例将获得一个ResourceLoader的引用。

              在ResourceLoader接口里有如下方法:

              (1)Resource getResource(String location) : 该接口仅有这个方法,用于返回一个Resource实例。ApplicationContext实现类都实现ResourceLoader接口,因此ApplicationContext可直接获取Resource实例。

              5.2、使用演示

              实验一:ClassPathXmlApplicationContext获取Resource实例

              package com.atguigu.spring6.resouceloader;
              import org.springframework.context.ApplicationContext;
              import org.springframework.context.support.ClassPathXmlApplicationContext;
              import org.springframework.core.io.Resource;
              public class Demo1 {
                  public static void main(String[] args) {
                      ApplicationContext ctx = new ClassPathXmlApplicationContext();
              //        通过ApplicationContext访问资源
              //        ApplicationContext实例获取Resource实例时,
              //        默认采用与ApplicationContext相同的资源访问策略
                      Resource res = ctx.getResource("atguigu.txt");
                      System.out.println(res.getFilename());
                  }
              }
              

              实验二:FileSystemApplicationContext获取Resource实例

              package com.atguigu.spring6.resouceloader;
              import org.springframework.context.ApplicationContext;
              import org.springframework.context.support.FileSystemXmlApplicationContext;
              import org.springframework.core.io.Resource;
              public class Demo2 {
                  public static void main(String[] args) {
                      ApplicationContext ctx = new FileSystemXmlApplicationContext();
                      Resource res = ctx.getResource("atguigu.txt");
                      System.out.println(res.getFilename());
                  }
              }
              
              5.3、ResourceLoader 总结

              Spring将采用和ApplicationContext相同的策略来访问资源。也就是说,如果ApplicationContext是FileSystemXmlApplicationContext,res就是FileSystemResource实例;如果ApplicationContext是ClassPathXmlApplicationContext,res就是ClassPathResource实例

              当Spring应用需要进行资源访问时,实际上并不需要直接使用Resource实现类,而是调用ResourceLoader实例的getResource()方法来获得资源,ReosurceLoader将会负责选择Reosurce实现类,也就是确定具体的资源访问策略,从而将应用程序和具体的资源访问策略分离开来

              另外,使用ApplicationContext访问资源时,可通过不同前缀指定强制使用指定的ClassPathResource、FileSystemResource等实现类

              Resource res = ctx.getResource("calsspath:bean.xml");
              Resrouce res = ctx.getResource("file:bean.xml");
              Resource res = ctx.getResource("http://localhost:8080/beans.xml");
              

              6、ResourceLoaderAware 接口

              ResourceLoaderAware接口实现类的实例将获得一个ResourceLoader的引用,ResourceLoaderAware接口也提供了一个setResourceLoader()方法,该方法将由Spring容器负责调用,Spring容器会将一个ResourceLoader对象作为该方法的参数传入。

              如果把实现ResourceLoaderAware接口的Bean类部署在Spring容器中,Spring容器会将自身当成ResourceLoader作为setResourceLoader()方法的参数传入。由于ApplicationContext的实现类都实现了ResourceLoader接口,Spring容器自身完全可作为ResorceLoader使用。

              实验:演示ResourceLoaderAware使用

              第一步 创建类,实现ResourceLoaderAware接口

              package com.atguigu.spring6.resouceloader;
              import org.springframework.context.ResourceLoaderAware;
              import org.springframework.core.io.ResourceLoader;
              public class TestBean implements ResourceLoaderAware {
                  private ResourceLoader resourceLoader;
                  //实现ResourceLoaderAware接口必须实现的方法
              	//如果把该Bean部署在Spring容器中,该方法将会有Spring容器负责调用。
              	//SPring容器调用该方法时,Spring会将自身作为参数传给该方法。
                  public void setResourceLoader(ResourceLoader resourceLoader) {
                      this.resourceLoader = resourceLoader;
                  }
                  //返回ResourceLoader对象的应用
                  public ResourceLoader getResourceLoader(){
                      return this.resourceLoader;
                  }
              }
              

              第二步 创建bean.xml文件,配置TestBean

              
              
                  
              
              

              第三步 测试

              package com.atguigu.spring6.resouceloader;
              import org.springframework.context.ApplicationContext;
              import org.springframework.context.support.ClassPathXmlApplicationContext;
              import org.springframework.core.io.Resource;
              import org.springframework.core.io.ResourceLoader;
              public class Demo3 {
                  public static void main(String[] args) {
                      //Spring容器会将一个ResourceLoader对象作为该方法的参数传入
                      ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
                      TestBean testBean = ctx.getBean("testBean",TestBean.class);
                      //获取ResourceLoader对象
                      ResourceLoader resourceLoader = testBean.getResourceLoader();
                      System.out.println("Spring容器将自身注入到ResourceLoaderAware Bean 中 ? :" + (resourceLoader == ctx));
                      //加载其他资源
                      Resource resource = resourceLoader.getResource("atguigu.txt");
                      System.out.println(resource.getFilename());
                      System.out.println(resource.getDescription());
                  }
              }
              

              7、使用Resource 作为属性

              前面介绍了 Spring 提供的资源访问策略,但这些依赖访问策略要么需要使用 Resource 实现类,要么需要使用 ApplicationContext 来获取资源。实际上,当应用程序中的 Bean 实例需要访问资源时,Spring 有更好的解决方法:直接利用依赖注入。从这个意义上来看,Spring 框架不仅充分利用了策略模式来简化资源访问,而且还将策略模式和 IoC 进行充分地结合,最大程度地简化了 Spring 资源访问。

              归纳起来,如果 Bean 实例需要访问资源,有如下两种解决方案:

              • 代码中获取 Resource 实例。
              • 使用依赖注入。

                对于第一种方式,当程序获取 Resource 实例时,总需要提供 Resource 所在的位置,不管通过 FileSystemResource 创建实例,还是通过 ClassPathResource 创建实例,或者通过 ApplicationContext 的 getResource() 方法获取实例,都需要提供资源位置。这意味着:资源所在的物理位置将被耦合到代码中,如果资源位置发生改变,则必须改写程序。因此,通常建议采用第二种方法,让 Spring 为 Bean 实例依赖注入资源。

                实验:让Spring为Bean实例依赖注入资源

                第一步 创建依赖注入类,定义属性和方法

                package com.atguigu.spring6.resouceloader;
                import org.springframework.core.io.Resource;
                public class ResourceBean {
                    
                    private Resource res;
                    
                    public void setRes(Resource res) {
                        this.res = res;
                    }
                    public Resource getRes() {
                        return res;
                    }
                    
                    public void parse(){
                        System.out.println(res.getFilename());
                        System.out.println(res.getDescription());
                    }
                }
                

                第二步 创建spring配置文件,配置依赖注入

                
                
                    
                      
                      
                        
                    
                
                

                第三步 测试

                package com.atguigu.spring6.resouceloader;
                import org.springframework.context.ApplicationContext;
                import org.springframework.context.support.ClassPathXmlApplicationContext;
                public class Demo4 {
                    public static void main(String[] args) {
                        ApplicationContext ctx =
                                new ClassPathXmlApplicationContext("bean.xml");
                        ResourceBean resourceBean = ctx.getBean("resourceBean",ResourceBean.class);
                        resourceBean.parse();
                    }
                }
                

                8、应用程序上下文和资源路径

                8.1、概述

                不管以怎样的方式创建ApplicationContext实例,都需要为ApplicationContext指定配置文件,Spring允许使用一份或多分XML配置文件。当程序创建ApplicationContext实例时,通常也是以Resource的方式来访问配置文件的,所以ApplicationContext完全支持ClassPathResource、FileSystemResource、ServletContextResource等资源访问方式。

                ApplicationContext确定资源访问策略通常有两种方法:

                (1)使用ApplicationContext实现类指定访问策略。

                (2)使用前缀指定访问策略。

                8.2、ApplicationContext实现类指定访问策略

                创建ApplicationContext对象时,通常可以使用如下实现类:

                (1) ClassPathXMLApplicationContext : 对应使用ClassPathResource进行资源访问。

                (2)FileSystemXmlApplicationContext : 对应使用FileSystemResource进行资源访问。

                (3)XmlWebApplicationContext : 对应使用ServletContextResource进行资源访问。

                当使用ApplicationContext的不同实现类时,就意味着Spring使用响应的资源访问策略。

                效果前面已经演示

                8.3、使用前缀指定访问策略

                实验一:classpath前缀使用

                package com.atguigu.spring6.context;
                import org.springframework.context.ApplicationContext;
                import org.springframework.context.support.FileSystemXmlApplicationContext;
                import org.springframework.core.io.Resource;
                public class Demo1 {
                    public static void main(String[] args) {
                        /*
                         * 通过搜索文件系统路径下的xml文件创建ApplicationContext,
                         * 但通过指定classpath:前缀强制搜索类加载路径
                         * classpath:bean.xml
                         * */
                        ApplicationContext ctx =
                                new ClassPathXmlApplicationContext("classpath:bean.xml");
                        System.out.println(ctx);
                        Resource resource = ctx.getResource("atguigu.txt");
                        System.out.println(resource.getFilename());
                        System.out.println(resource.getDescription());
                    }
                }
                

                实验二:classpath通配符使用

                classpath * :前缀提供了加载多个XML配置文件的能力,当使用classpath*:前缀来指定XML配置文件时,系统将搜索类加载路径,找到所有与文件名匹配的文件,分别加载文件中的配置定义,最后合并成一个ApplicationContext。

                ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath*:bean.xml");
                System.out.println(ctx);
                

                当使用classpath * :前缀时,Spring将会搜索类加载路径下所有满足该规则的配置文件。

                如果不是采用classpath * :前缀,而是改为使用classpath:前缀,Spring则只加载第一个符合条件的XML文件

                注意 :

                classpath * : 前缀仅对ApplicationContext有效。实际情况是,创建ApplicationContext时,分别访问多个配置文件(通过ClassLoader的getResource方法实现)。因此,classpath * :前缀不可用于Resource。

                使用三:通配符其他使用

                一次性加载多个配置文件的方式:指定配置文件时使用通配符

                ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:bean*.xml");
                

                Spring允许将classpath*:前缀和通配符结合使用:

                ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath*:bean*.xml");