Class和ClassLoader的getResource方法详解与源码分析

classpath

Java中有两个classpath，一个是bootstrap classpath，另一个是classpath。

classpath有如下两种形式 [4]：

• JAR files（JAR文件的全路径），and
• Paths to the top of package hierarchies.（顶级目录路径）

bootrap classpath

bootstrap classpath对应于启动类加载器，根据类加载的双亲委派模型，Java程序运行时首先会由启动类加载器加载bootstrap classpath下的类和Jar包中的类。bootstrap classpath可以通过-Xbootclasspath JVM参数来指定。在Java代码中，我们可以通过System.getProperty("sun.boot.class.path")来获取bootstrap classpath。

Java中的getResource等资源加载方法也遵循双亲委派模型，首先会委托给父类加载器加载资源。委托到启动类加载器时，启动类加载器会从bootstrap classpath对应的jar包或目录中加载资源。因此放在bootstrap classpath中的资源也能够被加载。

classpath

下面是Java官方教程对classpath的定义：

The CLASSPATH variable is one way to tell applications, including the JDK tools, where to look for user classes. (Classes that are part of the JRE, JDK platform, and extensions should be defined through other means, such as the bootstrap class path or the extensions directory.)

classpath用于告诉Java程序从哪里加载用户类以及用户资源。（JRE、JDK本身的类，以及扩展类应该通过其他方式来定位，例如bootstrap class path 或 扩展目录。）

所以说，classpath是用来定位用户自定义的类和资源的。

在Java代码中，可以通过System.getProperty("java.class.path")来获取当前的classpath。

extention directory

extention directory也就是扩展目录，是Java程序加载扩展类的目录，可以通过System.getProperty("java.ext.dirs")来获取。

在资源加载的过程中，如果启动类加载器无法加载，则扩展类加载器会尝试从扩展目录中的jar包中加载。

资源的访问方式

资源(resource) 就是我们的程序需要访问的数据，例如图片、文本、视频、音频等等。

访问资源有两种方式：

• Location dependent
• Location Independent

Location dependent

所谓Location Dependent，就是我们对资源的访问方式受程序所在位置的影响。

例如，在Java中，使用本机绝对路径访问文件时，就是一种Location Dependent的访问方法，代码如下：

File file = new File("/root/project/resource/config.xml")

如果项目中使用上述方式读取文件，当项目在其他目录或其他机器上部署和运行时，就需要修改上述代码中的文件路径，因此上述用法是LocationDependent的。

注意：

并不是说通过File类来访问资源一定是Location Dependent的，我们借助File也可以实现Location Independent的访问，例如我们可以给File构造器传入相对路径，这里的相对路径是相对于当前工作目录（System.getProperty("user.dir")）的[3]，所以如果要访问的资源是项目的一部分，File类搭配相对路径也可以实现Location Independent的访问。

Location Independent

实现Location Independent的资源读取最常用的就是Class或ClassLoader类中的如下方法：

• URL getResource(String name)
• InputStream getResourceAsStream(String name)
• Enumeration<URL> getResources(String name)
• getSystemResource, getSystemResources, getSystemResourceAsStream

其中，前两个方法是Class和ClassLoader类都有的，后面的方法只有ClassLoader类有。

借助这些方法，可以实现从classpath下读取资源，或者相对于当前class文件所在的目录读取资源。

---

借助Class和ClassLoader都可以获取资源，并且后面分析源码可以看到，Class类获取资源的方法最终会调用ClassLoader类中对应的方法，那么，这两个类中获取资源的方法的区别在哪里呢？

区别在于ClassLoader类中的这两个方法仅支持相对于classpath的路径（开头不能加/，加了就获取不到classpath下的文件了），而Class类中的这两个方法除了支持相对于classpath的路径外（以/开头），还支持相对于当前class文件所在目录的路径（开头不加/）。

---

下面举一个例子，项目的目录结构如下图所示：

其中，xxx/target/classes/ 是 classpath之一。尝试获取resources目录下config.xml文件的代码及其运行结果如下：

public class GetResourceTest {
    public static void main(String[] args) {
        // 获取不到, 因为是相对于xxx/target/classes/com/resourcetest/的路径
        URL resource1 = GetResourceTest.class.getResource("config.xml");
        // 下面3个能获取到, 因为是相对于classpath的路径
        URL resource2 = GetResourceTest.class.getResource("/config.xml");
        URL resource3 = GetResourceTest.class.getClassLoader().getResource("config.xml");
        URL resource4 = GetResourceTest.class.getClassLoader().getResource("./config.xml");
        // 获取不到，无法被解析为相对于classpath的路径
        URL resource5 = GetResourceTest.class.getClassLoader().getResource("/config.xml");

        System.out.println(resource1); // null
        System.out.println(resource2); // 非null
        System.out.println(resource3); // 非null
        System.out.println(resource4); // 非null
        System.out.println(resource5); // null
    }
}

源码解析

可以参考一下[5]

ClassLoader.getResource

先看ClassLoader.getResource，其源码如下：

public URL getResource(String name) {
    URL url;
    if (parent != null) {
        url = parent.getResource(name);
    } else {
        url = getBootstrapResource(name);
    }
    if (url == null) {
        url = findResource(name);
    }
    return url;
}

可以看到，和类加载过程类似，资源的加载也使用双亲委派模型，首先委托给父类加载器进行加载。

ClassLoader和URLClassPath

每个类加载器都有与之对应的 URLClassPath：

• 应用(系统)类加载器 AppClassLoader 和 扩展类加载器 ExtClassLoader 都继承自 URLClassLoader，URLClassLoader有一个URLClassPath字段：

  

• 启动类加载器对应的是null，它对应的URLClassPath是通过getBootstrapClassPath()方法获取的，参考ClassLoader.getBootstrapClassPath方法

  private static URL getBootstrapResource(String name) {
      URLClassPath ucp = getBootstrapClassPath();
      Resource res = ucp.getResource(name);
      return res != null ? res.getURL() : null;
  }
  

  跟踪源码可以发现，getBootstrapClassPath()最终获取的是sun.misc.Launcher.BootClassPathHolder.bcp字段，该字段的赋值过程如下：

  private static class BootClassPathHolder {
      static final URLClassPath bcp;
      static {
          URL[] urls;
          if (bootClassPath != null) {
              urls = AccessController.doPrivileged(
                  new PrivilegedAction<URL[]>() {
                      public URL[] run() {
                          File[] classPath = getClassPath(bootClassPath); // bootClassPath即bootstrap classpath
                          int len = classPath.length;
                          // ...
                          return pathToURLs(classPath); // 将classPath转化为URL
                      }
                  }
              );
          } else {
              urls = new URL[0];
          }
          bcp = new URLClassPath(urls, factory);
      }
  }
  

URLClassPath和Loader

URLClassPath用于维护从JAR包或目录中加载类或资源的查找路径，这个路径由若干个URL组成（URL封装在了Loader里面，一个Loader对应一个URL）。

URLClassPath包括一个ArrayList<Loader> loaders字段，Loader是URLClassPath的内部类，顾名思义，Loader是用来从JAR包或目录中加载类或资源的，它用于加载资源的方法是findResource和getResource。注意，查看JarLoader和FileLoader的源码可以发现，findResource最终也会调用getResource：

Loader有两个实现类JarLoader和FileLoader，负责实际的资源加载任务，分别负责从JAR包和目录中加载资源。

每个Loader对应一个base URL，表示对应的JAR包或目录的URL。

Loader.getResource

上一小节提到了，Loader不管是用findResource还是getResource获取资源，最终都是调用getResource，因此下面对getResource进行分析。

下面是FileLoader.getResource的源码：

Resource getResource(final String name, boolean check) {
    final URL url;
    try {
        // 下面这句可以去掉base中的..
        URL normalizedBase = new URL(getBaseURL(), "."); // getBaseURL()获取Loader的base字段
        // 尝试将base 和 ClassLoader.getResource()传入的name拼接成一个完整的URL
        // 这里也就解释了为什么name如果开头是“/”则无法获取classpath下资源的原因，
        // 因为如果name开头是“/”，则拼接后的URL是“protocol://name”，则在下面那个if语句会直接返回null
        url = new URL(getBaseURL(), ParseUtil.encodePath(name, false));
        if (url.getFile().startsWith(normalizedBase.getFile()) == false) {
            return null;
        }
        if (check)
            URLClassPath.check(url);

        final File file;
        
        // 下面就是将base对应的路径和name对应的路径拼接起来，获得一个File对象
        
        // 如果name中存在..符号，表示定位到上一级目录，此时有可能出现dir和name
        // 组合后实际路径定位到base(dir)之外的情况，此时应该返回null
        if (name.indexOf("..") != -1) {
            // 这里的dir就是base对应的File对象
            file = (new File(dir, name.replace('/', File.separatorChar)))
                .getCanonicalFile();
            if ( !((file.getPath()).startsWith(dir.getPath())) ) {
                /* outside of base dir */
                // 如果通过..定位到了base(dir)之外，则返回null
                return null;
            }
        } else {
            file = new File(dir, name.replace('/', File.separatorChar));
        }
		
        // 判断文件存不存在
        if (file.exists()) {
            return new Resource() {
                public String getName() { return name; };
                public URL getURL() { return url; };
                public URL getCodeSourceURL() { return getBaseURL(); };
                public InputStream getInputStream() throws IOException
                { return new FileInputStream(file); };
                public int getContentLength() throws IOException
                { return (int)file.length(); };
            };
        }
    } catch (Exception e) {
        return null;
    }
    return null;
}

相信通过上述代码，我们就可以判断出下面的各个语句分别会输出什么结果了：

URL resource3 = GetResourceTest.class.getClassLoader().getResource("config.xml");
URL resource4 = GetResourceTest.class.getClassLoader().getResource("./config.xml");
URL resource5 = GetResourceTest.class.getClassLoader().getResource("/config.xml");
URL resource6 = GetResourceTest.class.getClassLoader().getResource("../config.xml");

URLClassPath.getResource/findResource

三种类加载器对资源的加载最终都是靠URLClassPath的getResource或findResoource方法完成的，而这两个方法又是借助loaders列表中的每一个loader来分别对指定的JAR包或目录进行资源加载的。

其中，应用类加载器和扩展类加载器会调用URLClassPath的findResource方法：

/**
     * Finds the resource with the specified name on the URL search path
     * or null if not found or security check fails.
     *
     * @param name      the name of the resource
     * @param check     whether to perform a security check
     * @return a <code>URL</code> for the resource, or <code>null</code>
     * if the resource could not be found.
     */
public URL findResource(String name, boolean check) {
    Loader loader;
    // 遍历loaders列表中的每一个loader，使用每个loader进行加载
    for (int i = 0; (loader = getLoader(i)) != null; i++) {
        URL url = loader.findResource(name, check);
        if (url != null) { return url; }
    }
    return null;
}

启动类加载器会调用URLClassPath的getResource方法，该方法的逻辑和findResource几乎一样：

/**
     * Finds the first Resource on the URL search path which has the specified
     * name. Returns null if no Resource could be found.
     *
     * @param name the name of the Resource
     * @param check     whether to perform a security check
     * @return the Resource, or null if not found
     */
public Resource getResource(String name, boolean check) {
    if (DEBUG) {
        System.err.println("URLClassPath.getResource(\"" + name + "\")");
    }

    Loader loader;
    for (int i = 0; (loader = getLoader(i)) != null; i++) {
        Resource res = loader.getResource(name, check);
        if (res != null) { return res;}
    }
    return null;
}

Loader和Classpath的对应关系

从前面的讨论中我们知道，Loader负责从Jar包或目录下加载资源，每个Loader对应一个base URL。

这个base URL其实来源于bootstrap classpath或classpath中的每一个条目对应的URL，以及扩展目录下的每一个jar包对应的URL。

以AppClassLoader的URLClassPath对象为例，假设程序的classpath有3个条目，记为a;b;c，则URLClassPath对象有3个Loader，这3个Loader的base URL分别为a,b,c对应的URL，分别负责从这三个地方加载资源。

Class.getResource

该方法和ClassLoader.getResource类似，并且是通过调用ClassLoader.getResource实现的。

public java.net.URL getResource(String name) {
    name = resolveName(name); // 对名称进行解析，开头有没有“/”
    ClassLoader cl = getClassLoader0(); // 获取当前Class对象的类加载器
    if (cl==null) {
        // A system class.
        return ClassLoader.getSystemResource(name);
    }
    return cl.getResource(name);
}

区别在于Class类中的该方法既可以处理相对于classpath的路径（开头是"/"），也可以处理相对于当前class文件所在目录的路径（开头不是"/"）。

ClassLoader.getSystemResource

public static URL getSystemResource(String name) {
    ClassLoader system = getSystemClassLoader(); // 获取系统（应用）类加载器
    if (system == null) {
        return getBootstrapResource(name);
    }
    return system.getResource(name);
}

什么时候会用到该方法呢，比如对于启动类加载器加载的类，根据双亲委派，如果这些类调用getResource则只能由启动类加载器加载资源。如果这些类想要使用用户classpath下的资源呢？此时就可以调用该方法，先获取系统类加载器，然后使用系统类加载器加载资源。

参考

[1] Accessing a Resource in Java

[2] Location-Independent Access to Resources — JDK官网

[3] How does Java resolve a relative path in new File()?

[4] What is a classpath and how do I set it?

[5] Java empty path convention, especially that used in ClassLoader.getResources