Java 类加载机制详解

在讲类的加载机制前，先来看一道题目：

public class ClassLoaderTest {
    public static void main(String[] args) {
        System.out.println("爸爸的岁数:" + Son.factor);  //入口1
        // new Son();  //入口 2
    }
}

class Grandpa {
    static {
        System.out.println("爷爷在静态代码块");
    }
    public Grandpa() {
        System.out.println("我是爷爷~");
    }
}    

class Father extends Grandpa {
    static {
        System.out.println("爸爸在静态代码块");
    }
    public static int factor = 25;

    public Father() {
        System.out.println("我是爸爸~");
    }
}

class Son extends Father {
    static {
        System.out.println("儿子在静态代码块");
    }

    public Son() {
        System.out.println("我是儿子~");
    }
}

上面的代码中分了 入口1 和 入口2 ， 两者不同时存在，入口不一样，最后输出的结果也是不一样的。小伙伴可以思考下这两个入口对于类的初始化有啥不一样。下面是具体结果：

入口1的结果：

爷爷在静态代码块
爸爸在静态代码块
爸爸的岁数:25

入口2 的结果

爷爷在静态代码块
爸爸在静态代码块
儿子在静态代码块
我是爷爷~
我是爸爸~
我是儿子~

如果以前没有遇到这种问题，现在要你解答肯定是很难的。该题考察的就是你对 Java 类加载机制的理解。如果你对 Java 加载机制不理解，那么你是无法解答这道题目的。

对比上面两个结果，可以发现，入口1 都是静态代码的初始化，入口2 既涉及到静态代码的初始化，也涉及到类的初始化。到此大家肯定就知道对于静态代码和非静态代码的初始化逻辑是有区别的。

这篇文章，将对 Java 类加载机制的进行讲解，让你以后遇到类似问题不在犯难。

类的加载过程

当 Java 虚拟机将 Java 源码编译为字节码之后，虚拟机便可以将字节码读取进内存，从而进行解析、运行等整个过程，这个过程我们叫：Java 虚拟机的类加载机制。JVM 虚拟机执行 class 字节码的过程可以分为七个阶段： 加载、验证、准备、解析、初始化、使用、卸载 。 其中加载、检验、准备、初始化和卸载这个五个阶段的顺序是固定的，而解析则未必。为了支持动态绑定，解析这个过程可以发生在初始化阶段之后。

1. 加载

什么情况下需要开始 类加载 的第一个阶段：加载。 JAVA虚拟机规范并没有进行强制约束，交给虚拟机的具体实现自由把握。

加载阶段是“类加载”过程中的一个阶段，这个阶段通常也被称作“装载”，在加载阶段，虚拟机主要完成以下3件事情：

1. 通过 "类全名" 来获取定义此类的二进制字节流

2. 将字节流所代表的静态存储结构转换为方法区的运行时数据结构

3. 在 java 堆中生成一个代表这个类的 java.lang.Class 对象，作为方法区这些数据的访问入口（所以我们能够通过低调用类.getClass() ）

注意这里字节流不一定非得要从一个 Class 文件获取，这里既可以从 ZIP 包中读取（比如从 jar 包和 war 包中读取），也可以在运行时计算生成（动态代理），也可以由其它文件生成（比如将 JSP 文件转换成对应的 Class 类）。加载的信息存储在 JVM 的方法区。

对于数组类来说，它并没有对应的字节流，而是由 Java 虚拟机直接生成的。对于其它的类来说，Java 虚拟机则需要借助类加载器来完成查找字节流的过程。

如果上面那么多记不住： 请一定记住这句： 加载阶段也就是查找获取类的二进制数据（磁盘或者网络）动作，将类的数据（Class 的信息：类的定义或者结构）放入方法区 （内存） 。

一图说明：

类加载器

把类加载阶段的 "通过一个类的全限定名来获取描述此类的二进制字节流" 这个动作交给虚拟机之外的类加载器来完成。这样的好处在于，我们可以自行实现类加载器来加载其他格式的类，只要是二进制字节流就行，这就大大增强了加载器灵活性。

系统自带的类加载器分为三种：

1. 启动类加载器 。其它的类加载器都是 java.lang.ClassLoader 的子类，启动类加载器是由 C++ 实现的，没有对应的 Java 对象，因此在 Java 中只能用 null 代替。启动类加载器加载最为基础，最为重要的类，如 JRE 的 lib 目录下 jar 包中的类；扩展类加载器的父类是启动类加载器，它负责加载相对次要，但又通用的类，如 JRE 的 lib/ext 目录下jar包中的类

2. 扩展类加载器 。Java核心类库提供，负责加载java的扩展库（加载 JAVA_HOME/jre/ext/*.jar 中的类），开发者可以直接使用扩展类加载器。

3. 应用程序类加载器 。Java核心类库提供。应用类加载器的父类加载器则是扩展类加载器，它负责加载应用程序路径下的类。开发者可以直接使用这个类加载器，若应用程序中没有定义过自己的类加载器，java 应用的类都是由它来完成加载的。

具体关系如下：

双亲委派机制工作过程：

如果一个类加载器收到了类加载器的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父加载器去完成。每个层次的类加载器都是如此，因此所有的加载请求最终都会传送到 Bootstrap 类加载器(启动类加载器)中，只有父类加载反馈自己无法加载这个请求(它的搜索范围中没有找到所需的类)时，子加载器才会尝试自己去加载。

双亲委派模型的优点：java类随着它的加载器一起具备了一种带有优先级的层次关系.

例如类 java.lang.Object 它存放在 rt.jart 之中，无论哪一个类加载器都要加载这个类.最终都是双亲委派模型最顶端的 Bootstrap 类加载器去加载.因此Object类在程序的各种类加载器环境中都是同一个类.相反.如果没有使用双亲委派模型.由各个类加载器自行去加载的话.如果用户编写了一个称为 "java.lang.Object" 的类，并存放在程序的 ClassPath 中。那系统中将会出现多个不同的Object类，java类型体系中最基础的行为也就无法保证，应用程序也将会一片混乱。

这里也可以用代码验证下：

public class ClassLoaderTest {
    public static void main(String[] args) {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        System.out.println(loader);  
        System.out.println(loader.getParent());  
        System.out.println(loader.getParent().getParent());  
    }
}

输出结果为：

sun.misc.Launcher$AppClassLoader@2a139a55
sun.misc.Launcher$ExtClassLoader@7852e922
null

跟前面的描述是一致的。启动类加载器是由 C++ 实现的，没有对应的 Java 对象，因此在 Java 中只能用 null 代替。

自定义类加载器

1、为什么要自定义ClassLoader

因为系统的 ClassLoader 只会加载指定目录下的 class 文件,如果你想加载自己的 class 文件，那么就可以自定义一个 ClassLoader.

而且我们可以根据自己的需求，对 class 文件进行加密和解密。

2. 如何自定义ClassLoader

新建一个类继承自 java.lang.ClassLoader 重写它的 findClass 方法。将 class 字节码数组转换为 Class 类的实例。调用 loadClass 方法加载即可

代码实战：

先是定义一个自定义类加载器

package com.hello.test;

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

public class MyClassLoader extends ClassLoader {
    // 指定路径
    private String path ;
    
    public MyClassLoader(String classPath){
        path=classPath;
    }
 
    /**
     * 重写findClass方法
     * @param name 是我们这个类的全路径
     * @return
     * @throws ClassNotFoundException
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        Class log = null;
        // 获取该class文件字节码数组
        byte[] classData = getData();
 
        if (classData != null) {
            // 将class的字节码数组转换成Class类的实例
            log = defineClass(name, classData, 0, classData.length);
        }
        return log;
    }
 
    /**
     * 将class文件转化为字节码数组
     * @return
     */
    private byte[] getData() {
 
        File file = new File(path);
        if (file.exists()){
            FileInputStream in = null;
            ByteArrayOutputStream out = null;
            try {
                in = new FileInputStream(file);
                out = new ByteArrayOutputStream();
 
                byte[] buffer = new byte[1024];
                int size = 0;
                while ((size = in.read(buffer)) != -1) {
                    out.write(buffer, 0, size);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    in.close();
                } catch (IOException e) {
 
                    e.printStackTrace();
                }
            }
            return out.toByteArray();
        }else{
            return null;
        }
    }
}

可以再 getData 里面做很多事情 ，比如加密解密之类的 都是可以的。

接着创建一个试验 class :

package com.hello.test;

public class Log {
    public static void main(String[] args) {
        System.out.println("load Log class successfully from log " );
    }
}

执行命令行 javac Log.java 生成我们的 Log.class 文件:

最后就是进行加载：

package com.hello.test;

import java.lang.reflect.Method;

public class ClassLoaderTest {
    public static void main(String[] args) {
         // 这个类class的路径,自己复制自己电脑的路径
        String classPath = "/Users/yourname/Documents/workspace-sts-3.9.6.RELEASE/HelloWorld/src/Log.class";
 
        MyClassLoader myClassLoader = new MyClassLoader(classPath);
        // 类的全称，对应包名
        String packageNamePath = "com.hello.test.Log";
        try {
        // 加载Log这个class文件
            Class<?> Log = myClassLoader.loadClass(packageNamePath);
            System.out.println("类加载器是:" + Log.getClassLoader());
            // 利用反射获取main方法
            Method method = Log.getDeclaredMethod("main", String[].class);
            Object object = Log.newInstance();
            String[] arg = {"ad"};
            method.invoke(object, (Object) arg);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

输出结果如下：

可以看到是委托父类进行加载的。 到此，关于类加载器的内容就说完了。

巩固练习

最后我们再来看一道升级过后的题目：

public class Book {
 
    static int amount1 = 112;

    static Book book = new Book();  // 入口1


    public static void main(String[] args) {
        staticFunction();
    }


    static {
        System.out.println("书的静态代码块");
    }

    {
        System.out.println("书的普通代码块");
    }

    Book() {
        System.out.println("书的构造方法");
        System.out.println("price=" + price +", amount=" + amount + ", amount1=" + amount1);
    }

    public static void staticFunction() {
        System.out.println("书的静态方法");

　　　　 System.out.println("amount=" + amount + ",amount1=" + amount1);
    }
    
    int price = 110;
    static int amount = 112;
    // static Book book = new Book(); // 入口2
}

入口1 的结果

书的普通代码块
书的构造方法
price=110, amount=0, amount1=112
书的静态代码块
书的静态方法
amount=112, amount1=112