类加载机制（什么是类加载机制，类加载的时机和过程，类加载器，自定义类加载器）...

一、什么是类加载机制

        虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，就是虚拟机的类加载机制。

二、类加载的时机

        类从被加载到虚拟机内存中，到卸载出内存，它的整个生命周期包括：加载、连接（验证、准备、解析）、初始化、使用和卸载。如图所示：

            

        加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的，类的加载过程必须按照这种顺序开始。为了支持Java的运行时绑定，解析阶段在某些情况下可以在初始化阶段之后在开始。

        哪么什么时候需要开始类加载的第一个阶段“加载”呢？Java虚拟机规范中并没有进行强制约束，这可以由具体的虚拟机实现来自由把握。但是对于初始化阶段，虚拟机规范要求必须在每个类或接口被Java程序首次主动使用时才初始化它们。

• 主动使用：

            ①创建类的实例（使用new关键字实例化对象的时候）。

            ②读取或设置某个类的静态变量（被final修饰的字段、已经在编译期把结果放入常量池的字段除外）。

            ③调用类的静态方法。

            ④通过java.lang.reflect包的方法对类进行反射调用的时候。

            ⑤初始化一个类的子类。（如果父类没有初始化，需要先初始化父类）

            ⑥虚拟机启动时，指定要执行的主类（包含main()方法的类）

            ⑦当使用JDK  1.7的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没                 有进行过初始化，则需要先触发其初始化。

•  被动使用：   

            除了以上的几种情况，其他使用Java类的方式都被看作时对类的被动使用，不会导致类的初始化。下面我们来看几个被动引用的例子：

    ①通过子类引用父类的静态字段或方法，不会导致子类初始化。

public class NotInitializationDemo01 {

    public static void main(String[] args) {
        /**
         * 通过子类引用父类的静态字段或方法，不会导致子类初始化
         */
        System.out.println(SubClass01.value);
        SubClass01.doSomething();
    }
}

class SuperClass01{

    public static int value = 1;

    static {
        System.out.println("SuperClass init!");
    }

    public static void doSomething(){
        System.out.println("SuperClass static doSomething()");
    }

}

class SubClass01 extends SuperClass01{
    static {
        System.out.println("SubClass init!");
    }
}

    运行结果如下：

        

    ②通过数组定义来引用类，不会触发此类的初始化。

public class NotInitializationDemo02 {

    public static void main(String[] args) {
        /**
         * 通过子类引用父类的静态字段或方法，不会导致子类初始化
         */
        ArrayClass[] arrayClasses = new ArrayClass[10];
    }
}

class ArrayClass{

    static {
        System.out.println("ArrayClass init!");
    }
}

    运行结果如下：

        

        没有输出“ArrayClass init！”，说明并没有触发类com.caofanqi.classload.ArrayClass 的初始化阶段。但是这段代码里面触发了另外一个名为“[Lcom.caofanqi.classload.ArrayClass”的类的初始化阶段，对于用户代码来说，这并不是一个合法的类名称，它是一个由虚拟机自动生成的、直接继承于java.lang.Object的子类，创建动作由字节码指令newarray触发。

    ③常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。

public class NotInitializationDemo03 {

    public static void main(String[] args) {
        /**
         * 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
         */
        System.out.println(ConstClass.HELLOWORLD);
    }
}

class ConstClass {

    public static final String HELLOWORLD = "hello world";

    static {
        System.out.println("ConstClass init！");
    }

}

        运行结果如下：

            

        虽然在Java源码中引用了ConstClass类中的常量HELLOWORLD，但其实在编译阶段通过常量传播优化，已经将此常量的值“hello world”存储到了NotInitializationDemo03类的常量池中，以后NotInitializationDemo03对常量ConstClass.HELLOWORLD的引用实际都被转化为NotInitializationDemo03类对自身常量池的引用了。也就是说，实际上NotInitializationDemo03的Class文件之中并没有ConstClass类的符号引用入口，这两个类在编译成Class之后就不存在任何联系了。

        注意：当Java虚拟机初始化一个类时，要求它的父类都已经被初始化，但是这条规则不适用于接口。一个父接口并不会因为它的子接口或者实现类的初始化而初始化。只有当程序首次使用特定接口的静态变量时，才会导致该接口的初始化。

三、类加载的过程

        1、加载：是类加载的一个阶段。在加载阶段，虚拟机需要完成3件事情

                      ①通过一个类的全限定名来获取定义此类的二进制字节流。

                      ②将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。

                      ③在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据访问入口。（对于HotSpot虚拟机而言，Class对象比较特殊，虽然是对象，但是存放在方法区里面）

           加载.class文件的几种方式：

                    ①从本地系统中直接加载。②从网络下载.class文件。③从zip，jar等文件中加载.class文件。④从专有数据库中提取.class文件。⑤运行时计算生成（动态代理技术）

        2、验证：是连接阶段的第一步，目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并不会危害虚拟机自身的安全。（通过javac编译出来的.class文件是安全的，但是也可以通过其他途径获得.class文件，如果不检查可能会导致系统崩溃，所以验证是虚拟机对自身保护的一项重要工作）

             验证阶段大致会完成以下检验动作：①文件格式验证（如是否以魔数0xCAFEBABE开头等）②元数据验证（如是否继承了被final修饰的类等）③字节码验证（确定程序语义合法、符合逻辑）④符号引用验证（如符号引用中通过字符串描述的全限定名是否能找到对应的类）

        3、准备：该阶段正式为类变量分配内存并设置类变量初始值，这些变量所使用的内存都将在方法区中进行分配。这里进行内存分配的仅包含类变量（被static修饰的变量），不包括实例变量，实例变量会在对象实例化时随着对象分配在java堆中。

        例如：public static int value = 1; value在准备阶段后的初始值是0而不是1，因为在这时还没有执行任何java方法，而把value赋值为1的指令被程序编译后，会存放在类构造器<clinit>()方法中，所以把value赋值为1的动作将在初始化阶段才会执行。但是被final修饰的常量例外，在准备阶段就会被初始化为所指定的值。

        4、解析：虚拟机将常量池内的符号引用替换为直接引用。如果有了直接引用，那么引用的目标必定已经在内存中存在。

        5、初始化：类初始化阶段是类加载过程的最后一步，前面的类加载过程中，除了在加载阶段用户可以通过自定义类加载器参与之外，其它都是完全由虚拟机主导和控制的。到了初始化阶段，才真正开始执行类中定义的java代码。是执行类构造器<clinit>()方法的过程。

          ①<clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态代码块（static{}）中的语句合并产生的，收集的顺序是由语句在源代码中出现的顺序决定的，静态代码块只能访问到定义在静态代码块之前的变量，定义在它后面的变量，在前面的静态代码块可以赋值，但是不能访问。如下所示：

public class Demo04 {

    static {
        i = 123; //赋值可以通过
        //System.out.println(i); //不能使用定义在后面的变量，会包“非法前向引用”的Error
    }

    public static int i;

    public static void main(String[] args) {
        System.out.println(Demo04.i);
    }

}

执行结果：

①没有打开注释 ②打开注释

        ②<clinit>()方法于类的构造函数（实例构造器<init>()方法）不同，它不需要显示地调用父类构造器，虚拟机会保证在子类<clinit>()方法执行之前，父类的<clinit>()方法已经执行完毕。所以在虚拟机中第一个被执行的<clinit>()方法的类肯定是java.lang.Object。示例如下：

public class Demo05 {

    public static void main(String[] args) {
        /**
         * 会先执行父类的<clinit>()方法，然后执行子类的<clinit>()方法
         * 也就是说会先执行父类的静态代码块，然后执行子类的静态代码块
         */
        System.out.println(SubClass05.b);
    }

}

class SuperClass05{

    public static int a = 1;

    static {
        a = 2;
        System.out.println("SuperClass init!");
    }

}

class SubClass05 extends SuperClass05{

    public static int b = a;
    static {
        System.out.println("SubClass init!");
    }
}

        运行结果如下：

            

    ③＜clinit＞()方法对于类或接口来说并不是必需的，如果一个类中没有静态语句块，也没有对变量的赋值操作，那么编译器可以不为这个类生成＜clinit＞()方法。

    ④接口中不能使用静态语句块，但仍然有变量初始化的赋值操作，因此接口与类一样都会生成＜clinit＞()方法。但接口与类不同的是，执行接口的＜clinit＞()方法不需要先执行父接口的＜clinit＞()方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的＜clinit＞()方法。

    ⑤虚拟机会保证一个类的＜clinit＞()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的＜clinit＞()方法，其他线程都需要阻塞等待，直到活动线程执行＜clinit＞()方法完毕。

四、类加载器

        类加载器用来把类加载到Java虚拟机中。从JDK1.2版本开始，类的加载过程采用双亲委派模型，这种机制能更好的保证Java平台的安全性。

    1、类加载器的种类：

            ①启动类加载器（Bootstrap ClassLoader），使用C++语言实现，是虚拟机自身的一部分，加载<JACA_HOME>\lib（如rt.jar），或者被-Xbootclasspath参数限定的类；

            ②扩展类加载器（Extension ClassLoader），Java语言实现，是java.lang.ClassLoader子类，加载<JACA_HOME>\lib\ext，或者被java.ext.dirs系统变量指定的类；

            ③应用程序类加载器（Application ClassLoader），Java语言实现，是java.lang.ClassLoader子类，加载ClassPath路径所指定的类。

            ④自定义类加载器，通过继承ClassLoader实现，一般是加载我们的自定义类。

    2、双亲委派模型

                

        类加载器之间的这种层次关系，称为类加载器的双亲委派模型（Parents Delegation Model）。双亲委派模型要求除了顶层的启动类加载器外，其余的类加载器都应当有自己的父类加载器。这里类加载器之间的父子关系一般不会以继承（Inheritance）的关系来实现，而是都使用组合（Composition）关系来复用父加载器的代码。

        双亲委派模型的工作过程是：如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去加载。

        在双亲委派模型中，各个加载器按照父子关系形成了树形结构，除了根类加载器以外，其余的类加载器都有且只有一个父加载器。

        双亲委派好处：①避免同一个类被多次加载；②每个加载器只能加载自己范围内的类；

    3、命名空间

            每个类加载器都有自己的命名空间，命名空间由该加载器及所有父加载器所加载的类组成。在同一个命名空间中，不会出现全限定名相同的两个类。在不同的命名空间中，又可能会出现全限定名相同的俩个类。

        这里就涉及到一个面试题：我们可以自己写一个java.lang.String类么，答案是不能的，因为java.lang.String是由启动类加载器加载的，命名空间中已经存在，所以不可以。

    4、运行时包

        由同一类加载器加载的属于相同包的类组成了运行时包。决定两个类是不是属于同一个运行时包，不仅要看它们的包名是否相同，还要看定义类加载器是否相同。只有属于同一运行时包的类才能互相访问包可见（即默认访问级别）的类和类成员。这样的限制能避免用户自定义的类冒充核心类库的类，去访问核心类库的包可见成员。

        假设用户自己定义了一个类java.lang.MyString，并由用户自定义的类加载器加载，由于java.lang.MyString和核心类库java.lang.*由不同的加载器加载，它们属于不同的运行时包，所以java.lang.MyString和核心类库java.lang.*由不同的加载器加载，它们属于不同的运行时包，所以java.lang.MyString不能访问核心类库java.lang包中的包可见成员。

     5、自定义类加载器

           继承java.lang.ClassLoader类，重写findClass(String name)方法即可，如下所示：

package com.caofanqi.classload;

import java.io.*;

/**
 * 自定义类加载器
 */
public class MyClassLoader extends ClassLoader {

    private String name; //类加载器的名字

    private String classPath;// 加载类的路径

    private final String fileType = ".class"; // class文件的扩展名

    public MyClassLoader(String name, String classPath) {
        super();
        this.name = name;
        this.classPath = classPath;
    }

    public MyClassLoader(String name, String classPath, ClassLoader parent) {
        super(parent);
        this.name = name;
        this.classPath = classPath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = getData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        } else {
            return defineClass(name, classData, 0, classData.length);
        }
    }

    private byte[] getData(String className) {
        InputStream is = null;
        byte[] data = null;
        ByteArrayOutputStream baos = null;

        String path = classPath + File.separatorChar + className.replace('.', File.separatorChar) + fileType;

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

            int ch = 0;
            while (-1 != (ch = is.read())) {
                baos.write(ch);
            }
            data = baos.toByteArray();
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            try {
                is.close();
                baos.close();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        return data;
    }

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

    public static void main(String args[]) throws ClassNotFoundException,
            InstantiationException, IllegalAccessException {
        ClassLoader myClassLoader = new MyClassLoader("myClassLoader", "E:\\test");
        Class c = myClassLoader.loadClass("TestClassLoad");//注意要包括包名
        System.out.println(c.newInstance());//打印类加载成功.
    }
}

    TestClassLoad如下，编译好后将.class文件放到指定位置，删除classpath下的.class

public class TestClassLoad {
    @Override
    public String toString() {
        return  this.getClass().getClassLoader() + "类加载成功。";
    }
}

测试如下：

 

源代码：https://gitee.com/itcaofanqi/CaoFanqiStudyRepository/tree/master/stujvm

转载于:https://my.oschina.net/caofanqi/blog/3014924