双亲委派机制

清疚 2022-09-08 06:19 301阅读 0赞

双亲委派机制
JVM类加载器是有亲子层级结构的，如下图

在这里插入图片描述
这里类加载其实就有一个双亲委派机制，加载某个类时会先委托父加载器寻找目标类，找不到再 委托上层父加载器加载，如果所有父加载器在自己的加载类路径下都找不到目标类，则在自己的 类加载路径中查找并载入目标类。 比如我们的Math类，最先会找应用程序类加载器加载，应用程序类加载器会先委托扩展类加载 器加载，扩展类加载器再委托引导类加载器，顶层引导类加载器在自己的类加载路径里找了半天 没找到Math类，则向下退回加载Math类的请求，扩展类加载器收到回复就自己加载，在自己的 类加载路径里找了半天也没找到Math类，又向下退回Math类的加载请求给应用程序类加载器， 应用程序类加载器于是在自己的类加载路径里找Math类，结果找到了就自己加载了。
双亲委派机制说简单点就是，先找父亲加载，不行再由儿子自己加载

为什么要设计双亲委派机制？
沙箱安全机制：自己写的java.lang.String.class类不会被加载，这样便可以防止核心API库被随意篡改。
避免类的重复加载：当父亲已经加载了该类时，就没有必要子ClassLoader再加载一 次，保证被加载类的唯一性。

全盘负责委托机制
全盘负责是指当一个ClassLoder装载一个类时，除非显示的使用另外一个ClassLoder，该类 所依赖及引用的类也由这个ClassLoder载入。

自定义类加载器示例（沿用双亲委派机制）：
自定义类加载器只需要继承 java.lang.ClassLoader 类，该类有两个核心方法，一个是 loadClass(String, boolean)，实现了双亲委派机制，还有一个方法是findClass，默认实现是空 方法，所以我们自定义类加载器主要是重写findClass方法。

  1. import java.io.FileInputStream;
  2. import java.lang.reflect.Method;
  4. public class MyClassLoaderTest { 
  5.     static class MyClassLoader extends ClassLoader{ 
  6.         private String classPath;
  8.         public MyClassLoader(String classPath){ 
  9.             this.classPath = classPath;
  10.         }
  12.         private byte[] loadByte(String name) throws Exception{ 
  13.             name = name.replaceAll("\\.","/");
  14.             FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
  15.             int len = fis.available();
  16.             byte[] data = new byte[len];
  17.             fis.read(data);
  18.             fis.close();
  19.             return data;
  20.         }
  22.         @Override
  23.         protected Class<?> findClass(String name) throws ClassNotFoundException{ 
  24.             try { 
  25.                 byte[] data = loadByte(name);
  26.                 // defineClass将一个字节数组转为Class对象，
  27.                 // 这个字节数组是class文件读取后最终的字节数组。
  28.                 return defineClass(name, data,0, data.length);
  29.             }catch (Exception e){ 
  30.                 e.printStackTrace();
  31.                 throw new ClassNotFoundException();
  32.             }
  33.         }
  34.     }// MyClassLoader
  36.     public static void main(String args[]) throws Exception{ 
  37.         // 初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器
  38.         // 的父加载器设置为应用程序类加载器AppClassLoader
  39.         MyClassLoader classLoader = new MyClassLoader("D:\\111");
  40.         // 如果运行环境也有User类，就不会用自定义ClassLoader加载
  41.         Class clazz = classLoader.loadClass("User");
  42.         Object obj = clazz.newInstance();
  43.         Method method = clazz.getDeclaredMethod("sout",null);
  44.         method.invoke(obj,null);
  45.         System.out.println(clazz.getClassLoader().getClass().getName());
  46.     }
  47. }

运行结果：
在这里插入图片描述
打破双亲委派机制
尝试打破双亲委派机制，用自定义类加载器加载我们自己实现的java.lang.String.class，除了重写findClass方法还要重写loadClass方法。

  1. import java.io.FileInputStream;
  2. import java.lang.reflect.Method;
  3. import java.lang.String;
  5. public class MyClassLoaderTest { 
  6.     static class MyClassLoader extends ClassLoader{ 
  7.         private String classPath;
  9.         public MyClassLoader(String classPath){ 
  10.             this.classPath = classPath;
  11.         }
  13.         private byte[] loadByte(String name) throws Exception{ 
  14.             name = name.replaceAll("\\.","/");
  15.             FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
  16.             int len = fis.available();
  17.             byte[] data = new byte[len];
  18.             fis.read(data);
  19.             fis.close();
  20.             return data;
  21.         }
  23.         @Override
  24.         protected Class<?> findClass(String name) throws ClassNotFoundException{ 
  25.             try { 
  26.                 byte[] data = loadByte(name);
  27.                 // defineClass将一个字节数组转为Class对象，
  28.                 // 这个字节数组是class文件读取后最终的字节数组。
  29.                 return defineClass(name, data,0, data.length);
  30.             }catch (Exception e){ 
  31.                 e.printStackTrace();
  32.                 throw new ClassNotFoundException();
  33.             }
  34.         }
  36.         /** * 重写类加载方法，实现自己的加载逻辑，不委派给双亲加载 * @param name * @param resolve * @return */
  37.         @Override
  38.         protected Class<?> loadClass(String name, boolean resolve)
  39.                 throws ClassNotFoundException{ 
  40.             synchronized (getClassLoadingLock(name)){ 
  41.                 // First, check if the class has already been loaded
  42.                 Class<?> c = findLoadedClass(name);
  44.                 if(c == null){ 
  45.                     long t1 = System.nanoTime();
  47.                     //非自定义的类还是走双亲委派加载
  48.                     if (!name.startsWith("com.tom"))
  49.                     { 
  50.                         c = this.getParent().loadClass(name);
  51.                     }else{ 
  52.                         c = findClass(name);
  53.                     }
  55.                     // this is the defining class loader;record the stats
  56.                     sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
  57.                     sun.misc.PerfCounter.getFindClasses().increment();
  58.                 }// if c == null
  59.                 if(resolve){ 
  60.                     resolveClass(c);
  61.                 }
  62.                 return c;
  63.             }
  64.         }
  66.     }// MyClassLoader
  68.     public static void main(String args[]) throws Exception{ 
  69.         // 初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器
  70.         // 的父加载器设置为应用程序类加载器AppClassLoader
  71.         MyClassLoader classLoader = new MyClassLoader("D:/111");
  72.         // java.lang.SecurityException: Prohibited package name: java.lang 限制包名,
  73.         // 不能自定义这个包名,与java类库冲突,安全管理器不通过
  74. // Class clazz = classLoader.loadClass("java.lang.String");
  75.         // 但是换个包名就可以
  76.         Class clazz = classLoader.loadClass("com.tom.String");
  77.         Object obj = clazz.newInstance();
  78.         Method method = clazz.getDeclaredMethod("sout",null);
  79.         method.invoke(obj,null);
  80.         System.out.println(clazz.getClassLoader().getClass().getName());
  81.     }
  82. }

Tomcat打破双亲委派机制
以Tomcat类加载为例，Tomcat 如果使用默认的双亲委派类加载机制行不行？ 我们思考一下：Tomcat是个web容器， 那么它要解决什么问题：

  • 一个web容器可能需要部署两个应用程序，不同的应用程序可能会依赖同一个第三方类库的 不同版本，不能要求同一个类库在同一个服务器只有一份，因此要保证每个应用程序的类库都是 独立的，保证相互隔离。
  • 部署在同一个web容器中相同的类库相同的版本可以共享。否则，如果服务器有10个应用程 序，那么要有10份相同的类库加载进虚拟机。
  • web容器也有自己依赖的类库，不能与应用程序的类库混淆。基于安全考虑，应该让容器的 类库和程序的类库隔离开来。
  • web容器要支持jsp的修改，我们知道，jsp 文件最终也是要编译成class文件才能在虚拟机中 运行，但程序运行后修改jsp已经是司空见惯的事情， web容器需要支持 jsp 修改后不用重启。

再看看我们的问题：Tomcat 如果使用默认的双亲委派类加载机制行不行？ 答案是不行的。为什么？
第一个问题，如果使用默认的类加载器机制，那么是无法加载两个相同类库的不同版本的，默认 的类加器是不管你是什么版本的，只在乎你的全限定类名，并且只有一份。
第二个问题，默认的类加载器是能够实现的，因为他的职责就是保证唯一性。
第三个问题和第一个问题一样。
我们再看第四个问题，我们想我们要怎么实现jsp文件的热加载，jsp 文件其实也就是class文 件，那么如果修改了，但类名还是一样，类加载器会直接取方法区中已经存在的，修改后的jsp 是不会重新加载的。那么怎么办呢？我们可以直接卸载掉这jsp文件的类加载器，所以你应该想 到了，每个jsp文件对应一个唯一的类加载器，当一个jsp文件修改了，就直接卸载这个jsp类加载 器。重新创建类加载器，重新加载jsp文件。
Tomcat自定义加载器详解
在这里插入图片描述
tomcat的几个主要类加载器：

  • commonLoader：Tomcat最基本的类加载器，加载路径中的class可以被Tomcat容 器本身以及各个Webapp访问；
  • catalinaLoader：Tomcat容器私有的类加载器，加载路径中的class对于Webapp不 可见； -sharedLoader：各个Webapp共享的类加载器，加载路径中的class对于所有 Webapp可见，但是对于Tomcat容器不可见；
  • WebappClassLoader：各个Webapp私有的类加载器，加载路径中的class只对当前 Webapp可见，比如加载war包里相关的类，每个war包应用都有自己的WebappClassLoader，实现相互隔离，比如不同war包应用引入了不同的spring版本， 这样实现就能加载各自的spring版本；

从图中的委派关系中可以看出：
CommonClassLoader能加载的类都可以被CatalinaClassLoader和SharedClassLoader使用， 从而实现了公有类库的共用，而CatalinaClassLoader和SharedClassLoader自己能加载的类则 与对方相互隔离。
WebAppClassLoader可以使用SharedClassLoader加载到的类，但各个WebAppClassLoader 实例之间相互隔离。
而JasperLoader的加载范围仅仅是这个JSP文件所编译出来的那一个.Class文件，它出现的目的 就是为了被丢弃：当Web容器检测到JSP文件被修改时，会替换掉目前的JasperLoader的实例， 并通过再建立一个新的Jsp类加载器来实现JSP文件的热加载功能。
tomcat 这种类加载机制违背了java 推荐的双亲委派模型了吗？答案是：违背了。
很显然，tomcat 不是这样实现，tomcat 为了实现隔离性，没有遵守这个约定，每个 webappClassLoader加载自己的目录下的class文件，不会传递给父类加载器，打破了双亲委 派机制。
模拟实现Tomcat的webappClassLoader加载自己war包应用内不同版本类实现相互共存与隔离

  1. import java.io.FileInputStream;
  2. import java.lang.reflect.Method;
  3. import java.lang.String;
  5. public class MyClassLoaderTest { 
  6.     static class MyClassLoader extends ClassLoader{ 
  7.         private String classPath;
  9.         public MyClassLoader(String classPath){ 
  10.             this.classPath = classPath;
  11.         }
  13.         private byte[] loadByte(String name) throws Exception{ 
  14.             name = name.replaceAll("\\.","/");
  15.             FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
  16.             int len = fis.available();
  17.             byte[] data = new byte[len];
  18.             fis.read(data);
  19.             fis.close();
  20.             return data;
  21.         }
  23.         @Override
  24.         protected Class<?> findClass(String name) throws ClassNotFoundException{ 
  25.             try { 
  26.                 byte[] data = loadByte(name);
  27.                 // defineClass将一个字节数组转为Class对象，
  28.                 // 这个字节数组是class文件读取后最终的字节数组。
  29.                 return defineClass(name, data,0, data.length);
  30.             }catch (Exception e){ 
  31.                 e.printStackTrace();
  32.                 throw new ClassNotFoundException();
  33.             }
  34.         }
  36.         /** * 重写类加载方法，实现自己的加载逻辑，不委派给双亲加载 * @param name * @param resolve * @return */
  37.         @Override
  38.         protected Class<?> loadClass(String name, boolean resolve)
  39.                 throws ClassNotFoundException{ 
  40.             synchronized (getClassLoadingLock(name)){ 
  41.                 // First, check if the class has already been loaded
  42.                 Class<?> c = findLoadedClass(name);
  44.                 if(c == null){ 
  45.                     long t1 = System.nanoTime();
  47.                     //非自定义的类还是走双亲委派加载
  48.                     if (!name.startsWith("com.tom"))
  49.                     { 
  50.                         c = this.getParent().loadClass(name);
  51.                     }else{ 
  52.                         c = findClass(name);
  53.                     }
  55.                     // this is the defining class loader;record the stats
  56.                     sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
  57.                     sun.misc.PerfCounter.getFindClasses().increment();
  58.                 }// if c == null
  59.                 if(resolve){ 
  60.                     resolveClass(c);
  61.                 }
  62.                 return c;
  63.             }
  64.         }
  66.     }// MyClassLoader
  68.     public static void main(String args[]) throws Exception{ 
  69.         // 初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器
  70.         // 的父加载器设置为应用程序类加载器AppClassLoader
  71.         MyClassLoader classLoader = new MyClassLoader("D:/111");
  72.         // java.lang.SecurityException: Prohibited package name: java.lang 限制包名,
  73.         // 不能自定义这个包名,与java类库冲突,安全管理器不通过
  74.         // Class clazz = classLoader.loadClass("java.lang.String");
  75.         // 但是换个包名就可以
  76.         Class clazz = classLoader.loadClass("com.tom.String");
  77.         Object obj = clazz.newInstance();
  78.         Method method = clazz.getDeclaredMethod("sout",null);
  79.         method.invoke(obj,null);
  80.         System.out.println(clazz.getClassLoader());
  83.         MyClassLoader classLoader1 = new MyClassLoader("D:/111");
  84.         Class clazz1 = classLoader1.loadClass("com.tom.String");
  85.         Object obj1 = clazz1.newInstance();
  86.         Method method1 = clazz1.getDeclaredMethod("sout",null);
  87.         method1.invoke(obj1,null);
  88.         System.out.println(clazz1.getClassLoader());
  89.     }
  90. }

在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，301人围观）

还没有评论，来说两句吧...

相关阅读

    相关 双亲委派机制

    什么是双亲委派机制? JVM加载字节码文件是按需加载，只有用到该类时才会加载字节码文件到内存中生成Class的对象，加载字节码文件采用的是双亲委派机制。 工作原理

    绝地灬酷狼绝地灬酷狼/ 0 赞/ 202 阅读

    相关 双亲委派机制

    Java虚拟机对Class文件采用的是按需加载的方式，也就是说当需要使用该类时，才会加载该类的对象到内存当中生成class对象。而且加载某个类的class文件时，Java虚拟机

    川长思鸟来川长思鸟来/ 0 赞/ 120 阅读

    相关 双亲委派机制

    JVM提供了三种类加载器，分别为启动类加载器(Bootstrap Classloader)、扩展类加载器(Extention Classloader)和应用程序类加载器(App

    末蓝、末蓝、/ 0 赞/ 363 阅读

    相关 双亲委派机制

    > 双亲委派机制 > JVM类加载器是有亲子层级结构的，如下图 ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shado

    清疚清疚/ 0 赞/ 302 阅读

    相关 双亲委派机制总结

    预定义类加载器和双亲委派机制 1. JVM预定义的三种类型类加载器： 启动（Bootstrap）类加载器：是用本地代码实现的类装入器，它负责将

    怼烎@怼烎@/ 0 赞/ 307 阅读

    相关 双亲委派机制

    ![这里写图片描述][70] 上图中展示的类加载器之间的这种层次关系，称为类加载器的双亲委派模型。双亲委派模型除了顶层的启动类加载器之外，其余的类加载器都应当有自己的父类加

    水深无声水深无声/ 0 赞/ 393 阅读

    相关 双亲委派机制

    一 点睛 Java虚拟机对class文件采用的是按需加载的方式，也就是说当需要使用该类时才会将它的class文件加载到内存生成class对象。而且加载某个类的class文

    小灰灰小灰灰/ 0 赞/ 594 阅读