转载、引用请标明出处
https://www.jianshu.com/p/2840e87de2b7
本文出自zhh_happig的简书博客，谢谢

以下内容，是本人学习的笔记和工作中的总结，仅供大家参考，有误的地方还请指正

一 类加载器

JVM提供了三类加载器

• 根类加载器Bootstrap
  • 使用C++编写，程序员无法在java代码中获得该类
  • 没有父加载器
  • 并没有继承java.lang.ClassLoader
  • 负责加载虚拟机的核心类库，如java.lang.*等
  • 如果一个类是用根类加载器加载的，那么通过Class对象getClassLoader()得到的值为null，比如java.lang.String类
• 扩展加载器(Extension)，使用java代码实现
  • 使用java代码实现，继承java.lang.ClassLoader(java类继承关系)
  • 父加载器是根类加载器
  • 它从java.ext.dirs系统属性所指定的目录中加载类库，或从jdk的安装目录jre/lib/ext扩展目录中加载类库
• 系统加载器(应用加载器)Syetem，
  • 使用java代码实现，继承java.lang.ClassLoader(java类继承关系)
  • 父加载器是扩展加载器
  • 从环境变量classpath或者系统属性java.class.path所指定的目录中加载类
  • 通过ClassLoader.getSystemClassLoader()获取
  • 是应用程序运行时的类加载器
  • 用户自定义的类加载器的默认父加载器
  • 定义类加载器概念：如果某个加载器能够加载一个类，那么该加载器称作 定义类加载器；定义类加载器及其所有子加载器都被称作 初始类加载器。

注意：扩展加载器的父加载器是根类加载器，这种父子关系不是java类继承关系。而是加载器之间的包装关系
可以从ClassLoader源码看出加载器之间的包装关系：this.parent = parent;

private ClassLoader(Void unused, ClassLoader parent) {
  this.parent = parent;
  if (ParallelLoaders.isRegistered(this.getClass())) {
    parallelLockMap = new ConcurrentHashMap<>();
    package2certs = new ConcurrentHashMap<>();
    domains =Collections.synchronizedSet(new HashSet<ProtectionDomain>());
    assertionLock = new Object();
  } else {
    // no finer-grained lock; lock on the classloader instance
    parallelLockMap = null;
    package2certs = new Hashtable<>();
    domains = new HashSet<>();
    assertionLock = this;
  }
}

//自定义的加载器，继承ClassLoader
ClassLoader loader1 = new MyClassLoader();
//给loader2指定父加载器，参数loader1将作为loader2的父加载器
ClassLoader loader2 = new MyClassLoader(loader1);

//如果不指定父加载器，则默认父加载器是系统加载器
ClassLoader loader2 = new MyClassLoader();

二 父委托机制

父亲委托机制是为了确保java平台软件系统的安全性。

• 在此机制中，除了java虚拟机自带的根类加载器没有父加载器以外，其余的类加载器都有且只有一个父加载器。
• 当java程序请求加载器loader1加载Sample类时，loader1首先委托自己的父加载器去加载，如果父加载器还有父加载器，继续向上委托。
• 如果有某个父加载器能加载Sample类，则由父加载器完成，否则才由自己本身加载Sample类，加载完成会将Sample类对应的Class对象的引用返回给loader1。
• 如果都加载不了，最后才由loader1加载。

三 运行时包

• 由 同一类加载器 加载的属于 相同包 的类组成了 运行时包。
• 决定了两个类是不是属于同一个运行时包，不仅要看包名，还要看 定义类加载器是否相同。
• 只有属于 同一运行时包 的 类 才能互相访问 包可见(default) 的类和类成员。
• 这样做是为了避免用户自定义的类冒充核心类库的类，去访问核心类库的包可见成员。

用户自定义了一个类 java.lang.Spy, 并由用户自定义的类加载器加载，虽然java.lang.Spy类和核心类库java.lang.* 中的类包名相同，但是他们的类加载器却不同，java.lang.Spy类加载器是系统加载器，核心类库java.lang.* 的加载器是根类加载器，所以java.lang.Spy类和核心类库java.lang.* 中的类属性不同的运行时包，所以java.lang.Spy不能访问核心类库java.lang.* 中的包可见成员，保证了安全性。

四 自定义加载器

用户自定义的加载器都是java.lang.ClassLoader的子类，默认父加载器是系统加载器

• 继承java.lang.ClassLoader
• 只需要覆盖findClass(String name)方法
  • findClass方法会找到类的位置
  • findClass返回该类对应的Class对象的引用，再由loadClass方法加载类

示例1

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

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 void setPath(String path) {
        this.path = path;
    }

    @Override
    public String toString() {
        return this.name;
    }

    public MyClassLoader(ClassLoader parent, String name) {
        super(parent); // 显示指定父加载器
        this.name = name;
    }
    
    @Override
    public Class<?> findClass(String name) {
        byte[] data = loadClassData(name);
        if(data == null){
            return null;
        }
        return this.defineClass(name, data, 0, data.length);
    }

    //java建议这样去加载class文件二进制字节码
    private byte[] loadClassData(String name) {
        InputStream is = null;
        ByteArrayOutputStream bos = null;
        byte[] data = null;
        try {
            name = name.substring(name.lastIndexOf(".") + 1, name.length());
            is = new FileInputStream(new File(path + name + fileType));
            bos = new ByteArrayOutputStream();
            int ch = 0;
            while (-1 != (ch = is.read())) {
                bos.write(ch);
            }
            data = bos.toByteArray();
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            try {
                is.close();
                bos.close();
            } catch (Exception ex) {
                ex.printStackTrace();
            }

        }
        return data;
    }

    public static void main(String[] args) throws Exception {

        //不显示执行父加载器，那么loader1的父加载器是系统类加载器
        MyClassLoader loader1 = new MyClassLoader("loader1");
        loader1.setPath("D:\\myapp\\serverlib\\");//此目录有Smaple、Dog class文件

        //loader2的父加载器是loader1
        MyClassLoader loader2 = new MyClassLoader(loader1, "loader2");
        loader2.setPath("D:\\myapp\\clientlib\\");//此目录无Smaple、Dog class文件

        //父加载设置为null, 那么loader3父载器就是根类加载器
        MyClassLoader loader3 = new MyClassLoader(null, "loader3");
        loader3.setPath("D:\\myapp\\otherlib\\");//此目录有Smaple、Dog class文件

        test(loader2);
        test(loader3);

    }

    public static void test(ClassLoader loader) throws Exception {

        Class<?> clazz = loader.loadClass("Sample");
        Object object = clazz.newInstance();
    }
}

public class Sample {

    public int a = 1;

    public Sample(){
        System.out.println("Smaple is loaded by " + this.getClass().getClassLoader());
        new Dog();
    }
}

public class Dog {

    public int b = 1;

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

1.执行java -cp .;D:\myapp\serverlib\ MyClassLoader，-cp参数：增加classpath路径，输出结果：
Smaple is loaded by sun.misc.Launcher$AppClassLoader@18b4aac2 //系统加载器
Dog is loaded by sun.misc.Launcher$AppClassLoader@18b4aac2 //系统加载器
Smaple is loaded by loader3
Dog is loaded by loader3
解析：
(1)loader2向上父委托，根类加载器无法加载Smaple、Dog，扩展加载器无法加载Smaple、Dog，系统加载器是加载classpath中的类，由于java命令中将类的路径增加到了classpath中，所以由系统加载器加载Smaple、Dog
(2)系统加载器是Smaple、Dog类的定义类加载器；系统类加载器、loader1、loader2加载器都是Smaple、Dog类的初始类加载器
(3)loader3向上父委托，根类加载器无法加载Smaple、Dog，所以由loader3自己加载，loader3加载器是Smaple、Dog类的定义类加载器和初始类加载器

2.执行java MyClassLoader，输出结果：
Smaple is loaded by loader1
Dog is loaded by loader1
Smaple is loaded by loader3
Dog is loaded by loader3
解析：
(1)loader2向上父委托，根类加载器无法加载Smaple、Dog，扩展加载器无法加载Smaple、Dog，由于没有增加类路径到classpath中，所以系统加载器无法加载Smaple、Dog，而loader1加载目录中有Smaple、Dog class文件，所以loader1可以加载
(2)虽然loader2加载器加载目录中没有Smaple、Dog class文件，但是已经由loader1加载了

五 类加载器的命名空间

• 同一个命名空间内的类是相互可以见的
• 子加载器的命名空间包含所有父加载器的命名空间。因此由子加载器加载的类能看见父加载器加载的类。
• 例如 系统类加载器加载的类能看见根类加载器加载的类。
• 由父加载器加载的类不能看见子加载器加载的类。
• 如果两个加载器之间没有直接或间接的父子关系，那么它们各自加载的类相互不可见
• 当两个不同命令空间内的类互相不可见时，可采用java反射机制来访问其他命令空间中的类的实例的属性和方法

示例2

把示例1中main方法中的代码改为：
public static void main(String[] args) throws Exception {

    //loader1的父加载器是系统类加载器
    MyClassLoader loader1 = new MyClassLoader("loader1");
    loader1.setPath("D:\\myapp\\serverlib\\");

    Class<?> clazz = loader1.loadClass("Sample");
    Object object = clazz.newInstance();
    Sample Sample = (Sample) object;
    System.out.println(Sample.a);

    /**
    * 反射
    Class<?> clazz = loader1.loadClass("Sample");
    Object object = clazz.newInstance();
    Field field = clazz.getField("a");
    int a = field.getInt(object);
    System.out.println(a);
    */

}

执行java MyClassLoader，输出结果：
Smaple is loaded by loader1
Dog is loaded by loader1
Exception in thread "main" java.lang.NoClassDefFoundError: Sample
    at MyClassLoader.main<MyClassLoader.java: 86>
也就是这一句出错了：Sample Sample = (Sample) object;
解析：
MyClassLoader类是由系统类加载的，而Sample类是由loader1类加载的，父加载器加载的类不能看见子加载器加载的类，因此MyClassLoader类看不见Sample类，所以在MyClassLoader类中的main方法中使用Sample类会导致上面错误。

示例3

把上面示例1中的main方法中的注释做如下更改
public static void main(String[] args) throws Exception {

    //不显示执行父加载器，那么loader1的父加载器是系统类加载器
    MyClassLoader loader1 = new MyClassLoader("loader1");
    loader1.setPath("D:\\myapp\\serverlib\\");//此目录有Smaple class文件，没有Dog文件

    //loader2的父加载器是loader1
    MyClassLoader loader2 = new MyClassLoader(loader1, "loader2");
    loader2.setPath("D:\\myapp\\clientlib\\");//此目录只有Dog class文件

    test(loader2);
}

执行java MyClassLoader，输出结果：
Smaple is loaded by loader1
Exception in thread "main" java.lang.NoClassDefFoundError: Dog

为什么输出结果不是
Smaple is loaded by loader1
Dogis loaded by loader2 
解析：
loader2父委托loader1了，loader1加载目录里面有Sample类，没有Dog类，所以loader1只加载了Sample类，loader2加载目录有Dog类，Dog类应该由loader2自己加载，为什么会报错了呢？
其实Dog类已经被loader2加载，只是没有输出Dog is loaded by loader2这一句而已。因为父加载器加载的类看不到子加载器加载的类的问题，所以在Sample的构造方法里面使用Dog类时就已经报错了，代码不会在往下执行了。

六 类的卸载

1 ClassLoader、Class对象、类的实例之间的关系

• ClassLoader对象 里面的集合存放着所有它加载的 类对应的 Class对象
• Class对象通过getClassLoader()可以获得 加载类 的ClassLoader对象，Class对象指向 对应的类 在方法区中的 二进制数据结构
• 类的实例可以通过getClass()方法获取 类对应的 Class对象

2 类的生命周期

• 由java虚拟机自带的类加载器加载的类，在java虚拟机的生命周期内，始终不会被卸载。
• java虚拟机自带的类加载器包括 根类加载器、扩展类加载器、系统类加载器。
• java虚拟机本身会始终引用这些类加载器，而这些类加载器则会始终引用他们所加载的类的Class对象，因此这些Class对象始终是被引用着的。

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

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

以上内容，是本人学习的笔记和工作中的总结，仅供大家参考，有误的地方还请指正

转载、引用请标明出处
https://www.jianshu.com/p/2840e87de2b7
本文出自zhh_happig的简书博客，谢谢