1.2、类加载器

类加载器ClassLoader角色

所有的类都由类加载器加载，加载的作用就是将 .class文件加载到内存。

一个非数组类的加载阶段（加载阶段获取类的二进制字节流的动作）是可控性最强的阶段，这一步我们可以去完成还可以自定义类加载器去控制字节流的获取方式（重写一个类加载器的 loadClass() 方法）。

数组类型不通过类加载器创建，它由 Java 虚拟机直接创建。

类加载器分类

JVM支持两种类型的加载器

• 引导类加载器（BootStrap ClassLoader）
• 自定义类加载器（User-Defined ClassLoader）

从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器，但是java虚拟机规范却没有这么定义，而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器。

无论类加载器的类型如何划分，在程序中我们最常见的类加载器始终只有三个

• 对于用户自定义类来说：使用系统类加载器AppClassLoader进行加载
• java核心类库都是使用引导类加载器BootStrapClassLoader加载的

/**
 * ClassLoader加载
 */
public class ClassLoaderTest {
    public static void main(String[] args) {
        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //获取其上层  扩展类加载器
        ClassLoader extClassLoader = systemClassLoader.getParent();
        System.out.println(extClassLoader);//sun.misc.Launcher$ExtClassLoader@610455d6

        //获取其上层 获取不到引导类加载器
        ClassLoader bootStrapClassLoader = extClassLoader.getParent();
        System.out.println(bootStrapClassLoader);//null

        //对于用户自定义类来说：使用系统类加载器进行加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //String 类使用引导类加载器进行加载的  -->java核心类库都是使用引导类加载器加载的
        ClassLoader classLoader1 = String.class.getClassLoader();
        System.out.println(classLoader1);//null
    }
}

虚拟机自带的加载器

1. 启动类加载器（引导类加载器，BootStrap ClassLoader）

   • 这个类加载使用C/C++语言实现的，嵌套在JVM内部
   • 它用来加载java的核心库（JAVA_HOME/jre/lib/rt.jar/resources.jar或sun.boot.class.path路径下的内容），用于提供JVM自身需要的类
   • 并不继承自java.lang.ClassLoader,没有父加载器
   • 加载拓展类和应用程序类加载器，并指定为他们的父加载器
   • 处于安全考虑，BootStrap启动类加载器只加载包名为java、javax、sun等开头的类

2. 拓展类加载器（Extension ClassLoader）

   • java语言编写 ，由sun.misc.Launcher$ExtClassLoader实现。
   • 派生于ClassLoader类
   • 父类加载器为启动类加载器
   • 从java.ext.dirs系统属性所指定的目录中加载类库，或从JDK的安装目录的jre/lib/ext子目录（扩展目录）下加载类库。如果用户创建的JAR放在此目录下，也会由拓展类加载器自动加载

3. 应用程序类加载器（系统类加载器，AppClassLoader）

   • java语言编写， 由sun.misc.Launcher$AppClassLoader实现。
   • 派生于ClassLoader类
   • 父类加载器为拓展类加载器
   • 它负责加载环境变量classpath或系统属性 java.class.path指定路径下的类库
   • 该类加载器是程序中默认的类加载器，一般来说，java应用的类都是由它来完成加载
   • 通过ClassLoader#getSystemClassLoader()方法可以获取到该类加载器

用户自定义类加载器

当用户有以下需求时，也可以自定义类加载器来定制类的加载方式

• 隔离加载类
• 修改类加载的方式
• 拓展加载源
• 防止源码泄漏

实现步骤

1. 继承抽象类java.lang.ClassLoader 类的方式实现自己的类加载器
2. jdk1.2 之后不再建议去覆盖loadClass方法，而是把自定义加载逻辑写在 findClass() 中
3. 如果没有复杂需求也可以直接继承URLClassLoader类，避免自己编写findClass() 及获取字节码流的方式

类加载机制

双亲委派机制

0. 类加载的时候，系统会首先判断当前类是否被加载过。已经被加载的类会直接返回，否则才会尝试加载。
1. 加载的时候，首先会把该请求委派该父类加载器的 loadClass() 处理，如果父类加载器还有其父类加载器，则进一步向上委托，因此所有的请求最终都应该传送到顶层的启动类加载器 BootstrapClassLoader 中。
2. 如果父类加载器可以完成加载，就返回；当父类加载器无法处理时，子类加载器才会尝试去加载。

源码分析

双亲委派模型的实现代码非常简单，逻辑非常清晰，都集中在 java.lang.ClassLoader 的 loadClass() 中，相关代码如下所示。

private final ClassLoader parent; 
protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // 首先，检查请求的类是否已经被加载过
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {//父加载器不为空，调用父加载器loadClass()方法处理
                        c = parent.loadClass(name, false);
                    } else {//父加载器为空，使用启动类加载器 BootstrapClassLoader 加载
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                   //抛出异常说明父类加载器无法完成加载请求
                }
                
                if (c == null) {
                    long t1 = System.nanoTime();
                    //自己尝试加载
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

双亲委派机制的优势

• 可以避免类的重复加载（JVM 区分不同类的方式不仅仅根据类名，相同的类文件被不同的类加载器加载产生的是两个不同的类）

  jvm中表示两个class对象是否为同一个类存在的两个必要条件

  • 类的完整类名必须一致，包括包名
  • 加载这个类的ClassLoader（指ClassLoader实例对象）必须相同

• 也保证了 Java 的核心 API 不被篡改。如果没有使用双亲委派模型，而是每个类加载器加载自己的话就会出现一些问题，比如我们编写一个称为 java.lang.Object 类的话，那么程序运行的时候，系统就会出现多个不同的 Object 类。

沙箱安全机制

举例

自定义String类，添加main方法。但是在加载子自定义的String类的时候回率先使用引导类加载器加载，而引导类加载器在加载过程中会先加载jdk自带的文件（rt.jar包中的java\lang\String.class）。自定义String类的main方法就无法找到而报错。

这样可以保证对java核心源代码的保护，这就是沙箱安全机制.