JVM双亲委派模型

谁践踏了优雅 2021-06-10 20:41 494阅读 0赞

### 文章目录 ###

*   *   *  双亲委派原理
         *  双亲委派的意义
         *  JVM提供的类加载器
         *  执行类加载的五种方式
         *  自定义类加载器
         *   *  （1）遵守双亲委派模型：继承ClassLoader，重写findClass方法。
             *  （2）破坏双亲委派模型：继承ClassLoader,重写loadClass方法。
             *  Q:前面说了一堆双亲委托的好处，那么为什么要破坏双亲委托呢？

### 双亲委派原理 ###

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2MxNTE1ODAzMjMxOQ_size_10_color_FFFFFF_t_70_pic_center]

举个栗子：

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

### 双亲委派的意义 ###

采用双亲委派模式的是好处是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方法后输出如下：

![在这里插入图片描述][20210521180835276.png_pic_center]

### 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);
        }
    }

**输出如下：**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2MxNTE1ODAzMjMxOQ_size_16_color_FFFFFF_t_70_pic_center]

#### （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{
    
    }

**输出如下：**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2MxNTE1ODAzMjMxOQ_size_16_color_FFFFFF_t_70_pic_center 1]

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

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

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2MxNTE1ODAzMjMxOQ_size_10_color_FFFFFF_t_70_pic_center]: /images/20210606/af7c857bb8a740d68d70ffc309fab38c.png
[20210521180835276.png_pic_center]: /images/20210606/db84b25f0eb24406b909bc4ae4a50e28.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2MxNTE1ODAzMjMxOQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20210606/51c7214e4b014b67acd0ff61294216c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2MxNTE1ODAzMjMxOQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20210606/b92b9fbf85e14bef8b40eab83d849874.png