【第四章】 资源 之 4.2 内置Resource实现 ——跟我学spring3

4.2  内置Resource实现

4.2.1  ByteArrayResource

       ByteArrayResource代表byte[]数组资源,对于“getInputStream”操作将返回一个ByteArrayInputStream。

首先让我们看下使用ByteArrayResource如何处理byte数组资源:

 

java代码:
  1.       
  2. package cn.javass.spring.chapter4;  
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import org.junit.Test;  
  6. import org.springframework.core.io.ByteArrayResource;  
  7. import org.springframework.core.io.Resource;  
  8. public class ResourceTest {  
  9. @Test  
  10. public void testByteArrayResource() {  
  11. Resource resource = new ByteArrayResource("Hello World!".getBytes());  
  12.         if(resource.exists()) {  
  13.             dumpStream(resource);  
  14.         }  
  15. }  
  16. }  

 

是不是很简单,让我们看下“dumpStream”实现:

 

java代码:
  1. private void dumpStream(Resource resource) {  
  2.         InputStream is = null;  
  3.         try {  
  4.             //1.获取文件资源  
  5.             is = resource.getInputStream();  
  6.             //2.读取资源  
  7.             byte[] descBytes = new byte[is.available()];  
  8.             is.read(descBytes);  
  9.             System.out.println(new String(descBytes));  
  10.         } catch (IOException e) {  
  11.             e.printStackTrace();  
  12.         }  
  13.         finally {  
  14.             try {  
  15.                 //3.关闭资源  
  16.                 is.close();  
  17.             } catch (IOException e) {  
  18.             }  
  19.         }  
  20.     }  

      

    让我们来仔细看一下代码,dumpStream方法很抽象定义了访问流的三部曲:打开资源、读取资源、关闭资源,所以dunpStrean可以再进行抽象从而能在自己项目中使用;byteArrayResourceTest测试方法,也定义了基本步骤:定义资源、验证资源存在、访问资源。

 

       ByteArrayResource可多次读取数组资源,即isOpen ()永远返回false。

 

1.2.2  InputStreamResource

       InputStreamResource代表java.io.InputStream字节流,对于“getInputStream ”操作将直接返回该字节流,因此只能读取一次该字节流,即“isOpen”永远返回true。

       让我们看下测试代码吧:

 

java代码:
  1. @Test  
  2. public void testInputStreamResource() {  
  3.    ByteArrayInputStream bis = new ByteArrayInputStream("Hello World!".getBytes());  
  4.    Resource resource = new InputStreamResource(bis);  
  5.     if(resource.exists()) {  
  6.        dumpStream(resource);  
  7.     }  
  8.     Assert.assertEquals(true, resource.isOpen());  
  9. }  
  10.      

 

       测试代码几乎和ByteArrayResource测试完全一样,注意“isOpen”此处用于返回true。

 

4.2.3  FileSystemResource

       FileSystemResource代表java.io.File资源,对于“getInputStream ”操作将返回底层文件的字节流,“isOpen”将永远返回false,从而表示可多次读取底层文件的字节流。

       让我们看下测试代码吧:

 

java代码:
  1. @Test  
  2. public void testFileResource() {  
  3. File file = new File("d:/test.txt");  
  4.     Resource resource = new FileSystemResource(file);  
  5.     if(resource.exists()) {  
  6.         dumpStream(resource);  
  7.     }  
  8.     Assert.assertEquals(false, resource.isOpen());  
  9. }  
  10.    

 

       注意由于“isOpen”将永远返回false,所以可以多次调用dumpStream(resource)。

 

4.2.4  ClassPathResource

       ClassPathResource代表classpath路径的资源,将使用ClassLoader进行加载资源。classpath 资源存在于类路径中的文件系统中或jar包里,且“isOpen”永远返回false,表示可多次读取资源。

       ClassPathResource加载资源替代了Class类和ClassLoader类的“getResource(String name)”和“getResourceAsStream(String name)”两个加载类路径资源方法,提供一致的访问方式。

ClassPathResource提供了三个构造器:

         public ClassPathResource(String path):使用默认的ClassLoader加载“path”类路径资源;

         public ClassPathResource(String path, ClassLoader classLoader):使用指定的ClassLoader加载“path”类路径资源;

比如当前类路径是“cn.javass.spring.chapter4.ResourceTest”,而需要加载的资源路径是“cn/javass/spring/chapter4/test1.properties”,则将加载的资源在“cn/javass/spring/chapter4/test1.properties”;

         public ClassPathResource(String path, Class<?> clazz):使用指定的类加载“path”类路径资源,将加载相对于当前类的路径的资源;

比如当前类路径是“cn.javass.spring.chapter4.ResourceTest”,而需要加载的资源路径是“cn/javass/spring/chapter4/test1.properties”,则将加载的资源在“cn/javass/spring/chapter4/cn/javass/spring/chapter4/test1.properties”;

       而如果需要 加载的资源路径为“test1.properties”,将加载的资源为“cn/javass/spring/chapter4/test1.properties”。

 

       让我们直接看测试代码吧:

1)使用默认的加载器加载资源,将加载当前ClassLoader类路径上相对于根路径的资源:

 

java代码:
  1. @Test  
  2. public void testClasspathResourceByDefaultClassLoader() throws IOException {  
  3.    Resource resource = new ClassPathResource("cn/javass/spring/chapter4/test1.properties");  
  4.     if(resource.exists()) {  
  5.         dumpStream(resource);  
  6.     }  
  7.     System.out.println("path:" + resource.getFile().getAbsolutePath());  
  8.     Assert.assertEquals(false, resource.isOpen());  
  9. }  
  10.    

 

2)使用指定的ClassLoader进行加载资源,将加载指定的ClassLoader类路径上相对于根路径的资源:

 

java代码:
  1. @Test  
  2. public void testClasspathResourceByClassLoader() throws IOException {  
  3.     ClassLoader cl = this.getClass().getClassLoader();  
  4.     Resource resource = new ClassPathResource("cn/javass/spring/chapter4/test1.properties" , cl);  
  5.     if(resource.exists()) {  
  6.         dumpStream(resource);  
  7.     }  
  8.     System.out.println("path:" + resource.getFile().getAbsolutePath());  
  9.     Assert.assertEquals(false, resource.isOpen());  
  10. }  

 

3)使用指定的类进行加载资源,将尝试加载相对于当前类的路径的资源:

 

java代码:
  1. @Test  
  2. public void testClasspathResourceByClass() throws IOException {  
  3.    Class clazz = this.getClass();  
  4.     Resource resource1 = new ClassPathResource("cn/javass/spring/chapter4/test1.properties" , clazz);  
  5.     if(resource1.exists()) {  
  6.         dumpStream(resource1);  
  7.     }  
  8.     System.out.println("path:" + resource1.getFile().getAbsolutePath());  
  9.     Assert.assertEquals(false, resource1.isOpen());  
  10.          
  11.     Resource resource2 = new ClassPathResource("test1.properties" , this.getClass());  
  12.     if(resource2.exists()) {  
  13.         dumpStream(resource2);  
  14.    }  
  15.     System.out.println("path:" + resource2.getFile().getAbsolutePath());  
  16.     Assert.assertEquals(false, resource2.isOpen());  
  17. }  

       “resource1”将加载cn/javass/spring/chapter4/cn/javass/spring/chapter4/test1.properties资源;“resource2”将加载“cn/javass/spring/chapter4/test1.properties”;

 

4)加载jar包里的资源,首先在当前类路径下找不到,最后才到Jar包里找,而且在第一个Jar包里找到的将被返回:

 

java代码:
  1. @Test  
  2. public void classpathResourceTestFromJar() throws IOException {  
  3. Resource resource = new ClassPathResource("overview.html");  
  4.     if(resource.exists()) {  
  5.         dumpStream(resource);  
  6.     }  
  7.     System.out.println("path:" + resource.getURL().getPath());  
  8.     Assert.assertEquals(false, resource.isOpen());  
  9. }  

 

如果当前类路径包含“overview.html”,在项目的“resources”目录下,将加载该资源,否则将加载Jar包里的“overview.html”,而且不能使用“resource.getFile()”,应该使用“resource.getURL()”,因为资源不存在于文件系统而是存在于jar包里,URL类似于“file:/C:/.../***.jar!/overview.html”。

类路径一般都是相对路径,即相对于类路径或相对于当前类的路径,因此如果使用“/test1.properties”带前缀“/”的路径,将自动删除“/”得到“test1.properties”。

 

4.2.5  UrlResource

       UrlResource代表URL资源,用于简化URL资源访问。“isOpen”永远返回false,表示可多次读取资源。

       UrlResource一般支持如下资源访问:

         http:通过标准的http协议访问web资源,如new UrlResource(“http://地址”);

         ftp:通过ftp协议访问资源,如new UrlResource(“ftp://地址”);

         file:通过file协议访问本地文件系统资源,如new UrlResource(“file:d:/test.txt”);

具体使用方法在此就不演示了,可以参考cn.javass.spring.chapter4.ResourceTest中urlResourceTest测试方法。

 

4.2.6  ServletContextResource

       ServletContextResource代表web应用资源,用于简化servlet容器的ServletContext接口的getResource操作和getResourceAsStream操作;在此就不具体演示了。

 

4.2.7  VfsResource

VfsResource代表Jboss 虚拟文件系统资源。

 

Jboss VFS(Virtual File System)框架是一个文件系统资源访问的抽象层,它能一致的访问物理文件系统、jar资源、zip资源、war资源等,VFS能把这些资源一致的映射到一个目录上,访问它们就像访问物理文件资源一样,而其实这些资源不存在于物理文件系统。

在示例之前需要准备一些jar包,在此我们使用的是Jboss VFS3版本,可以下载最新的Jboss AS 6x,拷贝lib目录下的“jboss-logging.jar”和“jboss-vfs.jar”两个jar包拷贝到我们项目的lib目录中并添加到“Java Build Path”中的“Libaries”中。

让我们看下示例(cn.javass.spring.chapter4.ResourceTest):

 

java代码:
  1. @Test  
  2. public void testVfsResourceForRealFileSystem() throws IOException {  
  3. //1.创建一个虚拟的文件目录  
  4. VirtualFile home = VFS.getChild("/home");  
  5. //2.将虚拟目录映射到物理的目录  
  6. VFS.mount(home, new RealFileSystem(new File("d:")));  
  7. //3.通过虚拟目录获取文件资源  
  8. VirtualFile testFile = home.getChild("test.txt");  
  9. //4.通过一致的接口访问  
  10. Resource resource = new VfsResource(testFile);  
  11. if(resource.exists()) {  
  12.         dumpStream(resource);  
  13. }  
  14. System.out.println("path:" + resource.getFile().getAbsolutePath());  
  15. Assert.assertEquals(false, resource.isOpen());         
  16. }  
  17. @Test  
  18. public void testVfsResourceForJar() throws IOException {  
  19. //1.首先获取jar包路径  
  20.     File realFile = new File("lib/org.springframework.beans-3.0.5.RELEASE.jar");  
  21.     //2.创建一个虚拟的文件目录  
  22.     VirtualFile home = VFS.getChild("/home2");  
  23.     //3.将虚拟目录映射到物理的目录  
  24. VFS.mountZipExpanded(realFile, home,  
  25. TempFileProvider.create("tmp", Executors.newScheduledThreadPool(1)));  
  26. //4.通过虚拟目录获取文件资源  
  27.     VirtualFile testFile = home.getChild("META-INF/spring.handlers");  
  28.     Resource resource = new VfsResource(testFile);  
  29.     if(resource.exists()) {  
  30.             dumpStream(resource);  
  31.     }  
  32.     System.out.println("path:" + resource.getFile().getAbsolutePath());  
  33.     Assert.assertEquals(false, resource.isOpen());  
  34. }  
  35.   


原文地址 http://sishuok.com/forum/blogPost/list/2456.html

 

       通过VFS,对于jar里的资源和物理文件系统访问都具有一致性,此处只是简单示例,如果需要请到Jboss官网深入学习。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值