Class Loading -- 04 -- JVM类加载机制（三、类加载器）

本文链接：https://blog.csdn.net/Goodbye_Youth/article/details/102539853

本文深入探讨Java虚拟机(JVM)的类加载机制，包括类与类加载器的关系、类加载器的种类（启动类加载器、扩展类加载器、应用程序类加载器），以及自定义类加载器的实现方式。同时，讲解了loadClass()与findClass()方法在类加载过程中的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

原文链接：Class Loading – 04 – JVM类加载机制（三、类加载器）

接着我们再来详细地了解下虚拟机中的类加载器

一、类与类加载器

对于任意一个类，都需要由加载它的类加载器和这个类本身来确立其在 Java 虚拟机中的唯一性

每一个类加载器，都拥有一个独立的类名称空间，通俗地讲：即比较两个类是否 “相等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，不然即使这两个类来源于同一个 Class 文件，被同一个虚拟机加载，但只要加载它们的类加载器不同，那么这两个类就必定不相等

public class ClassLoaderTest {

    public static void main(String[] args) throws Exception {
        ClassLoader myLoader = new ClassLoader() {
            @Override
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                try {
                    String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
                    InputStream is = getClass().getResourceAsStream(fileName);
                    if (null == is) {
                        return super.loadClass(name);
                    }
                    byte[] data = new byte[is.available()];
                    is.read(data);
                    return defineClass(name, data, 0, data.length);
                } catch (IOException e) {
                    throw new ClassNotFoundException(name);
                }
            }
        };

        Object obj = myLoader.loadClass("classloader.Test").newInstance();
        System.out.println(obj.getClass()); // class classloader.Test
        System.out.println(obj instanceof Test); // false
    }
}

如上所示，我们自定义了一个简单的类加载器，通过它来加载同一路径下的 Test.class 文件
根据自定义加载器得到的对象，在与 Test 类做所属类型检查时返回了 false，这是因为虚拟机中存在了两个 Test 类，一个是由系统应用程序类加载器加载的，另一个是由我们自定义的类加载器加载的，因此虽然都来自同一个 Class 文件，但依然是两个不同的类，做对象所属类型检查时结果自然为 false

二、类加载器的种类

启动类加载器 (Bootstrap ClassLoader)
- 用于加载在 <JAVA_HOME>\lib 目录下的；或者由 -Xbootclasspath 参数指定路径中的，并由虚拟机识别的 (仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载) 的类库
扩展类加载器 (Extension ClassLoader)
- 用于加载 <JAVA_HOME>\lib\ext 目录中的；或者由 java.ext.dirs 系统变量指定路径中的类库
应用程序类加载器 (Application ClassLoader)
- 用于加载用户路径 (ClassPath) 上所指定的类库

三、自定义类加载器

在实现自定义类加载器的过程中，我们需要了解两个关键的函数，通过覆盖这两个函数，就可以自定义类加载的行为
- findClass(String name)
  - 加载指定名称的 Class 文件
- defineClass(byte[] b, int off, int len)
  - 将字节数组转换为 Class 对象实例
- 总的来说就是：findClass 方法按照指定的名称去加载 Class 文件，然后再调用 defineClass 方法去解析定义字节流，进而返回一个 Class 对象

示例如下

Wali.java

public class Wali {

	static {
		System.out.println("Hello Wail");
	}
}

MyClassLoader.java

public class MyClassLoader extends ClassLoader {

    private String path;
    private String classLoaderName;

    public MyClassLoader(String path, String classLoaderName) {
        this.path = path;
        this.classLoaderName = classLoaderName;
    }

    // 用于寻找类文件
    @Override
    protected Class<?> findClass(String name) {
        byte[] data = loadClassData(name);
        if (data != null) {
            return defineClass(name, data, 0, data.length);
        }
        return null;
    }

    // 用于加载类文件
    private byte[] loadClassData(String name) {
        name = path + name + ".class";
        InputStream is = null;
        ByteArrayOutputStream bos = null;
        try {
            is = new FileInputStream(new File(name));
            bos = new ByteArrayOutputStream();
            int length;
            byte[] data = new byte[1024];
            while ((length = is.read(data)) != -1) {
                bos.write(data, 0, length);
            }
            return bos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                if (is != null) {
                    is.close();
                }
                if (bos != null) {
                    bos.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

ClassLoaderChecker.java
```
public class ClassLoaderChecker {

    public static void main(String[] args) throws Exception {
        MyClassLoader m = new MyClassLoader("C:\\Users\\XJ\\Desktop\\", "MyClassLoader");
        Class clazz = m.loadClass("Wali");
        System.out.println(clazz.getClassLoader()); // com.xj.classloader.MyClassLoader@3a71f4dd
        clazz.newInstance(); // Hello Wali
    }
}
```
- 如上所示，编写了一个名为 Wali 的类，使用 javac 进行编译，生成 Wali.class 文件，然后再自定义一个名为 MyClassLoader 的类加载器，通过覆盖 findClass() 方法来加载指定目录下的 Class 文件，返回一个二进制数据字节流 (即一个 byte 数组)，最后将其传递给 defineClass() 方法去解析定义，最后返回一个 Class 对象
- 在实现 findClass() 方法的时候，我们可以在自定义的目录下去加载 Class 文件，而且通过 defineClass() 方法我们还可以知道，只要传入的是二进制的数据流，并且是合法的，我们便能通过不同的形式去加载，例如：
  - 使用 findClass() 方法去访问某个远程网络，进而获取二进制数据流，生成我们需要的类
  - 可以对某些敏感的 Class 文件进行加密，在 findClass() 方法里面对其进行解密
  - 可以对生成的二进制数据流进行处理，给类添加信息 (ASM：JAVA字节码分析、创建和修改的开源应用框，主要用于改造二进制数据流的行为)

四、loadClass() 与 findClass() 的作用

protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
    synchronized (getClassLoadingLock(name)) {
        // First, check if the class has already been loaded
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }

            if (c == null) {
                // If still not found, then invoke findClass in order
                // to find the class.
                long t1 = System.nanoTime();
                c = findClass(name);

                // this is the defining class loader; record the stats
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

protected Class<?> findClass(String name) throws ClassNotFoundException {
    throw new ClassNotFoundException(name);
}

如上所示，由源码可知，loadClass() 方法实现了双亲委派模型，大致流程如下
- 检查指定名称的类是否已经被加载过，如果加载过了，则直接返回
- 如果此类没有被加载过，则再判断是否存在父类加载器，如果有，则调用父类加载器来加载；如果没有，则调用启动类加载器 (Bootstrap ClassLoader) 来加载
- 如果父类加载器或启动类加载器都无法找到此类，则调用当前类加载器的 findClass() 方法来找到此类进行加载 (默认的 findClass() 只是一个空方法，直接抛出 ClassNotFoundException 异常，因此在自定义类加载器中，我们需要覆盖此方法来完成类的加载)
loadClass()
- 加载指定名称的 Class 文件
findClass()
- 查找指定名称的 Class 文件

五、归纳总结

类加载器
- 对于任意一个类，通过加载它的类加载器和这个类本身，可以确立其在 Java 虚拟机中的唯一性
- 每一个类加载器，都拥有一个独立的类名称空间
类加载器种类
- 启动类加载器 (Bootstrap ClassLoader)
- 扩展类加载器 (Extension ClassLoader)
- 应用程序类加载器 (Application ClassLoader)