Java类加载器和双亲委派模式

在Java的世界中，如果说类站在了第一梯队，那么类加载器就是第一梯队背后的男人（调皮下），正是有了类加载器，才得以使自己编写的类能够正确加载到jvm内存区域中。

我们有一段编译好的class文件，我们会使用如下命令执行

java.exe -Dfile.encoding=UTF-8 com.example.User

，java.exe 会调用jvm.dll启动jvm实例，然后执行程序中的main。
这样一个类也就加载完了，大致是这么个流程。下面看下具体的步骤。

加载类的步骤

分为如下步骤：

1. 准备加载：从硬盘系统加载到内存
2. 验证阶段：如验证文件的准确性；
3. 准备阶段：将静态变量设置为默认值
4. 解析阶段：将符号引用转为直接引用
   假设有个静态字段 static int a = 0, a 就是那个符号，加载的时候a的内存地址就已经确定了，这就是直接引用
   符号引用呢，一个非静态字段 User a = new User(); 这个类加载的new User()并不知道具体地址，只能当前类实例化的时候才能知道，用符号代替，这就是符号引用
5. 初始化：对类的静态变量实际赋值，执行静态代码块中的代码

类何时加载

简单来说，就是懒加载，及用时加载。如何验证？代码如下：

static class A {
        static int a = 1;

        static {
            System.out.println("A类已经加载");
        }
    }

    static class B extends A {
        static {
            System.out.println("B类已经加载");
        }
    }

    public static void load(){
        System.out.println(B.a);
    }

运行结果：

A类已经加载
1

这个结果并不意外，如果对应类加载的步骤，就很好理解了，首先A.a是个静态变量，A.a要有实际值一定会走到类加载步骤的第五步，所以A类加载了。

加载器分类

1. 引导类加载器（BootStrapClassLoader）
   加载jdk安装目录下jre\lib目录下的类，如：rt.jar
2. 扩展类加载器（ExtClassLoader）
   加载jdk安装目录下jre\lib\ext目录下的类
3. 应用程序类加载器（AppClassLoader）
   加载classpath下的类

双亲委派模式

我们前面已经说到，运行一个main程序的时候，jvm实例就已经启动了，C++写的代码会调用Java语言编写的类加载器，一些核心类库必须首先加载才能保证我们编写的Java程序能够执行不报错，所以BootStrapClassLoader加载器一定会加载rt.jar等包

一个user类准备加载，首先AppClassLoader并不会主动加载，而是委派它的父加载器ExtClassLoader，如果一圈下来，将由ClassLoader.getSystemClassLoader() 进行加载（AppClassLoader）
ClassLoader中的代码

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                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.
                    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;
        }
    }

双亲委派存在的意义

1. 避免了类的重复加载，每一个类加载器都有自己加载的范围
2. 放置核心类库被修改，比如有个自定义的类全限定名是：java.lang.String，这个类并不会被加载，而是直接会返回 rt.jar中的Java.lang.String。

打破双亲委派模式

1. 这就需要重写ClassLoader的loadClass方法了，不使用原有逻辑，也是一种打破
2. 线程上下文类加载器（Thread Context ClassLoader）
3. 实现了热部署的功能也要打破双亲委派，部署的代码永远是用户自定义代码，所以这部分代码需要热加载

实现自己的类加载器

重写ClassLoader的findClass方法，并调用defineClass返回Class对象