【小家Spring】资源访问利器---Spring提供的Resource接口以及它的常用子类源码分析

    public java.net.URL getResource(String name) {
        name = resolveName(name);
        ClassLoader cl = getClassLoader0();
        if (cl==null) {
            // A system class.
            return ClassLoader.getSystemResource(name);
        }
        return cl.getResource(name);
    }

     public InputStream getResourceAsStream(String name) {
        name = resolveName(name);
        ClassLoader cl = getClassLoader0();
        if (cl==null) {
            // A system class.
            return ClassLoader.getSystemResourceAsStream(name);
        }
        return cl.getResourceAsStream(name);
    }

    private String resolveName(String name) {
        if (name == null) {
            return name;
        }
        if (!name.startsWith("/")) {
            Class<?> c = this;
            while (c.isArray()) {
                c = c.getComponentType();
            }
            String baseName = c.getName();
            int index = baseName.lastIndexOf('.');
            if (index != -1) {
                name = baseName.substring(0, index).replace('.', '/')
                    +"/"+name;
            }
        } else {
            name = name.substring(1);
        }
        return name;
    }

    public static void main(String[] args) {
        // 此处用相对路径，那就是相对Main所在的路径。因此此处需要demo.properties和Main.class文件在同一个包里面  否则请用对应的../../等
        // 这里Main所在包为：com.fsx.maintest  因此最终找的文件地址为：com/fsx/maintest/demo.properties 会去这里找文件
        URL resource = Main.class.getResource("demo.properties");
        System.out.println(resource); //file:/E:/work/remotegitcheckoutproject/myprojects/java/demo-war/target/classes/com/fsx/maintest/demo.properties

        // 若采用绝对路径 /就代表当前项目名~~~~  所以此处的效果同上~~~
        resource = Main.class.getResource("/com/fsx/maintest/demo.properties");
        System.out.println(resource); // 同上

        // 关于getResourceAsStream的使用，路径处理上和上面一致，此处就不做过多解释了
        InputStream resourceAsStream = Main.class.getResourceAsStream("demo.properties");
        System.out.println(resourceAsStream); //java.io.BufferedInputStream@33e5ccce

        // ==================最后如果你想直接加载Classpath类路径下的配置文件(此处以类路径下的spring.properties为例)===================
        // 这个/ 不能省略，否则classpathResource为null
        URL classpathResource = Main.class.getResource("/spring.properties");
        System.out.println(classpathResource); //file:/E:/work/remotegitcheckoutproject/myprojects/java/demo-war/target/classes/spring.properties

        System.out.println(Main.class.getResource("")); //.../demo-war/target/classes/com/fsx/maintest/ 它定位到的是Main这个类所在的路径
        System.out.println(Main.class.getResource("/")); //.../demo-war/target/classes/  它定位到的是类路径
    }

    public static void main(String[] args) {
        // 这个大体上和class.getResource()类似。但是它没有class对路径的一个提前处理。所以它这里需要把路径写全了：com/fsx/maintest/demo.properties
        // 需要注意的是，因为它没有对路径处理的，所以不支持 `/`打头的这种绝对路径
        URL systemResource = ClassLoader.getSystemResource("com/fsx/maintest/demo.properties");
        System.out.println(systemResource); ///demo-war/target/classes/com/fsx/maintest/demo.properties

		//后面已经有一个/了，说明就是直接从classpath/目录下查找~~~~ 所以我们自己不需要再写/ 了
        systemResource = ClassLoader.getSystemResource("");
        System.out.println(systemResource); // .../demo-war/target/classes/  获取类路径的地址

        InputStream systemResourceAsStream = ClassLoader.getSystemResourceAsStream("com/fsx/maintest/demo.properties");
        System.out.println(systemResourceAsStream); //java.io.BufferedInputStream@46f5f779

        // 若要加载类路径下的文件，显然这个就更加的方便些~~~ 不需要 "/"了
        System.out.println(ClassLoader.getSystemResourceAsStream("spring.properties")); //java.io.BufferedInputStream@5a42bbf4
    }

// 实例方法
classLoader.getResources(META-INF/spring.factories)
// 静态方法
ClassLoader.getSystemResources(META-INF/spring.factories)

    public static void main(String[] args) throws FileNotFoundException {
        // 显然通过这种间接的方式去构建一个File对象也是可行的 只是比较绕
        String filePath = ClassLoader.getSystemResource("spring.properties").getFile();
        System.out.println(new File(filePath).exists()); //true
	}

    public static void main(String[] args) {
        // 使用带盘符的绝对路径  显然这个把项目名以及target都暴露出来了
        File file = new File("E:\\work\\remotegitcheckoutproject\\myprojects\\java\\demo-war\\target\\classes\\com\\fsx\\maintest\\demo.properties");
        System.out.println(file.exists()); //true 这里是返回true，表示找到了这个文件

        // 另外一种方式，也可以这么写
        file = new File(System.getProperty("user.dir") + "\\target\\classes\\com\\fsx\\maintest\\demo.properties");
        System.out.println(file.exists()); // true
    }

    public static void main(String[] args) {
        // 采用相对路径   很显然，这里相对的是工程~~~
        File file = new File("my.properties");
        System.out.println(file.exists()); //true
    }

    public static void main(String[] args) {
        // 采用相对路径   很显然，这里相对的是工程~~~（这里也得把/demo-war/target/classes这些写出来，非常不优雅）
        File file = new File("../demo-war/target/classes/com/fsx/maintest/demo.properties");
        System.out.println(file.exists()); //true
    }

public interface Resource extends InputStreamSource {

	//返回Resource所指向的底层资源是否存在 
	boolean exists();
	//返回当前Resource代表的底层资源是否可读 
	default boolean isReadable() {
		return true;
	}
	//返回Resource资源文件是否已经打开，**如果返回true，则只能被读取一次然后关闭以避免内存泄漏；**常见的Resource实现一般返回false 
	default boolean isOpen() {
		return false;
	}
	//@since 5.0  参见：getFile()
	default boolean isFile() {
		return false;
	}
	//如果当前Resource代表的底层资源能由java.util.URL代表，则返回该URL，否则抛出IO异常 
	URL getURL() throws IOException;
	//如果当前Resource代表的底层资源能由java.util.URI代表，则返回该URI，否则抛出IO异常 
	URI getURI() throws IOException;
	//如果当前Resource代表的底层资源能由java.io.File代表，则返回该File，否则抛出IO异常 
	File getFile() throws IOException;
	
	//@since 5.0  用到了nio得Channel相关的
	default ReadableByteChannel readableChannel() throws IOException {
		return Channels.newChannel(getInputStream());
	}
	// 返回当前Resource代表的底层文件资源的长度，一般是值代表的文件资源的长度
	long contentLength() throws IOException;
	//返回当前Resource代表的底层资源的最后修改时间
	long lastModified() throws IOException;

	// 用于创建相对于当前Resource代表的底层资源的资源
	// 比如当前Resource代表文件资源“d:/test/”则createRelative（“test.txt”）将返回表文件资源“d:/test/test.txt”Resource资源。 
	Resource createRelative(String relativePath) throws IOException;
	
	//返回当前Resource代表的底层文件资源的文件路径，比如File资源“file://d:/test.txt”将返回“d:/test.txt”，而URL资源http://www.javass.cn将返回“”，因为只返回文件路径。 
	@Nullable
	String getFilename();
	//返回当前Resource代表的底层资源的描述符，通常就是资源的全路径（实际文件名或实际URL地址）
	String getDescription();
}

InputStream getInputStream() throws IOException;

	String getPathWithinContext(); //  返回上下文内的路径  

    boolean isWritable();  //  是否可写
    OutputStream getOutputStream() throws IOException; //返回资源的写入流

public abstract class AbstractResource implements Resource {

	// File或者流  都从此处判断
	// 这里属于通用实现，子类大都会重写这个方法的~~~~~~
	@Override
	public boolean exists() {
		// Try file existence: can we find the file in the file system?
		try {
			return getFile().exists();
		} catch (IOException ex) {
			// Fall back to stream existence: can we open the stream?
			try {
				InputStream is = getInputStream();
				is.close();
				return true;
			} catch (Throwable isEx) {
				return false;
			}
		}
	}

	// 默认都是可读得。大多数子类都会复写
	@Override
	public boolean isReadable() {
		return true;
	}
	// 默认不是打开的。 比如InputStreamResource就会让他return true
	@Override
	public boolean isOpen() {
		return false;
	}
	// 默认不是一个File
	@Override
	public boolean isFile() {
		return false;
	}

	// 可议看到getURI方法一般都是依赖于getURL的
	@Override
	public URL getURL() throws IOException {
		throw new FileNotFoundException(getDescription() + " cannot be resolved to URL");
	}
	@Override
	public URI getURI() throws IOException {
		URL url = getURL();
		try {
			return ResourceUtils.toURI(url);
		} catch (URISyntaxException ex) {
			throw new NestedIOException("Invalid URI [" + url + "]", ex);
		}
	}

	@Override
	public File getFile() throws IOException {
		throw new FileNotFoundException(getDescription() + " cannot be resolved to absolute file path");
	}
	@Override
	public ReadableByteChannel readableChannel() throws IOException {
		return Channels.newChannel(getInputStream());
	}
	// 调用此方法，也相当于吧流的read了一遍，请务必注意
	@Override
	public long contentLength() throws IOException {
		InputStream is = getInputStream();
		try {
			long size = 0;
			byte[] buf = new byte[255];
			int read;
			while ((read = is.read(buf)) != -1) {
				size += read;
			}
			return size;
		} finally {
			try {
				is.close();
			} catch (IOException ex) {
			}
		}
	}
	@Override
	public long lastModified() throws IOException {
		long lastModified = getFileForLastModifiedCheck().lastModified();
		if (lastModified == 0L) {
			throw new FileNotFoundException(getDescription() +
					" cannot be resolved in the file system for resolving its last-modified timestamp");
		}
		return lastModified;
	}
	// 只有一个子类：`AbstractFileResolvingResource`覆盖了此方法
	protected File getFileForLastModifiedCheck() throws IOException {
		return getFile();
	}
	@Override
	public Resource createRelative(String relativePath) throws IOException {
		throw new FileNotFoundException("Cannot create a relative resource for " + getDescription());
	}
	@Override
	@Nullable
	public String getFilename() {
		return null;
	}
	// 这些基础方法，很多子类也都有重写~~~~ 但是一般来说关系不大
	@Override
	public String toString() {
		return getDescription();
	}
	// 比较的就是getDescription()
	@Override
	public boolean equals(Object obj) {
		return (obj == this ||
			(obj instanceof Resource && ((Resource) obj).getDescription().equals(getDescription())));
	}
	// getDescription()的hashCode
	@Override
	public int hashCode() {
		return getDescription().hashCode();
	}

}

// @since 1.2.3
public class ByteArrayResource extends AbstractResource {
	private final byte[] byteArray;
	private final String description;
	...	
	@Override
	public InputStream getInputStream() throws IOException {
		return new ByteArrayInputStream(this.byteArray);
	}
}

    public static void main(String[] args) {
        Resource resource = new ByteArrayResource("Hello!Spring!你好!".getBytes());
        if (resource.exists()) {
            dumpStream(resource); //Hello!Spring!你好!
        }
    }

    // 这个其实可以把这个resource写到本地文件，本处就不麻烦了，直接sout输出看一看即可~~~~
    private static void dumpStream(Resource resource) {
        InputStream is = null;
        try {
            //1.获取文件资源
            is = resource.getInputStream();
            //2.读取资源
            byte[] descBytes = new byte[is.available()];
            is.read(descBytes);
            System.out.println(new String(descBytes));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //3.关闭资源
                is.close();
            } catch (IOException e) {
            }
        }
    }

public class FileSystemResource extends AbstractResource implements WritableResource {
	private final File file;
	private final String path;
	...
	// 使用了Files 基于JDK1.7了
	@Override
	public InputStream getInputStream() throws IOException {
		try {
			return Files.newInputStream(this.file.toPath());
		}
		catch (NoSuchFileException ex) {
			throw new FileNotFoundException(ex.getMessage());
		}
	}
	@Override
	public boolean isReadable() {
		return (this.file.canRead() && !this.file.isDirectory());
	}
	
	// 读写
	@Override
	public ReadableByteChannel readableChannel() throws IOException {
		try {
			return FileChannel.open(this.file.toPath(), StandardOpenOption.READ);
		}
		catch (NoSuchFileException ex) {
			throw new FileNotFoundException(ex.getMessage());
		}
	}
	@Override
	public WritableByteChannel writableChannel() throws IOException {
		return FileChannel.open(this.file.toPath(), StandardOpenOption.WRITE);
	}
}

public class InputStreamResource extends AbstractResource {

	private final InputStream inputStream;
	private final String description;
	private boolean read = false;

	@Override
	public InputStream getInputStream() throws IOException, IllegalStateException {
		if (this.read) {
			throw new IllegalStateException("InputStream has already been read - " +
					"do not use InputStreamResource if a stream needs to be read multiple times");
		}
		this.read = true;
		return this.inputStream;
	}
}

	// dumpStream方法请参照上文
    public static void main(String[] args) {
        ByteArrayInputStream bis = new ByteArrayInputStream("Hello World!".getBytes());
        Resource resource = new InputStreamResource(bis);
        if (resource.exists()) {
            dumpStream(resource); //Hello World!
        }
    }

// @since 1.2.6
public class DescriptiveResource extends AbstractResource {
	@Override
	public InputStream getInputStream() throws IOException {
		throw new FileNotFoundException(
				getDescription() + " cannot be opened because it does not point to a readable resource");
	}
}

// @since 3.0
public abstract class AbstractFileResolvingResource extends AbstractResource {
}

    public static void main(String[] args) throws IOException {
        UrlResource resource = new UrlResource("http://www.springframework.org/schema/beans/spring-beans.xsd");
        if (resource.exists()) {
            File file = resource.getFile();
            System.out.println(file); //报错 java.io.FileNotFoundException: URL [xxx] cannot be resolved to absolute file path because it

            dumpStream(resource); //输出这个.xsd文件的所有的内容...
        }
    }

//@since 5.0.2 显然它出现得很晚。 并且还实现了WritableResource接口
public class FileUrlResource extends UrlResource implements WritableResource {
	@Nullable
	private volatile File file;
	
	public FileUrlResource(URL url) {
		super(url);
	}
	// 注意：若使用此构造函数，此处使用的是file协议  而UrlResource采用的是http协议，此处需注意
	// 若想http，请用上面构造。自己构造一个URL对象吧
	public FileUrlResource(String location) throws MalformedURLException {
		super(ResourceUtils.URL_PROTOCOL_FILE, location);
	}
	@Override
	public File getFile() throws IOException {
		File file = this.file;
		if (file != null) {
			return file;
		}
		file = super.getFile();
		this.file = file;
		return file;
	}

	@Override
	public boolean isWritable() {
		try {
			URL url = getURL();
			if (ResourceUtils.isFileURL(url)) {
				// Proceed with file system resolution
				File file = getFile();
				return (file.canWrite() && !file.isDirectory());
			}
			else {
				return true;
			}
		}
		catch (IOException ex) {
			return false;
		}
	}
	@Override
	public OutputStream getOutputStream() throws IOException {
		return Files.newOutputStream(getFile().toPath());
	}

	@Override
	public WritableByteChannel writableChannel() throws IOException {
		return FileChannel.open(getFile().toPath(), StandardOpenOption.WRITE);
	}
}

    public static void main(String[] args) throws IOException {
        //FileUrlResource resource = new FileUrlResource("http://www.springframework.org/schema/beans/spring-beans.xsd");
        FileUrlResource resource = new FileUrlResource(new URL("http://www.springframework.org/schema/beans/spring-beans.xsd"));
        if (resource.exists()) {
            dumpStream(resource); //输出这个.xsd文件的所有的内容...
        }
    }

public class ClassPathResource extends AbstractFileResolvingResource {
	private final String path;'
	@Nullable
	private ClassLoader classLoader;
	@Nullable
	private Class<?> clazz; // 它还可以自己指定clazz

	@Nullable
	public final ClassLoader getClassLoader() {
		return (this.clazz != null ? this.clazz.getClassLoader() : this.classLoader);
	}
	@Override
	public boolean exists() {
		return (resolveURL() != null);
	}
	// 这是它最重要的一个方法，依赖于JDK的实现嘛
	@Override
	public InputStream getInputStream() throws IOException {
		InputStream is;
		if (this.clazz != null) {
			is = this.clazz.getResourceAsStream(this.path);
		}
		else if (this.classLoader != null) {
			is = this.classLoader.getResourceAsStream(this.path);
		}
		else {
			is = ClassLoader.getSystemResourceAsStream(this.path);
		}
		if (is == null) {
			throw new FileNotFoundException(getDescription() + " cannot be opened because it does not exist");
		}
		return is;
	}
	@Override
	public URL getURL() throws IOException {
		URL url = resolveURL();
		if (url == null) {
			throw new FileNotFoundException(getDescription() + " cannot be resolved to URL because it does not exist");
		}
		return url;
	}
	// 非常简单 直接解析path即可
	@Override
	@Nullable
	public String getFilename() {
		return StringUtils.getFilename(this.path);
	}
}

    public static void main(String[] args) {
        //ClassPathResource resource = new ClassPathResource("spring.properties");

        // 如果是要获取指定类所在包下的文件，建议指定class
        ClassPathResource resource = new ClassPathResource("demo.properties",Main.class);
        if (resource.exists()) {
            dumpStream(resource); //name=fangshixiang  或者 demo=value
        }
    }

public class ServletContextResource extends AbstractFileResolvingResource implements ContextResource {
	// 持有servletContext的引用
	private final ServletContext servletContext;
	private final String path;
	
	// 只提供这一个构造函数，来构造一个资源
	public ServletContextResource(ServletContext servletContext, String path) {
		// check ServletContext
		Assert.notNull(servletContext, "Cannot resolve ServletContextResource without ServletContext");
		this.servletContext = servletContext;

		// check path
		Assert.notNull(path, "Path is required");
		String pathToUse = StringUtils.cleanPath(path);
		if (!pathToUse.startsWith("/")) {
			pathToUse = "/" + pathToUse;
		}
		this.path = pathToUse;
	}

	// 我们发现，它底层都是依赖于servletContext.getResource  getResourceAsStream这些方法去找到资源的
	@Override
	public boolean isFile() {
		try {
			URL url = this.servletContext.getResource(this.path);
			if (url != null && ResourceUtils.isFileURL(url)) {
				return true;
			}
			else {
				return (this.servletContext.getRealPath(this.path) != null);
			}
		}
		catch (MalformedURLException ex) {
			return false;
		}
	}
	@Override
	public InputStream getInputStream() throws IOException {
		InputStream is = this.servletContext.getResourceAsStream(this.path);
		if (is == null) {
			throw new FileNotFoundException("Could not open " + getDescription());
		}
		return is;
	}
	// 这个有点意思。如果URL就是File类型。就ok
	// 如果不是file类型，就根据绝对路径 new一个出来
	@Override
	public File getFile() throws IOException {
		URL url = this.servletContext.getResource(this.path);
		if (url != null && ResourceUtils.isFileURL(url)) {
			// Proceed with file system resolution...
			return super.getFile();
		}
		else {
			String realPath = WebUtils.getRealPath(this.servletContext, this.path);
			return new File(realPath);
		}
	}
	
}