Spring学习八----------Bean的配置之Resources

 

© 版权声明：本文为博主原创文章，转载请注明出处

Resources

针对于资源文件的统一接口

-UrlResource：URL对应的资源，根据一个URL地址即可创建

-ClassPathResource：获取类路径下的资源文件

-FileSystemResource：获取文件系统里面的资源

-ServletContextResource：ServletContext封装的资源，用于访问ServletContext环境下的资源（需导入spring-web.jar，需在web环境中测试，本次不测试。）

-InputStreamResource：针对于输入流封装的资源

-ByteArrayResource：针对于字节数组封装的资源

ResourceLoader

spring的IOC容器中，所有的Application context都实现了ResourceLoader这个接口，所有的application context都可以用getResource()方法来获取Resource实例。

前缀：

classpath：从类路径中加载

file：从文件系统中作为url加载

http：作为url加载

（none）：依赖于application context，也就是说application context是怎么加载的，它就是怎么加载的

实例

1.项目结构

2.pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	
	<modelVersion>4.0.0</modelVersion>
	
	<groupId>org.springresources</groupId>
	<artifactId>Spring-Resources</artifactId>
	<packaging>jar</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>Spring-Resources Maven Webapp</name>
	<url>http://maven.apache.org</url>
	
	<!-- 统一开发所需版本 -->
	<properties>
		<spring.version>4.3.7.RELEASE</spring.version>
	</properties>
	
	<dependencies>
		<!-- junit依赖 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
		<!-- Spring核心依赖 -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-core</artifactId>
		    <version>${spring.version}</version>
		</dependency>
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-beans</artifactId>
		    <version>${spring.version}</version>
		</dependency>
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-context</artifactId>
		    <version>${spring.version}</version>
		</dependency>
	</dependencies>
	
	<build>
		<finalName>Spring-Resources</finalName>
	</build>
</project>

3.test-resources.txt

测试spring Resource

4.SpringResource.java

package org.spring.resources;

import java.io.IOException;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.core.io.Resource;

public class SpringResource implements ApplicationContextAware {

	private ApplicationContext context;
	
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		
		this.context = applicationContext;
		
	}

	/**
	 * 通过classpath前缀获取Resource
	 * 
	 * @throws IOException
	 */
	public void getClassPathResouce() throws IOException {
		
		Resource resource = context.getResource("classpath:test-resources.txt");
		System.out.println("ResourceLoader(classpath) filename: " + resource.getFilename());
		System.out.println("ResourceLoader(classpath) size: " + resource.contentLength());
		
	}
	
	/**
	 * 通过file前缀获取Resource
	 * 
	 * @throws IOException
	 */
	public void getFileResouce() throws IOException {
		
		Resource resource = context.getResource("file:E:\\code\\Spring-Resources\\src\\main\\resources\\test-resources.txt");
		System.out.println("ResourceLoader(file) filename: " + resource.getFilename());
		System.out.println("ResourceLoader(file) size: " + resource.contentLength());
		
	}
	
	/**
	 * 通过url前缀获取Resource
	 * 
	 * @throws IOException
	 */
	public void getUrlResouce() throws IOException {
		
		Resource resource = context.getResource("url:http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/");
		System.out.println("ResourceLoader(url) filename: " + resource.getFilename());
		System.out.println("ResourceLoader(url) size: " + resource.contentLength());
		
	}
	
	/**
	 * 无前缀获取Resource
	 * 
	 * 跟application context有关，本代码中的application context是根据classpath获取的，所以该方法中也是根据classpath前缀获取的Resource
	 * 
	 * @throws IOException
	 */
	public void getResouce() throws IOException {
		
		Resource resource = context.getResource("test-resources.txt");
		System.out.println("ResourceLoader(none) filename: " + resource.getFilename());
		System.out.println("ResourceLoader(none) size: " + resource.contentLength());
		
	}
	
}

5.spring-resources.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
        
    <bean id="springResource" class="org.spring.resources.SpringResource"/>
    
</beans>

6.JunitTestBase.java

package org.spring.resources.test;

import org.junit.After;
import org.junit.Before;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.util.StringUtils;

/**
 * Junit基类
 *
 */
public class JunitTestBase {

	private ClassPathXmlApplicationContext context;
	private String springXmlPath;
	
	/**
	 * 无参构造器，使用此构造器则使用默认spring配置文件
	 */
	public JunitTestBase() {
		
	}

	/**
	 * 含参构造器，初始化spring配置文件路径
	 * 
	 * @param springXmlPath
	 * 						spring配置文件路径
	 */
	public JunitTestBase(String springXmlPath) {
		super();
		this.springXmlPath = springXmlPath;
	}
	
	/**
	 * 加载spring配置文件到容器中，并启动容器
	 * 在@Test方法执行之前执行
	 */
	@Before
	public void before() {
		
		if(StringUtils.isEmpty(springXmlPath)) {//默认spring配置文件
			springXmlPath = "classpath:spring-*.xml";
		}
		//加载spring配置文件到spring容器中
		context = new ClassPathXmlApplicationContext(springXmlPath.split("[,\\s]+"));
		//启动spring容器，并将启动信号扩散器该容器下的所有组件中
		context.start();
		
	}
	
	/**
	 * 销毁Spring容器
	 * 在@Test方法执行之后执行
	 */
	@After
	public void after() {
	
		if(context != null){
			context.destroy();
		}
		
	}
	
	/**
	 * 通过bean Id获取对象
	 * 
	 * @param beanId
	 * 					bean id
	 * @return
	 */
	public Object getBean(String beanId) {
		
		return context.getBean(beanId);
		
	}
	
}

7.TestSpringResources.java

package org.spring.resources.test;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.spring.resources.SpringResource;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.InputStreamResource;
import org.springframework.core.io.UrlResource;

@RunWith(BlockJUnit4ClassRunner.class)//默认执行类,可不写
public class TestSpringResources extends JunitTestBase {

	//构造器初始化spring配置文件
	public TestSpringResources() {
		
		super("classpath:spring-resources.xml");
		
	}
	
	/**
	 * 测试UrlResource
	 * 
	 * @throws IOException 
	 */
	@Test
	public void testUrlResources() throws IOException {
		
		UrlResource resource = new UrlResource("http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/");
		System.out.println("UrlResource filename:" + resource.getFilename());
		System.out.println("UrlResource size:" + resource.contentLength());
		
	}

	/**
	 * 测试ClassPathResource
	 * 
	 * @throws IOException
	 */
	@Test
	public void testClassPathResource() throws IOException {
		
		ClassPathResource resource = new ClassPathResource("test-resources.txt");
		System.out.println("ClassPathResource filename:" + resource.getFilename());
		System.out.println("ClassPathResource size:" + resource.contentLength());
		
	}
	
	/**
	 * 测试FileSystemResource
	 * 
	 * @throws IOException
	 */
	@Test
	public void testFileSystemResource() throws IOException {
		
		FileSystemResource resource = new FileSystemResource("E:\\code\\Spring-Resources\\src\\main\\resources\\test-resources.txt");
		System.out.println("FileSystemResource filename:" + resource.getFilename());
		System.out.println("FileSystemResource size:" + resource.contentLength());
		
	}
	
	/**
	 * 测试InputStreamResource
	 * 
	 * @throws IOException
	 */
	@Test
	public void testInputStreamResource() throws IOException {
		
		InputStream is = new FileInputStream("E:\\code\\Spring-Resources\\src\\main\\resources\\test-resources.txt");
		InputStreamResource resource = new InputStreamResource(is);
		System.out.println("InputStreamResource filename:" + resource.getFilename());
		System.out.println("InputStreamResource size:" + resource.contentLength());
		
	}
	
	/**
	 * 测试ByteArrayResource
	 * 
	 * @throws IOException
	 */
	@Test
	public void testByteArrayResource() throws IOException {
		
		ByteArrayResource resource = new ByteArrayResource("Test Resource".getBytes());
		System.out.println("ByteArrayResource filename:" + resource.getFilename());
		System.out.println("ByteArrayResource size:" + resource.contentLength());
		
	}
	
	/**
	 * 测试ResourceLoader-classpath前缀
	 * 
	 * @throws IOException
	 */
	@Test
	public void testResourceLoaderClassPath() throws IOException {
		
		SpringResource springResource = (SpringResource) super.getBean("springResource");
		springResource.getClassPathResouce();
		
	}
	
	/**
	 * 测试ResourceLoader-file前缀
	 * 
	 * @throws IOException
	 */
	@Test
	public void testResourceLoaderFile() throws IOException {
		
		SpringResource springResource = (SpringResource) super.getBean("springResource");
		springResource.getFileResouce();
		
	}
	
	/**
	 * 测试ResourceLoader-url前缀
	 * 
	 * @throws IOException
	 */
	@Test
	public void testResourceLoaderUrl() throws IOException {
		
		SpringResource springResource = (SpringResource) super.getBean("springResource");
		springResource.getUrlResouce();
		
	}
	
	/**
	 * 测试ResourceLoader-无前缀
	 * 
	 * @throws IOException
	 */
	@Test
	public void testResourceLoader() throws IOException {
		
		SpringResource springResource = (SpringResource) super.getBean("springResource");
		springResource.getResouce();
		
	}

}

8.效果预览

　　8.1 执行testUrlResources方法

　　8.2 执行testClassPathResource方法　

　　8.3 执行testFileSystemResource方法

　　8.4 执行testInputStreamResource方法

　　8.5 执行testByteArrayResource方法

　　8.6 执行testResourceLoaderClassPath方法

　　8.7 执行testResourceLoaderFile方法

　　8.8 执行testResourceLoaderUrl方法

　　8.9 执行testResourceLoader方法

参考：http://www.imooc.com/video/3758

 

转载于:https://www.cnblogs.com/jinjiyese153/p/6709907.html