类加载机制

class执行流程：类加载器加载class文件——>链接——>初始化——>将数据放到运行数据区——>运行——>卸载

【注：】整个链接过程分为 验证、准备、解析

1. 验证：根据运行数据区的规则要求来判断class文件是否安全
2. 准备：为静态变量分配初始值，例如 int i = 10;在此时i=0
3. 解析：将字符引用 转变为 直接引用（字符其实就是Java文件的引用被编译class文件后的格式，解析时要把字符引用改成指针指向，细节参考： 字符引用_纵有疾风起，壮志不言弃的博客-CSDN博客）

逻辑图示

执行流程

加载：

如下图，类加载器分为三种，顶级Bootstap、第二级和第三级分别为 Extension 和 System

序言：在介绍双亲委派机制的时候，不得不提ClassLoader。说ClassLoader之前，我们得先了解下Java的基本知识。 

一、什么是ClassLoader ?
       Java是运行在Java的虚拟机(JVM)中的，但是它是怎么就运行在JVM中了呢？原来我们在IDE中编写的Java源代码被编译器编译成.class的字节码文件以后。要由我们的ClassLoader负责将这些class文件加载到JVM中去执行。

二、ClassLoader只有一个吗 ？

       实质上，JVM中提供了三层的ClassLoader，这三层加载器是指 JVM 默认加载器，还有另一个是用户自定义加载器：

jvm默认	Bootstrap classLoader	主要负责加载核心的类库(即%JAVA_HOME%\jre\lib下的核心包，比如rt.jar包的java.lang.*等)，安全考虑，只会加载Java、Javax、sun开头的类	c++编辑，无父加载器，也没有继承java.lang.ClassLoader
jvm默认	ExtClassLoader	extensionClassLoader 是由sun.misc.Launcher$ExtClassLoader(jdk8)实现，主要负责加载系统变量java.ext.dirs 或者 %JAVA_HOME%\jre\lib\ext目录下的一些扩展的jar。	java编辑，父加载器是根类加载器
jvm默认	AppClassLoader 或者SystemClassLoader	是由sun.misc.Launcher$AppClassLoader类实现。它的父加载器是Ext加载器，主要负责加载 系统变量Java.class.path 或者 %Java_HOME%\lib & \lib\tool.jar等环境变量 指定的应用程序的主函数类，一半是程序的默认加载类，可以通过ClassLoader.getSystemClassLoader()直接获得	Java编写,父加载器是ext加载器,我们自定义一个类就是通过这个加载器加载
用户自定义	CustomerClassLoader		继承java.lang.ClassLoader，如果感觉Application加载器无法满足需求，可以自定义一个类加载器去 optimize

双亲委派机制：

       那如果有一个Hello.class文件，它是如何被加载到JVM中的呢？

打开IDE，搜索下“ClassLoader”,然后打开“java.lang”包下的ClassLoader类。然后将代码翻到loadClass方法：

 public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }
    //              -----??-----
    protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }
 
                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    c = findClass(name);
                }
            }
            return c;
    }

其实这段代码已经很好的解释了双亲委派机制，为了直观，我找了一张图来描述一下上面一段代码到底是怎么做的：  

       从上图中我们就更容易理解了，当一个Hello.class这样的文件要被加载时。不考虑我们自定义类加载器，首先会在AppClassLoader中检查是否加载过，如果有那就无需再加载了。如果没有，那么会拿到父加载器，然后调用父加载器的LoadClass方法。父类中同理会先检查自己是否已经加载过，如果没有再往上。注意这个过程，知道到达Bootstrap classLoader之前，都是没有哪个加载器自己选择加载的。如果父加载器无法加载，会下沉到子加载器去加载，一直到最底层，如果没有任何加载器能加载，就会抛出ClassNotFoundException。

为什么要设计这种机制
这种设计有个好处是，如果有人想替换系统级别的类：String.java。篡改它的实现，但是在这种机制下这些系统的类已经被Bootstrap classLoader加载过了，所以并不会再去加载，从一定程度上防止了危险代码的植入。

【注：】

切记，一定是先加载核心包，再加载扩展包，最后再加载作者代码

       举个例子，如果你自定义一个String 类，那这个类无法被执行，以为最终要走到 BootStrap加载器 ，但是在这之前该加载器已经对java.lang.String进行类加载，你的自定义String类根本不会再被加载，所以安全的一逼，除非你去改核心包的class文件

附：最后对 ExtClassLoader 补充一下

ExtClassLoader源码

private static File[] getExtDirs(){
    String s = System.getProperty("java.ext.dirs");
    File[] dirs;
    if(s != null){
        StringTokenizer st = new StringTokenizer(s,File.pathSeparator);
        int count = st.countTokens();
        dirs = new File[count];
        for(int i = 0; i< count;i++){
            dirs[i] = new File(st.nextToken());
        }
    } else{
        dirs = new File[0];
    }
    return dirs;
}

举个例子 我们在ext目录下找到dnsns.jar，找到里面的DNSNameService，然后在main函数直接打印：System.out.println("dnsnameservice 加载器："+ DNSNameService.class.getClassLoader());
下图可以看到控制台的打印结果