【JVM学习笔记】类加载器

概述

类加载器用来把类加载到Java虚拟机中。从JDK1.2版本开始，类的加载过程采用父委托机制，这种机制能更好地保证Java平台的安全。在此委托机制中，除了Java虚拟机自带的根类加载器以外，其余的类加载器都有且只有一个父加载器。当Java程序请求加载器loader1加载sample类时，loader1首先委托自己的父加载器去加载Sample类，若父加载器能加载，则由父加载器完成加载任务，否则才由加载器loader1本身加载sample类。

加载器的分类

Java虚拟机自带了以下几种加载器：

• 根(Bootstrap)类加载器：该加载器没有父加载器。它负责加载虚拟机的核心类库，如java.lang.*等。例如java.lang.Object就是由根类加载器加载的。根类加载器从系统属性sun.boot.class.path所指定的目录中加载类库。根类加载器的实现依赖于底层操作系统，属于虚拟机的实现的一部分，它并没有继承java.lang.ClassLoader类
• 扩展(Extension)类加载器：它的父加载器为根类加载器。它从java.ext.dirs系统属性所指定的目录中加载类库，或者从JDK安装目录的jre/lib/ext子目录（扩展目录）下加载类库，如果把用户创建的JAR文件放在这个目录下，也会自动由扩展类加载器加载。扩展类加载器是纯Java类，是java.lang.ClassLoader类的子类
• 系统(System)类加载器：也称应用类加载器，它的父加载器为扩展类加载器。它从环境变量classpath或者系统属性java.class.path所指定的目录中加载类，它是用户自定义的类加载器的默认父加载器。系统类加载器是纯Java类，是java.lang.ClassLoader类的子类

除了以上虚拟机自带的加载器外，用户还可以定制自己的类加载器。Java提供了抽象类java.lang.ClassLoader，所有用户自定义的类加载器都应该继承ClassLoader类。

（扩展类加载器和系统类加载器都是由启动类加载器加载的）

类加载器的父委托机制

在父委托机制中，各个加载器按照父子关系形成了树形结构，除了根类加载器之外，其余的类加载器都有且只有一个父加载器（题外话，双亲委托机制是hotspot默认提供的一种机制，但并不是所有环境中都遵循这种机制，OSGI就打破了这种机制）

如果有一个类加载器能够成功加载某个类，那么这个类加载器被称为定义类加载器，所有能成功返回Class对象引用的类加载器（包括定义类加载器）都被称为初始类加载器

获得ClassLoader的途径

获得当前类的ClassLoader

clazz.getClassLoader();

获得当前线程上下文的ClassLoader

Thread.currentThread().getContextClassLoader()

获得系统的ClassLoader

ClassLoader.getSystemClassLoader()

获得调用者的ClassLoader（这种用的比较少）

DriverManager.getCallerClassLoader()

数组类的类对象不是由类加载器创建的，而是根据Java运行时的需要自动创建的。 Class.getClassLoader（）返回的数组类的类加载器与其元素类型的类加载器相同; 如果元素类型是基本类型，则数组类没有类加载器。

public class ClassLoaderLearn {
    public static void main(String[] args) throws ClassNotFoundException {
        String[] strings = new String[2];
        System.out.println(strings.getClass().getClassLoader());

        ClassLoaderLearn[] array = new ClassLoaderLearn[5];
        System.out.println(array.getClass().getClassLoader());

        int[] nums = new int[5];
        System.out.println(nums.getClass().getClassLoader());
    }
}

运行结果为

null
sun.misc.Launcher$AppClassLoader@18b4aac2
null

入门示例

package com.learn.jvm.loader;

import java.io.*;

/**
 * @author wx
 * @Description
 * @date 2019/09/01 11:51
 * 实际上我们自定义的这个ClassLoader只重写了findclass方法
 */
public class ClassLoaderLearn extends ClassLoader {

    private String classLoaderName; // classloader的名称
    private String path;            // 加载路径
    private String fileName;        // 文件名

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

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public ClassLoaderLearn(String classLoaderName) {
        // 这句话可以省略，因为默认就会去调用父类的无参构造方法
        // 在这里写出来就是为了强调它的作用，super()这个方法会去创建一个新的ClassLoader，其父加载器为SystemClassLoader
        super();
        this.classLoaderName = classLoaderName;
    }

    public ClassLoaderLearn(ClassLoader parent, String classLoaderName) {
        // super(parent)会创建一个新的类加载器，这个新的类加载器的父加载器为parent
        super(parent);
        this.classLoaderName = classLoaderName;
    }

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

    // 对父类中findClass方法doc文档的翻译：
    // 查找具有指定二进制名称的类。 此方法应由遵循委托模型的类加载器实现覆盖以加载类，并且在检查所请求类的父类加载器之后将由loadClass方法调用。 默认实现抛出ClassNotFoundException
    @Override
    protected Class<?> findClass(String className) throws ClassNotFoundException {
        System.out.println("findClass invoked: " + className);
        System.out.println("class loader name: " + this.classLoaderName);
        byte[] data = this.loadClassData(className);
        return this.defineClass(className, data, 0, data.length);
    }

    // className 是要加载的类的binaryname
    private byte[] loadClassData(String className) {
        InputStream is = null;
        byte[] data = null;
        ByteArrayOutputStream baos = null;

        try {
            is = new FileInputStream(new File(path+fileName));
            baos = new ByteArrayOutputStream();

            int ch;
            while (-1 != (ch = is.read())) {
                baos.write(ch);
            }

            data = baos.toByteArray();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
                baos.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

        return data;
    }

    public static void main(String[] args) throws Exception {
        ClassLoaderLearn loader = new ClassLoaderLearn("MyClassLoader");
//        loader.setPath("D:\\workspace-learn\\common-learn\\learn-jvm\\target\\classes");
        loader.setPath("D:/");
        loader.setFileName("Test.class");

        // loadClass是ClassLoader提供的方法
        // 深入源代码的doc文档，可以看到，loadClass方法按照如下顺序寻找类
        // 1.调用findLoadedClass(String)方法检查这个类是否已经被加载过了
        // 2.调用父加载器的loadClass方法，如果父加载器为null，就会使用根类加载器
        // 3.调用findClass(String)方法来寻找这个类
        Class<?> clazz = loader.loadClass("com.learn.jvm.loader.Test");
        System.out.println("class: " + clazz);
        Object obj = clazz.newInstance();
        System.out.println("obj:" + obj);
        System.out.println(obj.getClass().getClassLoader());
    }
}

上述代码中的Test类，是项目路径中的一个类。如果不删除生成的class文件则Test将会由根类加载器加载，加载的系统路径下的Test.class

如果删除项目路径下的Test.class文件，将其放到D盘，运行上诉程序，则Test类将由我们自定义的类加载器加载，如下面输出结果：

findClass invoked: com.learn.jvm.loader.Test
class loader name: MyClassLoader
class: class com.learn.jvm.loader.Test
obj:com.learn.jvm.loader.Test@14ae5a5
ClassLoaderLearn{classLoaderName='MyClassLoader'}

命名空间

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

（感觉OSGI就是这样的）

以下代码，在项目路径下有Test.class和项目路径没有Test.class这两种情况下，输出结果是不同的

public class ClassLoaderLearn extends ClassLoader {

    private String classLoaderName; // classloader的名称
    private String path;            // 加载路径
    private String fileName;        // 文件名

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

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public ClassLoaderLearn(String classLoaderName) {
        // 这句话可以省略，因为默认就会去调用父类的无参构造方法
        // 在这里写出来就是为了强调它的作用，super()这个方法会去创建一个新的ClassLoader，其父加载器为SystemClassLoader
        super();
        this.classLoaderName = classLoaderName;
    }

    public ClassLoaderLearn(ClassLoader parent, String classLoaderName) {
        // super(parent)会创建一个新的类加载器，这个新的类加载器的父加载器为parent
        super(parent);
        this.classLoaderName = classLoaderName;
    }

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

    // 对父类中findClass方法doc文档的翻译：
    // 查找具有指定二进制名称的类。 此方法应由遵循委托模型的类加载器实现覆盖以加载类，并且在检查所请求类的父类加载器之后将由loadClass方法调用。 默认实现抛出ClassNotFoundException
    @Override
    protected Class<?> findClass(String className) throws ClassNotFoundException {
        byte[] data = this.loadClassData(className);
        return this.defineClass(className, data, 0, data.length);
    }

    // className 是要加载的类的binaryname
    private byte[] loadClassData(String className) {
        InputStream is = null;
        byte[] data = null;
        ByteArrayOutputStream baos = null;

        try {
            is = new FileInputStream(new File(path+fileName));
            baos = new ByteArrayOutputStream();

            int ch;
            while (-1 != (ch = is.read())) {
                baos.write(ch);
            }

            data = baos.toByteArray();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
                baos.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

        return data;
    }

    public static void main(String[] args) throws Exception {
        ClassLoaderLearn loader1 = new ClassLoaderLearn("loader1");
        loader1.setPath("D:/");
        loader1.setFileName("Test.class");

        Class<?> clazz1 = loader1.loadClass("com.learn.jvm.loader.Test");
        System.out.println("class hashcode: " + clazz1.hashCode());
        Object obj1 = clazz1.newInstance();
        System.out.println("obj:" + obj1);
        System.out.println("classloader: " + obj1.getClass().getClassLoader());

        System.out.println("==========================");

        ClassLoaderLearn loader2 = new ClassLoaderLearn("loader2");
        loader2.setPath("D:/");
        loader2.setFileName("Test.class");

        Class<?> clazz2 = loader2.loadClass("com.learn.jvm.loader.Test");
        System.out.println("class hashcode: " + clazz2.hashCode());
        Object obj2 = clazz2.newInstance();
        System.out.println("obj:" + obj2);
        System.out.println("classloader: " + obj2.getClass().getClassLoader());
    }
}

输出结果（项目路径下有Test.class)

class hashcode: 356573597
obj:com.learn.jvm.loader.Test@677327b6
classloader: sun.misc.Launcher$AppClassLoader@18b4aac2
==========================
class hashcode: 356573597
obj:com.learn.jvm.loader.Test@14ae5a5
classloader: sun.misc.Launcher$AppClassLoader@18b4aac2

输出结果（项目路径下没有Test.class)

class hashcode: 21685669
obj:com.learn.jvm.loader.Test@7f31245a
classloader: ClassLoaderLearn{classLoaderName='loader1'}
==========================
class hashcode: 1173230247
obj:com.learn.jvm.loader.Test@330bedb4
classloader: ClassLoaderLearn{classLoaderName='loader2'}

这是为什么呢，为什么Test类被加载了两次。这就涉及到类加载器的命名空间问题，由于loader1和loader2在双亲委托机制中没有委托关系，所以是属于两个不同的命名空间

类的卸载

• 当一个类被加载、连接和初始化后，它的生命周期就开始了。当这个类的Class对象不再被引用，即不可抵达时，Class对象就会结束生命周期，这个类在方法区的数据也会被卸载，从而结束这个类的生命周期
• 一个类何时结束生命周期，取决于代表它的Class对象何时结束生命周期

由Java虚拟机自带的类加载器所加载的类，在虚拟机的生命周期中，始终不会被卸载。前面已经介绍过，Java虚拟机自带的类加载器包括根类加载器、扩展类加载器和系统类加载器。Java虚拟机本身会始终引用这些类加载器，而这些类加载器则会始终引用它们所加载的类的Class对象，因此这些Class对象始终是可触及的

由用户自定义的类加载器所加载的类是可以被卸载的

在类加载器的内部实现中，用一个Java集合来存放所加载类的引用。另一方面，一个Class对象总是会引用它的类加载器，调用Class对象的getClassLoader()方法，就能获得它的类加载器。由此可见，类的Class对象与类加载器之间为双向关联关系。

public class ClassLoaderLearn extends ClassLoader {

    private String classLoaderName; // classloader的名称
    private String path;            // 加载路径
    private String fileName;        // 文件名

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

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public ClassLoaderLearn(String classLoaderName) {
        // 这句话可以省略，因为默认就会去调用父类的无参构造方法
        // 在这里写出来就是为了强调它的作用，super()这个方法会去创建一个新的ClassLoader，其父加载器为SystemClassLoader
        super();
        this.classLoaderName = classLoaderName;
    }

    public ClassLoaderLearn(ClassLoader parent, String classLoaderName) {
        // super(parent)会创建一个新的类加载器，这个新的类加载器的父加载器为parent
        super(parent);
        this.classLoaderName = classLoaderName;
    }

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

    // 对父类中findClass方法doc文档的翻译：
    // 查找具有指定二进制名称的类。 此方法应由遵循委托模型的类加载器实现覆盖以加载类，并且在检查所请求类的父类加载器之后将由loadClass方法调用。 默认实现抛出ClassNotFoundException
    @Override
    protected Class<?> findClass(String className) throws ClassNotFoundException {
        byte[] data = this.loadClassData(className);
        return this.defineClass(className, data, 0, data.length);
    }

    // className 是要加载的类的binaryname
    private byte[] loadClassData(String className) {
        InputStream is = null;
        byte[] data = null;
        ByteArrayOutputStream baos = null;

        try {
            is = new FileInputStream(new File(path+fileName));
            baos = new ByteArrayOutputStream();

            int ch;
            while (-1 != (ch = is.read())) {
                baos.write(ch);
            }

            data = baos.toByteArray();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
                baos.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

        return data;
    }

    public static void main(String[] args) throws Exception {
        ClassLoaderLearn loader1 = new ClassLoaderLearn("loader1");
        loader1.setPath("D:/");
        loader1.setFileName("Test.class");

        Class<?> clazz1 = loader1.loadClass("com.learn.jvm.loader.Test");
        System.out.println("class hashcode: " + clazz1.hashCode());
        Object obj1 = clazz1.newInstance();
        System.out.println("obj:" + obj1);
        System.out.println("classloader: " + obj1.getClass().getClassLoader());

        System.out.println("==========================");
        loader1 = null;
        obj1 = null;
        clazz1 = null;
        System.gc();
        Thread.sleep(200000);

        loader1 = new ClassLoaderLearn("loader1");
        loader1.setPath("D:/");
        loader1.setFileName("Test.class");

        clazz1 = loader1.loadClass("com.learn.jvm.loader.Test");
        System.out.println("class hashcode: " + clazz1.hashCode());
        obj1 = clazz1.newInstance();
        System.out.println("obj:" + obj1);
        System.out.println("classloader: " + obj1.getClass().getClassLoader());
    }
}

输出结果（注意，项目路径下已经删掉了Test.class）

class hashcode: 21685669
obj:com.learn.jvm.loader.Test@7f31245a
classloader: ClassLoaderLearn{classLoaderName='loader1'}
==========================
[Unloading class com.learn.jvm.loader.Test 0x00000007c0061828]
class hashcode: 1173230247
obj:com.learn.jvm.loader.Test@330bedb4
classloader: ClassLoaderLearn{classLoaderName='loader1'}

使用jvisualvm看到的结果如下

如果A类的构造函数里创建了B类对象，那么B类和A类在加载的时候，是被同一个加载器加载

定义一个MyCat类

public class MyCat {
    public MyCat() {
        System.out.println("MyCat is loaded by " + this.getClass().getClassLoader());
    }
}

定义一个MySample类

public class MySample {
    public MySample() {
        System.out.println("MySample is loaded by: " + this.getClass().getClassLoader());
        new MyCat();
    }
}

然后是我们的类加载器和入口函数

public class ClassLoaderLearn extends ClassLoader {

    private String classLoaderName; // classloader的名称
    private String path;            // 加载路径
    private String fileName;        // 文件名

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

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public ClassLoaderLearn(String classLoaderName) {
        // 这句话可以省略，因为默认就会去调用父类的无参构造方法
        // 在这里写出来就是为了强调它的作用，super()这个方法会去创建一个新的ClassLoader，其父加载器为SystemClassLoader
        super();
        this.classLoaderName = classLoaderName;
    }

    public ClassLoaderLearn(ClassLoader parent, String classLoaderName) {
        // super(parent)会创建一个新的类加载器，这个新的类加载器的父加载器为parent
        super(parent);
        this.classLoaderName = classLoaderName;
    }

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

    // 对父类中findClass方法doc文档的翻译：
    // 查找具有指定二进制名称的类。 此方法应由遵循委托模型的类加载器实现覆盖以加载类，并且在检查所请求类的父类加载器之后将由loadClass方法调用。 默认实现抛出ClassNotFoundException
    @Override
    protected Class<?> findClass(String className) throws ClassNotFoundException {
        byte[] data = this.loadClassData(className);
        return this.defineClass(className, data, 0, data.length);
    }

    // className 是要加载的类的binaryname
    private byte[] loadClassData(String className) {
        InputStream is = null;
        byte[] data = null;
        ByteArrayOutputStream baos = null;

        try {
            is = new FileInputStream(new File(path+fileName));
            baos = new ByteArrayOutputStream();

            int ch;
            while (-1 != (ch = is.read())) {
                baos.write(ch);
            }

            data = baos.toByteArray();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
                baos.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

        return data;
    }

    public static void main(String[] args) throws Exception {
        ClassLoaderLearn loader1 = new ClassLoaderLearn("loader1");
        loader1.setPath("D:/");
        loader1.setFileName("MySample.class");

        Class<?> clazz1 = loader1.loadClass("com.learn.jvm.loader.MySample");
        System.out.println("class hashcode: " + clazz1.hashCode());

 　　　　 loader1.setFileName("MyCat.class");
        Object obj1 = clazz1.newInstance();
    }
}

运行结果（未删除项目路径下MyCat和MySample的情况）

class hashcode: 356573597
MySample is loaded by: sun.misc.Launcher$AppClassLoader@18b4aac2
MyCat is loaded by sun.misc.Launcher$AppClassLoader@18b4aac2

运行结果（已删除项目路径下MyCat和MySample的情况，将MyCat和MySample放在了D盘 ）

class hashcode: 21685669
MySample is loaded by: ClassLoaderLearn{classLoaderName='loader1'}
MyCat is loaded by ClassLoaderLearn{classLoaderName='loader1'}

如果在项目路径下只有MySample.class，没有MyCat.class

而在D盘两者都有，运行以上程序，输出结果为

class hashcode: 356573597
MySample is loaded by: sun.misc.Launcher$AppClassLoader@18b4aac2
Exception in thread "main" java.lang.NoClassDefFoundError: com/learn/jvm/loader/MyCat
	at com.learn.jvm.loader.MySample.<init>(MySample.java:11)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at java.lang.Class.newInstance(Class.java:442)
	at com.learn.jvm.loader.ClassLoaderLearn.main(ClassLoaderLearn.java:95)
Caused by: java.lang.ClassNotFoundException: com.learn.jvm.loader.MyCat
	at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:335)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	... 7 more

这是因为我们定义的类加载器，没有指定其父加载器，默认父加载器为系统类加载器。系统类加载器能够在classpath下面找到MySample类，但是接着却找不到MyCat类了

又一个例子，保持ClassLoaderLearn 类不变，新增一个Person类如下

public class Person {
    private Person myPerson;

    public void setMyPerson(Object obj) {
        this.myPerson = (Person)obj;
    }
}

修改main函数如下

public static void main(String[] args) throws Exception {
        ClassLoaderLearn loader1 = new ClassLoaderLearn("loader1");
        ClassLoaderLearn loader2 = new ClassLoaderLearn("loader2");
        loader1.setPath("D:/");
        loader1.setFileName("Person.class");
        loader2.setPath("D:/");
        loader2.setFileName("Person.class");
        Class<?> clazz1 = loader1.loadClass("com.learn.jvm.loader.Person");
        Class<?> clazz2 = loader2.loadClass("com.learn.jvm.loader.Person");

        Object obj1 = clazz1.newInstance();
        Object obj2 = clazz2.newInstance();

        Method method = clazz1.getMethod("setMyPerson", Object.class);
        method.invoke(obj1,obj2);
    }

输出结果（项目路径未删除Person.class）

(无输出，程序正常结束)

输出结果（项目路径已删除Person.class并放到了D盘)

Exception in thread "main" java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at com.learn.jvm.loader.ClassLoaderLearn.main(ClassLoaderLearn.java:100)
Caused by: java.lang.ClassCastException: com.learn.jvm.loader.Person cannot be cast to com.learn.jvm.loader.Person
	at com.learn.jvm.loader.Person.setMyPerson(Person.java:12)
	... 5 more

这是因为这两个类是由两个不同命名空间里的loader加载的，不是同一个类对象