JVM双亲委派模型

双亲委派原理

除了顶层的启动类加载器（Bootstrap ClassLoader）外，其余的类加载器都应当有自己的上层加载器，如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给上层的加载器，如果上层类加载器还存在其上层类加载器，则进一步向上委托，依次递归，直到请求最终到达顶层的启动类加载器，从顶层类加载器开始，如果类加载器根据类的全限定名查询到已经加载过这个类，就成功返回加载过的此类信息，倘若加载器未加载过此类，则原路返回给下层加载器继续重复此过程，直到最先加载此类的加载器所有上层加载器都未加载过此类后，此类加载器才会尝试自己去加载，这便是双亲委派模式。

类加载器三个机制

• 委托：指加载一个类的请求交给父类加载器，若父类加载器不可以找到或者加载到，再加载这个类
• 单一性：指子类加载器不会再次加载父类加载器已经加载过的类
• 可见性：子类加载器可以看见父类加载器加载的所有类，而父类加载器不可以看到子类加载器加载的类

举个栗子：

假如你是某个企业员工，你写了一份方案希望得到执行，首先你得拿给你的经理去审批吧，经理说这个事情他做不了主，于是经理就拿给总经理看，总经理也做不了主，就给董事长看，然后董事长看了看，也看不明白于是让总经理自己拿主意吧，总经理仔细一看，这个方案之前公司已经做过了，于是让经理去告诉那个员工不用做了，直接用那个做过的方案吧。

双亲委派的意义

采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系，通过这种层级关系可以避免类的重复加载，当上层类加载器已经加载了该类时，就没有必要下层的ClassLoader再加载一次。

其次是考虑到安全因素，jdk中定义的类不会被随意替换，假设我们在classpath路径下自定义一个名为java.lang.Integer的类，通过双亲委托模式传递到启动类加载器，而启动类加载器通过索引发现同全限定名的类已被加载，并不会重新加载网络传递的过来的java.lang.Integer，而直接返回已加载过的Integer.class，那么你所定义的类就不会被加载，这样便可以防止核心API库被随意篡改。

如：

package java.lang;

public class Integer {

    public void print(){
        System.out.println("this is Integer.");
    }

    public static void main(String[] args) {
        new Integer().print();
    }
}

执行main方法后输出如下：

JVM提供的类加载器

• 启动类加载器（BootstrapClassLoader）:由jvm负责管理，主要负责加载核心的类库(**rt.jar，也就是java.lang.***等)，并构造和启动ExtClassLoader和APPClassLoader。

• 扩展类加载器（ExtClassLoader）：主要负责加载jre/lib/ext**目录下的一些扩展的jar。

• 应用类加载器（AppClassLoader）：主要负责加载classpath下jar包和应用程序的主函数类。

如果当前类加载器加载的类引用了其它类，那么也会通过递归的方式先对其所有引用进行加载。

执行类加载的五种方式

认识了这三种类加载器，接下来我们看看类加载的五种方式。

1. 通过命令行使用java命令启动应用时由JVM初始化加载含有main()方法的主类。
2. 使用new关键字初始化一个对象时
3. 通过类对应的Class对象的newInstance()方法
4. 通过Class.forName(name)方法动态加载
5. 通过ClassLoader.loadClass(name)方法动态加载

自定义类加载器

java系统为我们提供的三种类加载器，还给出了他们的层次关系图，最下面就是自定义类加载器，那么我们如何自己定义类加载器呢？这主要有两种方式

（1）遵守双亲委派模型：继承ClassLoader，重写findClass方法。

通常我们推荐采用此方式自定义类加载器，最大程度上的遵守双亲委派模型。

findClass(name)查找具有指定全限定名的类。此方法用于遵循加载类的委托模型的类装入器实现重写，并将在检查请求类的父类装入器之后由loadClass方法调用。如果该类没有被加载过且其class文件读取不到则抛出ClassNotFoundException异常。

    protected Class<?> findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }

其实现例子：

package com.aliencat.javabase.classloader;

public class MyClassLoader extends ClassLoader{

    protected Class<?> findClass(String name) throws ClassNotFoundException {
        switch (name){
            case "java.lang.Integer":return Double.class;
            case "com.aliencat.javabase.classloader.LoaderDemo" :  return loadClassFromDisk(name);
        }
        throw new ClassNotFoundException(name);
    }

    //从calsspath下加载类的字节码文件
    public byte[] loadClassFromDisk(String name) {
        String classPathRoot = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        classPathRoot = classPathRoot.substring(1);
        String filePath = classPathRoot + name.replace(".","/") + ".class";
        try(InputStream in = new FileInputStream(filePath) ;
            ByteOutputStream stream = new ByteOutputStream()) {
            byte[] buff = new byte[1024];
            for(int num = 0; (num=in.read(buff)) != -1;){
                stream.write(buff,0,num);
            }
            return stream.toByteArray();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }


    public static void main(String[] args) throws ClassNotFoundException {
        Class clzz = new MyClassLoader().loadClass("com.aliencat.javabase.classloader.LoaderDemo");
        System.out.println(clzz);
        clzz = new MyClassLoader().loadClass("java.lang.Integer");
        System.out.println(clzz);
        clzz = new MyClassLoader().loadClass("java.lang.String");
        System.out.println(clzz);
        clzz = new MyClassLoader().loadClass("java.lang.xxxxx");
        System.out.println(clzz);
    }
}

输出如下：

（2）破坏双亲委派模型：继承ClassLoader,重写loadClass方法。

我们先来看下loadClass方法的源码是怎样的：

    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 {
                        //让BootstrapClass类加载器去查找该类
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // 上层类加载器抛出了ClassNotFoundException 则不进行处理

                }

                if (c == null) {

                    long t1 = System.nanoTime();
                    // 如果上层类加载器都没有找到
                    // 那么这个类加载器自己去找
                    // 如果找到了，则将resolve置为true
                    c = findClass(name);

                    // 这是定义类加载器；记录统计数据
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                //解析此类的信息
                resolveClass(c);
            }
            return c;
        }
    }

示例如下：

public class MyClassLoader extends ClassLoader {

    public static void main(String[] args) throws ClassNotFoundException {
        Class clzz = new MyClassLoader().loadClass("com.aliencat.javabase.classloader.ClassTest");
        System.out.println(clzz);
        clzz = new MyClassLoader().loadClass("java.lang.Double");
        System.out.println(clzz);
        clzz = new MyClassLoader().loadClass("java.lang.String");
        System.out.println(clzz);
    }

    protected Class<?> findClass(String name) throws ClassNotFoundException {
        switch (name) {
            case "java.lang.Double":
                return Integer.class;
            case "java.lang.Object":  //如果去掉此项，则破坏双亲委任的情况下会报找不到Object的NoClassDefFoundError异常
                return Object.class;
            case "com.aliencat.javabase.classloader.ClassTest":
                byte[] bytes = loadClassFromDisk(name);
                if(bytes != null){
                    return defineClass(name,bytes,0,bytes.length);
                }else {
                    return null;
                }
        }
        throw new ClassNotFoundException(name);
    }

    //从calsspath下加载类的字节码文件
    public byte[] loadClassFromDisk(String name) {
        String classPathRoot = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        classPathRoot = classPathRoot.substring(1);
        String filePath = classPathRoot + name.replace(".","/") + ".class";
        try(InputStream in = new FileInputStream(filePath) ;
            ByteOutputStream stream = new ByteOutputStream()) {
            byte[] buff = new byte[1024];
            for(int num = 0; (num=in.read(buff)) != -1;){
                stream.write(buff,0,num);
            }
            return stream.toByteArray();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException {
        synchronized (LoaderDemo.class) {
            // 首先，在当前加载器加载过的类中检查这个类有没有被加载过
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                //没加载过的话就去磁盘对应路径下去找
                c = findClass(name);
            }
            return c;
        }
    }

}

class ClassTest{

}

输出如下：

所以破坏双亲委托的方法简单来说就是通过继承ClassLoader重写loadClass方法，去掉其中委托给上级加载类的相关逻辑然后实现自定义的加载类的findClass逻辑。（另外你可以试试把ClassTest替换String的类名是什么效果哦，我就不演示了）

Q:前面说了一堆双亲委托的好处，那么为什么要破坏双亲委托呢？

A:因为在某些情况下父类加载器需要委托子类加载器去加载class文件。受到加载范围的限制，父类加载器无法加载到需要的文件，以JDBC接口为例，由于JDBC接口定义在jdk当中的，而其实现由各个数据库的服务商来提供，比如mysql的就写了MySQL-Connector，那么问题就来了，JDBC接口由启动类加载器加载，而JDBC的实现是由服务商提供的，并不在启动类加载器的加载目录下，在不破坏双亲委派的情况下，启动类加载器下层的类加载器要加载JDBC则必然会返回启动类加载器中已经加载过的接口，那么服务商提供的JDBC就不会被加载，所以需要自定义类加载器破坏双亲委派拿到服务商实现的JDBC接口，这里仅仅是举了破坏双亲委派的其中一个情况，类似的还有tomcat。