类加载器深入剖析

关注

原创最新推荐文章于 2026-03-24 17:39:03 发布 238 阅读 AI 写同款· GEO 优化 ›

JDK类加载器剖析我之所以深入研究 Java 类加载器，是为了解决一个奇怪的问题。流行出版物，也就是人们所认为的 Java 世界的灯塔，充斥着关于这个主题的相互矛盾和过时的信息。这种矛盾引发了我的调查 — — 在 Java 类加载器的迷宫中寻求清晰的答案。作为一名 Java 开发人员，您可能遇到过ClassNotFoundException一些NoClassDefFoundError神秘的消息，它们会暂时中断您的编码流程。旨在阐明这些问题的在线资源往往反而增加了混乱。阅读详情

java虚拟机与程序的生命周期

在如下的集中情况下，Java虚拟机将结束声明周期：

-执行了System,exit()方法

-程序正常执行结束

-程序在执行的过程中遇到了异常或错误而异常终止

-由于操作系统出现错误而导致Java虚拟机进程终止

类的加载、连接与初始化

加载：查找并加载类的二级制数据

连接：

-验证：确保被加载的类的正确性

-准备：为类的静态变量分配内存，并将其初始化为默认值

-解析：把类中的符号引用转换为直接引用。

初始化：为类的静态变量服务正确的初始值。

Java程序对类的使用方式可以分为两种：

--主动使用

--被动使用

所有的Java虚拟机必须在每个类或者接口被Java程序“首次主动使用”时才初始化他们。

主动使用（六种）

--创建类的实例

--访问某个类或者接口的静态变量，或者对该静态变量赋值

--调用类的静态方法

--反射（如Class.forName("com.zz.Test")）

--初始化一个类的子类

--Java虚拟机启动时被标明为启动类的类（Java Test类或者Main方法）

除了以上六种情况，其他使用Java类的方式都被看做是对类的被动使用，都不会导致类的初始化。

类的加载：

类的加载是指将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个java.lang.Class对象，用来封装类在方法区内的数据结构。

加载.class文件的方式
–从本地系统中直接加载
–通过网络下载.class文件（URLClassLoader(URL[] urls)）
–从zip，jar等归档文件中加载.class文件
–从专有数据库中提取.class文件
–将Java源文件动态编译为.class文件

类的加载的最终产品是位于堆区中的class对象

Class对象封装了类在方法区内的数据结构，并且向Java程序员提供了访问方法区内的数据结构的接口。（反射）

类加载器一共有两大类：Java虚拟机自带的加载器和用户自定义的类加载器

java虚拟机自带的类加载器：

•根类加载器（Bootstrap）
•扩展类加载器（Extension）
•系统类加载器（System）

根类加载器：使用C++编写，程序员无法在Java代码中获取该类。根类加载器负责加载虚拟机的核心类库，如java.lang.*等。根类加载器的实现依赖于底层操作系统，属于虚拟机的实现的一部分，它并没有继承java.lang.ClassLoader类。

扩展类加载器：它的父类加载器为根类加载器。加载jre\lib\ext目录下的类库。扩展类加载器是纯Java类，是java.lang.ClassLoader的子类。

系统类加载器也称为应用类加载器，它的父类加载器为扩展类加载器。它从环境变量classPath所指定的目录中加载类，它是用户自定义的类加载器的默认父类加载器。系统类加载器是纯Java类，是java.lang.ClassLoader的子类。

用户自定义的类加载器

用户可以定制类的加载方式，都是java.lang.ClassLoadeer的子类。

疑问：String的类加载器是谁呢？？？

public class StringClassLoader {
    public static void main(String[] args) {
        try {
            Class<?> name = Class.forName("java.lang.String");
            System.out.println(name.getClassLoader());
        }
        catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

输出：null

因此String的类加载器是启动类加载器。

类加载器并不需要等到某个类被“首次主动使用”时再加载它：

JVM规范允许类加载器在预料某个类将要被使用时就预先加载它，如果在预先加载的过程中遇到了.class文件缺失或存在错误，类加载器必须在程序首次主动使用该类时才报告错误（linkageError错误）

如果这个类一直没有被程序主动使用，那么类加载器就不会报告错误。

类被加载后，就进入连接阶段。

连接就是将已经读入到内存的类的二进制数据合并到虚拟机的运行时环境中去。

连接：

类的验证：

准备：

在准备阶段，Java虚拟机为类的静态变量分配内存，并设置默认的初始值。例如，下面的Sample类，在准备阶段，将为int类型的静态变量a分配4个字节的内存空间，并且赋予默认值0，为long类型的静态变量b分配8个字节的内存空间，并且赋予默认值0.

public class Sample {
    private static int a = 1;
    private static long b;
    static {
        b = 2;
    }
}

解析：

在解析阶段，Java虚拟机会把类的二级制数据中的符号引用替换为直接引用。例如在Worker类中的gotoWork()方法中会引用Car类的run()方法

public void gotoWork() {

car.run();

}

在Worker类的二进制数据中，包含了一个对Car类run()方法的符号引用，它由run()方法的全名和相关描述符组成。在解析阶段，Java虚拟机会把这个符号引用替换为一个指针，该指针指向Car类的run()方法在方法区内的内存位置，这个指针就是直接引用。

初始化：

在初始化阶段，Java虚拟机执行类的初始化语句，为类的静态变量赋予初始值。在程序中，静态变量的初始化有两种途径：

（1）在静态变量的声明处进行初始化；

（2）在静态代码块中进行初始化。

例如在上面的Sample例子中a被显式的初始化，而变量b是在静态代码块中初始化的。

静态变量的声明语句以及静态代码块都被看做类的初始化语句，Java虚拟机会按照初始化语句在类文件中的先后顺序来依次执行他们。

例子：

class Singleton {
    private static Singleton singleton = new Singleton();
    public static int counter1;
    public static int counter2 = 0;

    private Singleton() {
        counter1++;
        counter2++;
    }

    public static Singleton getInstance() {
        return singleton;
    }
}
public class MyTest {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println("counter1=" + Singleton.counter1);
        System.out.println("counter2=" + Singleton.counter2);
    }
}

输出：

counter1=1
counter2=0

原因：

准备阶段为静态变量赋值默认值（类型的默认值，不是程序中赋值）此时：singleton = null counter1=0 counter2=0

初始化阶段，为静态变量按照顺序赋予正确的值：

首先执行singleton = new singleton();会执行构造器，因此counter1=1，counter2 = 1

然后执行counter1和counter2的赋值语句，因此counter1=1 counter2 = 0；

初始化步骤：

（1）假如这个类还没有被加载和连接，那就先进行加载和连接。

（2）假如类存在直接的父类，并且这个父类还没有被初始化，那就向初始化直接的父类

（3）假如类中存在初始化语句，那就依次执行这些初始化语句。

例子：

public class FinalTest {
    public static final int x = 8 / 2;
    static {
        System.out.println("FinalTest static block");
    }
}

class Test {
    public static void main(String[] args) {
        System.out.println(FinalTest.x);
    }
}

输出：

原因：常量在编译期间就会调入类的常量池中，所以直接引用final类型的变量，类并没有被初始化

public class FinalTest2 {
    public static final int y = new Random().nextInt(100);
    static {
        System.out.println("FinalTest2 static block");
    }
}
class Test2 {
    public static void main(String[] args) {
        System.out.println(FinalTest2.y);
    }
}

输出：

why ?????

原因：x在编译时就可以确定，y只有在运行时才能确定

当JAVA虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用于接口

1）在初始化一个类时，并不会先初始化它所实现的接口

2）在初始化一个接口时，并不会先初始化它的父接口

因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化。只有当程序首次使用特定接口的静态变量时，才会导致该接口的初始化。

class Parent {
    static int a = 3;
    static {
        System.out.println("Parent static block");
    }
}
class Child extends Parent {
    static int b = 4;
    static {
        System.out.println("Child static block");
    }
}
public class Test1 {
    static {
        System.out.println("Test1 static block");
    }

    public static void main(String[] args) {
        System.out.println(Child.b);
    }
}

输出：

如果将main函数调用换成：

输出：

程序对子类的“主动使用”会导致父类被初始化；但是父类的“主动”使用并不会导致子类初始化（不可能说生成一个bjectO类的对象就导致系统中所有的子类都会被初始化）

只有当程序访问的静态变量或者静态方法确实在当前类或当前接口中定义时，才可以认为是对类或接口的主动使用。

调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化

例子：

public class ClassLoaderTest {
    public static void main(String[] args) {
        ClassLoader loader = ClassLoader.getSystemClassLoader();
        try {
            Class<?> aClass1 = loader.loadClass("com.zy.jvm.FinalTest");
            System.out.println("=======================");
            aClass1 = Class.forName("com.zy.jvm.FinalTest");
        }
        catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

FinalTest是之前定义的一个类：

public class FinalTest2 {
    public static final int y = new Random().nextInt(100);
    static {
        System.out.println("FinalTest2 static block");
    }
}
}

输出为：

若有一个类加载器能成功加载Sample类，那么这个类加载器被称为定义类加载器，所有能成功返回Class对象的引用的类加载器都被称为初始类加载器。（即定义类加载器及其所有子类加载器都被称为初始类加载器）

父亲委托机制的优点是能够提高软件系统的安全性。因为在此机制下，用户自定义的类加载器不可能加载应该由父类加载器加载的可靠类，从而防止不可靠甚至恶意的代码代替由父加载器加载的可靠代码。例如java,lang.Object类总是由根类加载器加载，其他任何用户自定义的类加载器都不可能加载含有恶意代码的java.lang.Object类。

命名空间：

每个类加载器都有自己的命名空间，命名空间由该加载器及所有父类加载器所加载的类组成。在同一个命名空间，不会出现类的完整名字（包括类的包名）相同的两个类；在不同的命名空间中，有可能会出现类的完整名字相同的两个类。

扩展：是否属于一个类，由包名和加载器决定。

自定义类加载器：

要创建用户自己的类加载器，只需要扩展java.lang.ClassLoader类，然后覆盖它的findClass(String name)方法即可。

public class MyClassLoader extends ClassLoader{
    private String name; //类加载器的名字
    private String path = "d:\\"; //加载类的路径
    private final String fileType = ".class"; //class文件的扩展名
    public MyClassLoader(String name) {
        super();  //让系统类加载器称为该类加载器的父类加载器
        this.name = name;
    }

    public MyClassLoader(ClassLoader parent, String name) {
        super(parent);   //显式指定该类加载器的父类加载器
        this.name = name;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] date = loadClassDate(name);
        return this.defineClass(name, date, 0, date.length);
    }

    private byte[] loadClassDate(String name) {
        byte[] date = null;
        name = name.replace(".", "\\");
        try (InputStream is = new FileInputStream(new File(path + name + fileType));
             ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()){
            int ch = 0;
            while (-1 != (ch = is.read())) {
                byteArrayOutputStream.write(ch);
            }
            date = byteArrayOutputStream.toByteArray();
        }
        catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        return date;
    }
    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    @Override
    public String toString() {
        return "MyClassLoader{" +
                "name='" + name + '\'' +
                '}';
    }
}

class MyClassLoaderTest {
    public static void main(String[] args) {
        MyClassLoader classLoader1 = new MyClassLoader("loader1");
        classLoader1.setPath("d:\\myapp\\serverlib\\");
        MyClassLoader classLoader2 = new MyClassLoader(classLoader1, "loader2");
        classLoader2.setPath("d:\\myapp\\clientlib\\");
        MyClassLoader classLoader3 = new MyClassLoader(null, "loader3");
        classLoader3.setPath("d:\\myapp\\otherlib\\");
        test(classLoader2);
        test(classLoader3);
    }
    public static void test(ClassLoader loader) {
        Class clazz = null;
        try {
            clazz = loader.loadClass("Sample");
            Object instance = clazz.newInstance();
        }
        catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

Sample类：

public class Sample {
    private static int a = 1;
    private static long b;
    static {
        b = 2;
    }

    public Sample() {
        System.out.println("Sample is load by: " + this.getClass().getClassLoader());
    }
}

将class文件放在三个上面定义的目录中，输出为：