引言

  • 类加载器是JVM执行类加载机制的前提。
  • ClassLoader的作用：ClassLoader是Java的核心组件，所有的Class都是由ClassLoader进行加载的，ClassLoader负责通过各种方式将Class信息的二进制数据流读入JVM内部，转换为一个与目标类对应的java.lang.Class对象实例。然后交给Java虚拟机进行链接、初始化等操作。因此，ClassLoader在整个装载阶段，只能影响到类的加载，而无法通过ClassLoader去改变类的链接和初始化行为。至于它是否可以运行，则由Execution Engine决定。
  • 类加载器最早出现在Java1.0版本中，那个时候只是单纯地为了满足Java Applet应用而被研发出来。但如今类加载器却在OSGi、字节码加解密领域大放异彩。这主要归功于Java虚拟机的设计者们当初在设计类加载器的时候，并没有考虑将它绑定在JVM内部，这样做的好处就是能够更加灵活和动态地执行类加载操作。

大厂面试题

蚂蚁金服：
深入分析ClassLoader，双亲委派机制
类加载器的双亲委派模型是什么？一面：双亲委派机制及使用原因

百度：
都有哪些类加载器，这些类加载器都加载哪些文件？
手写一个类加载器Demo
Class的forName（“java.lang.String”）和Class的getClassLoader（）的Loadclass（“java.lang.String”）有什么区别？

腾讯：
什么是双亲委派模型？
类加载器有哪些？

小米：
双亲委派模型介绍一下

滴滴：
简单说说你了解的类加载器一面：讲一下双亲委派模型，以及其优点

字节跳动：
什么是类加载器，类加载器有哪些？

京东：
类加载器的双亲委派模型是什么？
双亲委派机制可以打破吗？为什么

类加载的分类

  • 类的加载分类：显式加载 vs隐式加载
  • class文件的显式加载与隐式加载的方式是指JVM加载class文件到内存的方式。
  • 显式加载指的是在代码中通过调用ClassLoader加载class对象，如直接使用Class.forName(name)或this.getClass().getClassLoader().loadClass()加载class对象。
  • 隐式加载则是不直接在代码中调用ClassLoader的方法加载class对象，而是通过虚拟机自动加载到内存中，如在加载某个类的class文件时，该类的class文件中引用了另外一个类的对象，此时额外引用的类将通过JVM自动加载到内存中。
  • 在日常开发以上两种方式一般会混合使用。

代码举列

User user=new User();//隐式加载
Class clazz=Class.forName("com.atguigu.java.User");//显式加载并初始化
ClassLoader.getSystemClassLoader().loadClass("T1.Parent"); //显式加载,但不初始化

类加载器的必要性

一般情况下，Java开发人员并不需要在程序中显式地使用类加载器，但是了解类加载器的加载机制却显得至关重要。从以下几个方面说：

  • 避免在开发中遇到java.lang.ClassNotFoundException异常或java.lang.NoClassDefFoundError异常时，手足无措。只有了解类加载器的 加载机制才能够在出现异常的时候快速地根据错误异常日志定位问题和解决问题
  • 需要支持类的动态加载或需要对编译后的字节码文件进行加解密操作时，就需要与类加载器打交道了。
  • 开发人员可以在程序中编写自定义类加载器来重新定义类的加载规则，以便实现一些自定义的处理逻辑。

命名空间

何为类的唯一性？

对于任意一个类，都需要由加载它的类加载器和这个类本身一同确认其在Java虚拟机中的唯一性。每一个类加载器，都拥有一个独立的类名称空间：比较两个类是否相等，只有在这两个类是由同一个类加载器加载的前提下才有意义。否则，即使这两个类源自同一个Class文件，被同一个虚拟机加载，只要加载他们的类加载器不同，那这两个类就必定不相等。

命名空间

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

在大型应用中，我们往往借助这一特性，来运行同一个类的不同版本。

代码举例

package T1;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class UserClassLoader extends ClassLoader {
    private String rootDir;

    public UserClassLoader(String rootDir) {
        this.rootDir = rootDir;
    }

    // 编写findclass方法的逻辑
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        //获取类的cLass文件字节数组
        byte[] classData = getClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        } else {
            //直接生成cLass对象
            return defineClass(name, classData, 0, classData.length);
        }
    }


    // 编写获cLass文件并转换为字节码流的逻辑
    private byte[] getClassData(String className) {
        //读取类文件的字节
        String path = classNameToPath(className);
        try {
            InputStream ins = new FileInputStream(path);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len = 0;

            //读取类文件的字节码
            while ((len = ins.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;

    }

    // 类文件的完全路径
    private String classNameToPath(String className) {
        return rootDir + "\\" + className.replace('.', '\\') + ".class";
    }

    public static void main(String[] args) throws ClassNotFoundException {
        String rootDir = "F:\\java\\apache-maven-3.6.3\\jvm\\src\\main\\java";

        UserClassLoader userClassLoader1 = new UserClassLoader(rootDir);
        Class class1 = userClassLoader1.findClass("T1.User");
        UserClassLoader userClassLoader2 = new UserClassLoader(rootDir);
        Class class2 = userClassLoader2.findClass("T1.User");


        System.out.println(class1 == class2); // false
        System.out.println("class1:" + class1.getClassLoader()); // class1:T1.UserClassLoader@1b6d3586
        System.out.println("class2:" + class2.getClassLoader()); // class2:T1.UserClassLoader@74a14482


        // 应用类加载器
        Class class3 = ClassLoader.getSystemClassLoader().loadClass("T1.User");
        System.out.println(class3.getClassLoader()); // sun.misc.Launcher$AppClassLoader@18b4aac2

        // 删除target.classes.T1.User.class文件时,报错Exception in thread "main" java.lang.ClassNotFoundException: T1.User
        // 原因应用类加载器使用默认生成的class文件
        // 解决办法：Build->Recompile 指定java文件

    }

}

类加载机制的基本特征

  • 双亲委派模型。但不是所有类加载都遵守这个模型，有的时候，启动类加载器所加载的类型，是可能要加载用户代码的，比如JDK内部的ServiceProvider/ServiceLoader机制，用户可以在标准API框架上，提供自己的实现，JDK也需要提供些默认的参考实现。例如，Java中JNDI、JDBC、文件系统、Cipher等很多方面，都是利用的这种机制，这种情况就不会用双亲委派模型去加载，而是利用所谓的上下文加载器。
  • 可见性，子类加载器可以访问父加载器加载的类型，但是反过来是不允许的。不然，因为缺少必要的隔离，我们就没有办法利用类加载器去实现容器的逻辑。
  • 单一性，由于父加载器的类型对于子加载器是可见的，所以父加载器中加载过的类型，就不会在子加载器中重复加载。但是注意，类加载器“邻居”间，同一类型仍然可以被加载多次，因为互相并不可见。