JVM 类加载器

最新推荐文章于 2024-09-10 08:00:00 发布

置顶 AllenC6

最新推荐文章于 2024-09-10 08:00:00 发布

阅读量261

点赞数 1

分类专栏： Java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/m0_37707561/article/details/122381028

版权

Java 专栏收录该内容

32 篇文章 3 订阅

订阅专栏

本文详细介绍了Java中的类加载器，包括自定义类加载器的示例和双亲委派模型的工作原理。双亲委派模型确保了类的唯一性，防止类的版本冲突，是Java程序稳定运行的关键。通过这个模型，类加载请求会先由顶层的启动类加载器处理，然后逐级向下，直到找到合适的类加载器完成加载。

摘要由CSDN通过智能技术生成

一、类加载器

虚拟机设计团队把类加载阶段中的“通过一个类的全限定名来获取描述此类的二进制字节流”这个动作放到Java虚拟机外部去实现，以便让应用程序自己决定如何去获取所需要的类。实现这个动作的代码模块称为“类加载器”。类加载器可以说是Java语言的一项创新，也是Java语言流行的重要原因之一，它最初是为了满足Java Applet的需求而开发出来的。虽然目前Java Applet技术基本上已经“死掉”，但类加载器却在类层次划分、OSGi、热部署、代码加密等领域大放异彩，成为了Java技术体系中一块重要的基石，可谓是失之桑榆，收之东隅。

二、类与类加载器

载阶段。对于任意一个类，都需要由加载它的类加载器和这个类本身一同确立其在Java虚拟机中的唯一性，每一个类加载器，都拥有一个独立的类名称空间。这句话可以表达得更通俗一些：比较两个类是否“相等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个Class文件，被同一个虚拟机加载，只要加载它们的类加载器不同，那这两个类就必定不相等。这里所指的“相等”，包括代表类的Class对象的equals（）方法、isAssignableFrom（）方法、isInstance（）方法的返回结果，也包括使用instanceof关键字做对象所属关系判定等情况。如果没有注意到类加载器的影响，在某些情况下可能会产生具有迷惑性的结果。

例:

package com.example.fragmentadaptertest.testjava;

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

public class TestF {

    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 (is == null) {
                        return super.loadClass(name);
                    }
                    byte[] b = new byte[is.available()];
                    is.read(b);
                    return defineClass(name, b, 0, b.length);
                } catch (
                        IOException e) {
                    throw new ClassNotFoundException(name);
                }
            }
        };
        Object obj = myLoader.loadClass("com.example.fragmentadaptertest.testjava.TestF").newInstance();
        System.out.println(obj.getClass());
        System.out.println(obj instanceof com.example.fragmentadaptertest.testjava.TestF);
    }
}

执行结果:

上面例子中构造了一个简单的类加载器，尽管很简单，但是对于这个演示来说还是够用了。它可以加载与自己在同一路径下的Class文件。我们使用这个类加载器去加载了一个名为“com.example.fragmentadaptertest.testjava.TestF”的类，并实例化了这个类的对象。两行输出结果中，从第一句可以看出，这个对象确实是类com.example.fragmentadaptertest.testjava.TestF实例化出来的对象，但从第二句可以发现，这个对象与类com.example.fragmentadaptertest.testjava.TestF做所属类型检查的时候却返回了false，这是因为虚拟机中存在了两个ClassLoaderTest类，一个是由系统应用程序类加载器加载的，另外一个是由我们自定义的类加载器加载的，虽然都来自同一个Class文件，但依然是两个独立的类，做对象所属类型检查时结果自然为false。

三、双亲委派模型

从 Java 虚拟机的角度来讲，只存在两种不同的类加载器：一种是启动类加载器

（ Bootstrap ClassLoader ），这个类加载器使用 C++ 语言实现，是虚拟机自身的一部分；另

一种就是所有其他的类加载器，这些类加载器都由 Java 语言实现，独立于虚拟机外部，并且

全都继承自抽象类 java.lang.ClassLoader 。从Java 开发人员的角度来看，类加载器还可以划分得更细致一些，绝大部分 Java 程序都会使用到以下3 种系统提供的类加载器。

1.启动类加载器（ Bootstrap ClassLoader ）：前面已经介绍过，这个类将器负责将存放在

＜JAVA_HOME＞ \lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中的，并且是虚拟机

识别的（仅按照文件名识别，如 rt.jar ，名字不符合的类库即使放在 lib 目录中也不会被加载）

类库加载到虚拟机内存中。启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加

载器时，如果需要把加载请求委派给引导类加载器，那直接使用 null 代替即可

ClassLoader.getClassLoader（）方法的代码片段:

    public ClassLoader getClassLoader() {
        ClassLoader cl = getClassLoader0();
        if (cl == null)
            return null;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            ClassLoader ccl = ClassLoader.getCallerClassLoader();
            if (ccl != null && ccl != cl && !cl.isAncestor(
                    ccl)) {
                sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
            }
        }
        return cl;
    }

2.扩展类加载器（Extension ClassLoader）：这个加载器由sun.misc.Launcher

$ExtClassLoader 实现，它负责加载＜ JAVA_HOME ＞ \lib\ext 目录中的，或者被 java.ext.dirs 系

统变量所指定的路径中的所有类库，开发者可以直接使用扩展类加载器。

3.应用程序类加载器（Application ClassLoader）：这个类加载器由sun.misc.Launcher $App-

ClassLoader 实现。由于这个类加载器是 ClassLoader 中的 getSystemClassLoader （）方法的返回

值，所以一般也称它为系统类加载器。它负责加载用户类路径（ ClassPath ）上所指定的类

库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一

般情况下这个就是程序中默认的类加载器。

我们的应用程序都是由这 3 种类加载器互相配合进行加载的，如果有必要，还可以加入

自己定义的类加载器。这些类加载器之间的关系:

类加载器之间的这种层次关系，称为类加载器的双亲委派模型（ Parents Delegation Model）。双亲委派模型要求除了顶层的启动类加载器外，其余的类加载器都应当有自己的父类加载器。这里类加载器之间的父子关系一般不会以继承（Inheritance ）的关系来实现，而是都使用组合（Composition ）关系来复用父加载器的代码。

类加载器的双亲委派模型在 JDK 1.2 期间被引入并被广泛应用于之后几乎所有的 Java 程序

中，但它并不是一个强制性的约束模型，而是 Java 设计者推荐给开发者的一种类加载器实现

方式。

双亲委派模型的工作过程是：如果一个类加载器收到了类加载的请求，它首先不会自己

去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是

如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父加载器反馈

自己无法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自

己去加载。

使用双亲委派模型来组织类加载器之间的关系，有一个显而易见的好处就是 Java 类随着

它的类加载器一起具备了一种带有优先级的层次关系。例如类 java.lang.Object ，它存放在

rt.jar 之中，无论哪一个类加载器要加载这个类，最终都是委派给处于模型最顶端的启动类加

载器进行加载，因此 Object 类在程序的各种类加载器环境中都是同一个类。相反，如果没有

使用双亲委派模型，由各个类加载器自行去加载的话，如果用户自己编写了一个称为

java.lang.Object 的类，并放在程序的 ClassPath 中，那系统中将会出现多个不同的 Object

类， Java 类型体系中最基础的行为也就无法保证，应用程序也将会变得一片混乱。如果读者

有兴趣的话，可以尝试去编写一个与 rt.jar 类库中已有类重名的 Java 类，将会发现可以正常编

译，但永远无法被加载运行。

双亲委派模型对于保证 Java 程序的稳定运作很重要，但它的实现却非常简单，实现双亲委派的代码都集中在 java.lang.ClassLoader 的 loadClass （）方法之中，如代码清单 7-10 所示，

逻辑清晰易懂：先检查是否已经被加载过，若没有加载则调用父加载器的 loadClass （）方

法，若父加载器为空则默认使用启动类加载器作为父加载器。如果父类加载失败，抛出

ClassNotFoundException 异常后，再调用自己的 findClass （）方法进行加载。

双亲委派模型的实现的代码实现:

 protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        //首先，检查请求的类是否已经被加载过了 
        Class c = findLoadedClass(name);
        if (c == null) {
            try {
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                //如果父类加载器抛出ClassNotFoundException说明父类加载器无法完成加载请求 
            }
            if (c == null) {
                //在父类加载器无法加载的时候再调用本身的findClass方法来进行类加载 
                c = findClass(name);
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }