Spring源码：Resource

た入场券 2023-06-21 05:58 7阅读 0赞

**目录**

1、Resource 介绍

2、ResourceLoader 介绍

--------------------

# 1、Resource 概述 #

Spring中用 Resource 接口封装底层资源，统一管理。Resource实现有：文件（FileSystemResource）、ClassPath资源（ClassPathResource）、URL资源（URLResource）、InputStream资源（InputStreamResource）、Byte数组（ByteArrayResource）等。

Resource源码：

package org.springframework.core.io;
    
    import java.io.File;
    import java.io.IOException;
    import java.net.URI;
    import java.net.URL;
    import java.nio.channels.Channels;
    import java.nio.channels.ReadableByteChannel;
    import org.springframework.lang.Nullable;
    
    public interface Resource extends InputStreamSource {
        boolean exists();
    
        default boolean isReadable() {
            return this.exists();
        }
    
        default boolean isOpen() {
            return false;
        }
    
        default boolean isFile() {
            return false;
        }
    
        URL getURL() throws IOException;
    
        URI getURI() throws IOException;
    
        File getFile() throws IOException;
    
        default ReadableByteChannel readableChannel() throws IOException {
            return Channels.newChannel(this.getInputStream());
        }
    
        long contentLength() throws IOException;
    
        long lastModified() throws IOException;
    
        Resource createRelative(String var1) throws IOException;
    
        @Nullable
        String getFilename();
    
        String getDescription();
    }

# 2、示例 ClassPathResource #

ClassPathResource 源码：

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package org.springframework.core.io;
    
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.URL;
    import org.springframework.lang.Nullable;
    import org.springframework.util.Assert;
    import org.springframework.util.ClassUtils;
    import org.springframework.util.ObjectUtils;
    import org.springframework.util.StringUtils;
    
    public class ClassPathResource extends AbstractFileResolvingResource {
        // 文件路径，例如 application-context.xml文件
        private final String path;
        // 类加载器
        @Nullable
        private ClassLoader classLoader;
        @Nullable
        private Class<?> clazz;
    
        public ClassPathResource(String path) {
            this(path, (ClassLoader)null);
        }
    
        // 构造函数
        public ClassPathResource(String path, @Nullable ClassLoader classLoader) {
            Assert.notNull(path, "Path must not be null");
            String pathToUse = StringUtils.cleanPath(path);
            if(pathToUse.startsWith("/")) {
                pathToUse = pathToUse.substring(1);
            }
            // 初始化文件路径
            this.path = pathToUse;
            // 指定类加载器，如果没有传类加载器，则用默认的类加载器，翻看源码是：Thread.currentThread().getContextClassLoader()
            this.classLoader = classLoader != null?classLoader:ClassUtils.getDefaultClassLoader();
        }
    
        public ClassPathResource(String path, @Nullable Class<?> clazz) {
            Assert.notNull(path, "Path must not be null");
            this.path = StringUtils.cleanPath(path);
            this.clazz = clazz;
        }
    
        /** @deprecated */
        @Deprecated
        protected ClassPathResource(String path, @Nullable ClassLoader classLoader, @Nullable Class<?> clazz) {
            this.path = StringUtils.cleanPath(path);
            this.classLoader = classLoader;
            this.clazz = clazz;
        }
    
        // 获取配置文件路径
        public final String getPath() {
            return this.path;
        }
        // 获取类加载器
        @Nullable
        public final ClassLoader getClassLoader() {
            return this.clazz != null?this.clazz.getClassLoader():this.classLoader;
        }
        // 判断文件是否存在
        public boolean exists() {
            return this.resolveURL() != null;
        }
    
        @Nullable
        protected URL resolveURL() {
            return this.clazz != null?this.clazz.getResource(this.path):(this.classLoader != null?this.classLoader.getResource(this.path):ClassLoader.getSystemResource(this.path));
        }
        // 此方法继承自InputStreamSource，ClassPathResource实现了具体逻辑
        // 主要就是通过类加载器加载配置文件到内存 InputStream中
        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(this.getDescription() + " cannot be opened because it does not exist");
            } else {
                return is;
            }
        }
    
        public URL getURL() throws IOException {
            URL url = this.resolveURL();
            if(url == null) {
                throw new FileNotFoundException(this.getDescription() + " cannot be resolved to URL because it does not exist");
            } else {
                return url;
            }
        }
    
        public Resource createRelative(String relativePath) {
            String pathToUse = StringUtils.applyRelativePath(this.path, relativePath);
            return this.clazz != null?new ClassPathResource(pathToUse, this.clazz):new ClassPathResource(pathToUse, this.classLoader);
        }
    
        @Nullable
        public String getFilename() {
            return StringUtils.getFilename(this.path);
        }
    
        public String getDescription() {
            StringBuilder builder = new StringBuilder("class path resource [");
            String pathToUse = this.path;
            if(this.clazz != null && !pathToUse.startsWith("/")) {
                builder.append(ClassUtils.classPackageAsResourcePath(this.clazz));
                builder.append('/');
            }
    
            if(pathToUse.startsWith("/")) {
                pathToUse = pathToUse.substring(1);
            }
    
            builder.append(pathToUse);
            builder.append(']');
            return builder.toString();
        }
    
        public boolean equals(@Nullable Object other) {
            if(this == other) {
                return true;
            } else if(!(other instanceof ClassPathResource)) {
                return false;
            } else {
                ClassPathResource otherRes = (ClassPathResource)other;
                return this.path.equals(otherRes.path) && ObjectUtils.nullSafeEquals(this.classLoader, otherRes.classLoader) && ObjectUtils.nullSafeEquals(this.clazz, otherRes.clazz);
            }
        }
    
        public int hashCode() {
            return this.path.hashCode();
        }
    }

如以上代码中注释的，ClassPathResource 初始化时主要保存 classpath路径下配置文件路径，选择类加载器，然后在继承自 InputStreamResource 的方法 getInputStream中 通过 类加载器加载配置文件到内存（InputStream）中，供Reader使用。

[ClassPathResource获取InputStream流][ClassPathResource_InputStream]

# 3、ResourceLoader 介绍 #

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

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

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

ResourceLoader 源码：

package org.springframework.core.io;
    
    import org.springframework.lang.Nullable;
    
    public interface ResourceLoader {
        String CLASSPATH_URL_PREFIX = "classpath:";
    
        // 用于根据提供的location参数返回相应的Resource对象
        Resource getResource(String var1);
    
        // 返回加载这些Resource的ClassLoader
        @Nullable
        ClassLoader getClassLoader();
    }

[ClassPathResource_InputStream]: https://blog.csdn.net/ruanhao1203/article/details/103447084