java中的类加载与双亲委派机制

已于 2022-08-19 23:51:15 修改
阅读量247 收藏
点赞数
文章标签： java jvm 开发语言
于 2022-08-14 19:45:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a141210104/article/details/126335344
版权

类加载是什么

把磁盘中的java文件加载到内存中的过程叫做类加载

当我们用java命令运行某个类的main函数启动程序时，首先需要通过类加载器把主类加载到JVM. 有如下 User 类

package dc.dccmmtop;
public Class User {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

运行 java dc.dccmmtop.User 时， 先要找到 User.Class 文件，查找全路径就是 Class_PATH + {{package name}}，对于User类来说，就是 {$Class_APTH}/dc/dccmmtop.User.Class

假如 User.java 在F:\code, 并且不在Class_PATH 下，可以通过 java -Classpath "F:\code" 临时指定。

加载类之后还有后续的步骤:

  1. 验证
  2. 准备
  3. 解析
  4. 初始化
  5. 使用
  6. 卸载

这篇文章主要来讲讲类加载

类加载器

不了解类加载机制的，可能就认为，只需找到java文件所在的磁盘位置，然后进行一次读文件的操作不就完成了加载嘛，其实远非如此。

总有一个加载类的工具，这个工具叫做类加载器，在java代码中可以通过如下方式获取当前类的类加载器是什么

package dccmmtop;  
  
public Class User {  
    public static void main(String[] args) {  
        System.out.println("hello");  
        System.out.println(User.Class.getClassLoader()); 
    }  
}

在这里插入图片描述

如图可以看到类加载器的名字叫做 AppClassLoader

我们全局搜索一下这个类，会发现在 sun.misc.Launcher.java 文件中找到。

那么这个AppClassLoader 本身也是一个 java 文件，它又是什么时候被加载并初始化的呢？

我们滚动到文件顶部，看到 Launcher 类的构造方法部分：
在这里插入图片描述
标记1 和标记2 实现了一个单例模式，在5 处获取到了 AppClassLoader 实例。也就是说在某一个地方通过调用 Launcher 类中的 getLauncher() 方法，会得到 AppClassLoader 实例， 那么 getLauncher() 方法又是在哪里调用的呢？追踪到这里已经无法在java代码中找到上一步了，其实这个方法是jvm (c++实现)调用的，如下图:
在这里插入图片描述

以上就是类加载的主要步骤了。下面看一下双亲委派机制

双亲委派机制

我们继续看AppClassLoader 实例化的过程：

在这里插入图片描述

在5处，实例化了一个AppClassLoader的对象，同时传进去了一个参数 var1, 这个 var1 是另外一个类加载器ExtClassLoader , 我们在进入 getAppClassLoader 方法看一看是怎么实现的：

先看一下 几个ClassLoad的继承关系：

在这里插入图片描述

在这里插入图片描述

有上面的继承关系图可以看出来，AppClassLoader 和 ExtClassLoader 都是从 ClassLoader 继承来的。

在 Launcher() 中可知，调用 AppClassLoader.getAppClassLoader() 方法时， 把 ExtClassLoader 的实例作为参数传递进来，最终到4这一步，作为 var2 参数，调用父类的构造方法，继续追踪父类的构造方法直到 ClassLoader :
在这里插入图片描述

在 ClassLoader 构造方法中，维护了一个 parent 变量，到此我们知道了 AppClassLoader 中 parent 变量保存的是 ExtClassLoader的实例, 如下图表示

在这里插入图片描述

继续看Launcher 构造方法：
在这里插入图片描述

loadClass() 方法将 Class 文件加载到jvm中，我们跟踪一下这个方法，会发现最后会调到 根类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;  
    }  
}

上面代码块中的弟6行，findLoadedClass() , 先从已加载到的类集合中查找有没有这个类，如果有的话，直接返回，没有再进行下一步, findLoadedClass 方法源码如下
在这里插入图片描述

到 native finnal Class<?> findLoadedClass0(String name); 这里已经无法在向后追踪了，看到 naive ,要明白 使用native关键字说明这个方法是原生函数，也就是这个方法是用C/C++语言实现的，并且被编译成了DLL，由java去调用.

此时 User.Class 是第一次加载，AppClassLoader 中肯定无法在已加载的集合中找到，所以继续向下走到第 10，11 行. 上面已经分析过，AppClassLoader 中的 parent 是 ExtClassLoader , 所以在11行由 ExtClassLoader 的实例执行 laodClass 方法。 ExtClassLoader 没有覆写根类ClassLoader 的loaderClass 方法，所以也会到这里，只不过 ExtClassLoader 的 parent 是 NUll， 会走到13行，调用findBootstrapClassOrNull() 方法，再看一下这个方法的实现:

在这里插入图片描述

会发现这个方法也是C++实现的，虽然我们无法看到源码，但是根据注释可以知道，这个是保存了启动类加载器加载过的类。

到此为止，我们已经见识过3中不同的类加载器了：

  • AppClassLoader
  • ExtClassLoader
  • BootStrapClassLoader

我们先不管这个后面两个类加载器是什么， 假定他们也找不到 User.Class. 继续向下看：

执行到第21行findClas()这里，再看源码
在这里插入图片描述

在A-2 这一步，ucp 其实保存的就是当前 ClassLoader 的类加载路径，就不再展开。要记住此时的 ClassLoader 是 ExtClassLoader, 假如仍然找不到User.Class 会执行到 A-3.然后返回到 loadClass 方法中， 此时 c 是空，继续执行到33行，返回到 AppClassLoader 调用 parent.getAppClassLoader 处，在 AppClassLoader 实例的范围下继续向后执行，然后再继续调用 findClass 方法，如果在AppClassLoader的类加载路径中找到User.Class 文件，就会 执行 defindClass(name,res) 方法去加载类文件了。

整个过程用文字描述起来比较复杂，来张图就很清楚了，为什么叫做双亲委派：
在这里插入图片描述

把 loadedClassList 集合称作缓存

  1. 先在 AppClassLoader 中缓存中找，如果找不到向 ExtClassLoader 找，如果能找到，直接返回
  2. 在 ExtClassLoader 中缓存找，如果找不到向 BootStrapClassLoader 找，如果能找到，直接返回
  3. 在 BootStrapClassLoader 找，如果找不到， 在 ExtClassLoader 类路径集合中找，
  4. 如果在 ExtClassLoader 类路径集合找不到，在 AppClassLoader 类路径集合找
  5. 如果在 AppClassLoader 类路径集合中能找到，加载该类，并放入缓存。找不到则报错

双亲指的是 ExtClassLoader 和 BootStrapClassLoader， AppClassLoader 先不加载，而是向上让其“父”加载，父加载不到时，自己再加载。这里的父不是父类，而是调用层级的关系。

是时候介绍一下 这三个类加载器

BootStrapClassLoader

引导类加载器

负责加载支撑JVM运行的位于JRE的lib目录下的核心类库，比如 rt.jar、charsets.jar等

ExtClassLoader

扩展类加载器

负责加载支撑JVM运行的位于JRE的lib目录下的ext扩展目录中的JAR 类包

AppClassLoader

应用程序加载器

负责加载ClassPath路径下的类包，主要就是加载你自己写的那些类

我们可以写代码验证一下:

package dccmmtop;  
  
import sun.misc.Launcher;  
  
import java.net.URL;  
  
public Class User {  
    public static void main(String[] args) {  
        System.out.println(String.Class.getClassLoader()); // null  
        System.out.println(com.sun.crypto.provider.DESKeyFactory.Class.getClassLoader().getClass().getName()); //sun.misc.Launcher$ExtClassLoader  
        System.out.println(User.Class.getClassLoader().getClass().getName()); // sun.misc.Launcher$AppClassLoader  
        System.out.println();  
        System.out.println("bootstrapLoader加载以下文件：");  
        URL[] urls = Launcher.getBootstrapClassPath().getURLs();  
        for (int i = 0; i < urls.length; i++) {  
            System.out.println(urls[i]);  
        }  
        System.out.println();  
        System.out.println("extClassloader加载以下文件：");  
        System.out.println(System.getProperty("java.ext.dirs"));  
        System.out.println();  
        System.out.println("appClassLoader加载以下文件：");  
        System.out.println(System.getProperty("java.Class.path"));  
    }  
}

输入如下:

null // 因为调用了 c++ 实现。无法获取到java对象
sun.misc.Launcher$ExtClassLoader
sun.misc.Launcher$AppClassLoader

the bootstrapLoader : null
the extClassloader : sun.misc.Launcher$ExtClassLoader@77459877
the appClassLoader : sun.misc.Launcher$AppClassLoader@18b4aac2

bootstrapLoader加载以下文件：
file:/C:/Program%20Files/Java/jdk1.8.0_261/jre/lib/resources.jar
file:/C:/Program%20Files/Java/jdk1.8.0_261/jre/lib/rt.jar
file:/C:/Program%20Files/Java/jdk1.8.0_261/jre/lib/sunrsasign.jar
file:/C:/Program%20Files/Java/jdk1.8.0_261/jre/lib/jsse.jar
file:/C:/Program%20Files/Java/jdk1.8.0_261/jre/lib/jce.jar
file:/C:/Program%20Files/Java/jdk1.8.0_261/jre/lib/charsets.jar
file:/C:/Program%20Files/Java/jdk1.8.0_261/jre/lib/jfr.jar
file:/C:/Program%20Files/Java/jdk1.8.0_261/jre/Classes

extClassloader加载以下文件：
C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext;C:\WINDOWS\Sun\Java\lib\ext

appClassLoader加载以下文件：
C:\Program Files\Java\jdk1.8.0_261\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_261\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_261\jre\lib\ext\jaccess.jar;...省略

为什么使用双亲委派机制

  1. 沙箱安全机制：
    自己写的java.lang.String.Class类不会被加载，这样便可以防止核心 API库被随意篡改

  2. 避免类的重复加载：当父亲已经加载了该类时，就没有必要子ClassLoader再加载一 次，保证被加载类的唯一性

全盘负责委托机制

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

自定义类加载器

从上述源码的描述可知，类加载器的核心方法是 findClass , 和 defineClass 。

defindClass 将class文件从磁盘加载文件到内存，defineClass 开始解析class文件:
在这里插入图片描述

所以自定义类加载器只需继承 ClassLoader，然后从写 findClass 文件就行了：

目录如下:
在这里插入图片描述

App.java:

import java.io.FileInputStream;
import java.lang.reflect.Method;

public class App {
    static class MyClassLoader extends ClassLoader {
        private String classPath;

        public MyClassLoader(String classPath) {
            this.classPath = classPath;
        }

        // 从磁盘加载文件
        private byte[] loadByte(String name) throws Exception {
            name = name.replaceAll("\\.", "/");
            FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
            int len = fis.available();
            byte[] data = new byte[len];
            fis.read(data);
            fis.close();
            return data;
        }

        // 重写
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data = loadByte(name);
                // defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节 数组。
                return defieClass(name, data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }
    }

    public static void main(String args[]) throws Exception {
        // 初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器的父加载 器设置为应用程序类加载器AppClassLoader
        MyClassLoader classLoader = new MyClassLoader("D:/dc_code/java"); // D盘创建
        // 创建 io/dc 几级目录，将User类的复制类User.class丢入该目录
        Class clazz = classLoader.loadClass("io.dc.User");
        Object obj = clazz.newInstance();
        // 使用反射调用 User 类的 sout 方法
        Method method = clazz.getDeclaredMethod("sout", null);
        method.invoke(obj, null);
        System.out.println(clazz.getClassLoader().getClass().getName());
    }
}

打破双亲委派机制

经过上面的源码分析发现，主要是 ClassLoader 类中的laodClass 方法来实现的双亲委派机制，自己不加载而是先让其父加载。

所以直接复写 loadClass 方法即可，不再指定父级加载，当前类直接加载，如下:

import java.io.FileInputStream;
import java.lang.reflect.Method;

public class App {
    static class MyClassLoader extends ClassLoader {
        private String classPath;

        public MyClassLoader(String classPath) {
            this.classPath = classPath;
        }

        // 从磁盘加载文件
        private byte[] loadByte(String name) throws Exception {
            name = name.replaceAll("\\.", "/");
            FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
            int len = fis.available();
            byte[] data = new byte[len];
            fis.read(data);
            fis.close();
            return data;
        }

        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data = loadByte(name);
                // defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节 数组。
                return defineClass(name, data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }

        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) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    if (name.startsWith("io.dc")) {
                        // 直接查找, 限定包名
                        c = findClass(name);
                    } else {
                        // 其他包中的类还是使用双亲委派机制
                        // 否则会报找不到 Object 类
                        c = this.getParent().loadClass(name);
                    }
                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
                if (resolve) {
                    resolveClass(c);
                }
                return c;
            }
        }
    }

    public static void main(String args[]) throws Exception {
        // 初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器的父加载 器设置为应用程序类加载器AppClassLoader
        MyClassLoader classLoader = new MyClassLoader("D:/dc_code/java"); // D盘创建
        // 创建 io/dc 几级目录，将User类的复制类User.class丢入该目录
        Class clazz = classLoader.loadClass("io.dc.User");
        Object obj = clazz.newInstance();
        // 使用反射调用 User 类的 sout 方法
        Method method = clazz.getDeclaredMethod("sout", null);
        method.invoke(obj, null);
        System.out.println(clazz.getClassLoader().getClass().getName());
    }
}

Tomcat 中的类加载方式

为什么Tomcat 需要打破双亲委派机制

  1. tomcat 是一个web容器。可以同时运行多个web服务，每个服务可能会依赖同一个类的不同版本，例如 服务A 依赖 Spring 2.1.1 服务B 依赖 Spring 2.2.2 ,服务A B 所依赖的包名 + 类名肯定有一样的。但是我们知道在双亲委派机制中不能同时存在报名和类名一样的class文件。此时就需要打破
  2. web容器也有自己依赖的类库，不能与应用程序的类库混淆。基于安全考虑，应该让容器的 类库和程序的类库隔离开来。
  3. web容器要支持jsp的修改，我们知道，jsp 文件最终也是要编译成class文件才能在虚拟机中 运行，但程序运行后修改jsp已经是司空见惯的事情， web容器需要支持 jsp 修改后不用重启。如果使用双亲委派机制，同一个类加载过一次就不会再次加载了。很显然不能支持热加载功能。tomcat 把每一个jsp class 文件都用一个单独的加载器去加载。如果检测到 jsp 文件发生变动，直接将现有的 jsp 对应的类加载器卸载掉，重新生成一个新的加载器去加载。

模仿tomcat 实现多版本共存

用一个简单的demo来实现 tomcat 多版本共存功能:

有两个报名和类名一样的 User 类:

在这里插入图片描述

java1 -> User.java :

package io.dc;
public class User{
    public void sout (){
        System.out.println("user");
    }
    public static void main (String[] args){
        System.out.println("user");

    }

}

java2 -> User.java

package io.dc;

public class User {
    public void sout() {
        System.out.println("user1");
    }

    public static void main(String[] args) {
        System.out.println("user1");

    }

}

App.java

package io.dc;

import java.io.FileInputStream;
import java.lang.reflect.Method;

public class App {
    static class MyClassLoader extends ClassLoader {
        private String classPath;

        public MyClassLoader(String classPath) {
            this.classPath = classPath;
        }

        // 从磁盘加载文件
        private byte[] loadByte(String name) throws Exception {
            name = name.replaceAll("\\.", "/");
            FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");
            int len = fis.available();
            byte[] data = new byte[len];
            fis.read(data);
            fis.close();
            return data;
        }

        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data = loadByte(name);
                // defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节 数组。
                return defineClass(name, data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }

        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) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    if (name.startsWith("io.dc")) {
                        // 直接查找, 限定包名
                        c = findClass(name);
                    } else {
                        // 其他包中的类还是使用双亲委派机制
                        // 否则会报找不到 Object 类
                        c = this.getParent().loadClass(name);
                    }
                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
                if (resolve) {
                    resolveClass(c);
                }
                return c;
            }
        }
    }

    public static void main(String args[]) throws Exception {
        // 初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器的父加载 器设置为应用程序类加载器AppClassLoader
        MyClassLoader classLoader = new MyClassLoader("F:/code/java1"); // D盘创建
        // 创建 io/dc 几级目录，将User类的复制类User.class丢入该目录
        Class clazz = classLoader.loadClass("io.dc.User");
        Object obj = clazz.newInstance();
        // 使用反射调用 User 类的 sout 方法
        Method method = clazz.getDeclaredMethod("sout", null);
        method.invoke(obj, null);

        System.out.println(clazz.getClassLoader().getClass().getName());

        // 使用新的加载器加载另外一个 User.class
        MyClassLoader classLoader1 = new MyClassLoader("F:/code/java2"); // D盘创建
        // 创建 io/dc 几级目录，将User类的复制类User.class丢入该目录
        Class clazz1 = classLoader1.loadClass("io.dc.User");
        Object obj1 = clazz1.newInstance();
        // 使用反射调用 User 类的 sout 方法
        Method method1 = clazz1.getDeclaredMethod("sout", null);
        method1.invoke(obj1, null);
        System.out.println(clazz1.getClassLoader().getClass().getName());
    }
}

结果：
在这里插入图片描述

所以，同一个JVM内，两个相同包名和类名的类对象可以共存，因为他们的类加载器可以不一 样，所以看两个类对象是否是同一个，除了看类的包名和类名是否都相同之外，还需要他们的类 加载器也是同一个才能认为他们是同一个。

超的博客
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java虚拟机类加载机制及双亲委派模型
05-07
Java虚拟机类加载机制及双亲委派模型
双亲委派类加载机制
Kera_s的博客
04-01 911
双亲委派机制是Java中的一个重要特性，它通过一层层向上委派的方式保证了类的加载顺序和安全性。通过自定义类加载器，我们可以打破双亲委派机制，实现自己的类加载策略，但是需要注意类的安全性和稳定性。在实际应用中，我们应该谨慎使用自定义类加载器，避免不必要的安全问题。
类加载器 双亲委派
qq_42042621的博客
05-02 99
防止核心API库被随意篡改。比如有一个要加载java.lang.Integer类的请求，通过双亲委派进制加载传递到启动类加载器，在在核心Java API发现这个名字的类，发现该类已被加载，并不会重新加载传递的过来的java.lang.Integer，而直接返回已加载过的Integer.class，可以防止核心API被随意篡改。通俗的讲就是在某个特定的类加载器接到加载类请求时，先寄托给父加载器加载，依次递归，如果父加载器可以加载时则成功返回，如果不可以加载就自己去加载。
【JVM】Java类加载器 和 双亲委派机制
最新发布
qq_43325216的博客
03-29 812
当一个类加载器需要去加载类时，会 首先委派给其父类加载器进行加载，如果父类加载器无法加载，才由该类加载器自己去加载但是如果只为了定义自定义加载器，建议重写findClass方法，这样不会破坏双亲委派机制。@Override// 核心类库还是交给双亲委派机制进行加载// 通过类的全限定名，找到字节码文件，并转为byte数组 不写了// 类的加载就是由defineClass这个底层方法实现的。
【Java】深入了解双亲委派机制（常说的类加载机制）
weixin_45716968的博客
08-29 3630
ava虚拟机（JVM）的类加载机制是Java应用中不可或缺的一部分。本文将详细介绍JVM的双亲委派机制，并阐述各关键点。双亲委派机制（Parent-Delegate Model）是Java类加载器中采用的一种类加载策略。该机制的核心思想是：如果一个类加载器收到了类加载请求，默认先将该请求委托给其父类加载器处理。只有当父级加载器无法加载该类时，才会尝试自行加载。本文介绍了JVM的双亲委派机制，包括概念、类加载器层级关系、双亲委派流程及实例分析等方面的内容。
【JVM】类加载系统与双亲委派机制
Chovy_pyc的博客
02-23 296
Java类加载系统以及双亲委派机制
类加载器-双亲委派机制
weixin_40461030的博客
07-03 2718
双亲委派机制
java类加载机制.xmind
06-09
该文件是JVM中关于类加载机制的知识整理的思维导图，包括类加载机制概述、类加载的生命周期、加载时机、加载过程、类加载、类的初始化和实例化等几个大...包括双亲委派机制，违背双亲委派模型，开发自己的类加载器等等
Java类加载机制.pdf
12-15
java的类加载机制，类加载顺序，类加载的体系结构，类加载过程，双亲委派模型及机制等相关内容。做架构师或者高级开发，类加载是必须要掌握的内容。
什么是类加载器和什么是双亲委派机制.xmind
09-12
什么是类加载器和什么是双亲委派机制
【JVM】类加载器与双亲委派模型
12-21
有关类加载的全过程，可以先参考我的另外一篇文章类的奇幻漂流——类加载机制探秘 类加载器的类型 类加载器有以下种类： 启动类加载器（Bootstrap ClassLoader） 扩展类加载器（Extension ClassLoader） 应用类...
Java类加载机制&双亲委派机制
Gamble6
12-04 2596
类加载阶段分为加载、连接、初始化三个阶段，而加载阶段需要通过类的全限定名来获取定义了此类的二进制字节流。Java特意把这一步抽出来用类加载器来实现。把这一步骤抽离出来使得应用程序可以按需自定义类加载器。并且得益于类加载器，OSGI、热部署等领域才得以在JAVA中得到应用。 在Java中任意一个类都是由这个类本身和加载这个类的类加载器来确定这个类在JVM中的唯一性。也就是你用你A类加载器加载的com.aa.ClassA和你A类加载器加载的com.aa.ClassA它们是不同的，也就是用instanceo
类加载器和双亲委派机制
question_mark的博客
02-27 328
每个开发人员对java.lang.ClassNotFoundExcetpion这个异常肯定都不陌生,这个异常背后涉及到的是Java技术体系中的类加载机制. 本文简述了JVM三种预定义类加载器,即启动类加载器,扩展类加载器和系统类加载器,并介绍和分析它们之间的关系和类加载所采用的双亲委派机制,给出并分析了与Java类加载原来相关的若干问题. 版权声明： 本文作者：书呆子Rico 作者博客地址：ht...
关于类加载机制和双亲委派机制的一些思考 小结
BAStriver的博客
03-28 326
WebAppClassLoader 加载类的时候，故意打破了JVM 双亲委派机制，绕开了 AppClassLoader，直接先使用 ExtClassLoader 来加载类。既保证了基础类不会被同时加载，也保证了在同一个 Tomcat 下不同 web 之间的 class 是相互隔离的。
JVM类加载及双亲委派机制
yhh的博客
08-14 621
JVM类加载及双亲委派机制
关于Java类加载、双亲委派机制
hhxxttxs6的博客
04-20 136
此时并未将数据加载进内存，需要等验证阶段通过，才会在内存中为类数据分配空间。并且该class对象并未进行初始化，即没有执行构造函数。验证：连接阶段的第一步，保证class文件的字节流符合JVM规范，不会导致JVM出现安全问题。文件格式验证：如是否以魔数 0xCAFEBABE 开头、主、次版本号是否在当前虚拟机处理范围之内、常量合理性验证等。保证输入的字节流能正确地解析并存储于方法区之内，格式上符合描述一个 Java类型信息的要求。
类加载器详解（重点）之双亲委派
weixin_42491646的博客
04-18 679
类加载器详解（重点）之双亲委派
Java 类加载机制与双亲委派
.
11-09 210
Java 类加载机制与双亲委派
类加载器及双亲委派机制
weixin_48426115的博客
10-12 503
使用java语言编写，父类加载器为扩展类加载器，该类加载是程序中默认的类加载器，一般来说，java应用的类都是由它来完成加载。这个类加载使用C/C++语言实现的，嵌套在JVM内部，它用来加载Java的核心库（(JAVA_HOME/jre/lib/rt.jar、resources.jar或sun.boot.class.path路径下的内容），用于提供JVM自身需要的类，出于安全考虑，Boostrap启动类加载器只加载包名为java、javax、sun等开头的类。
java类加载双亲委派机制
05-13
Java类加载器采用双亲委派机制，这是Java安全模型的重要组成部分。这种机制保证Java核心API不会被随意篡改，同时也保证了Java程序的稳定性和安全性。 双亲委派机制的基本原则是：当一个类加载器接收到类加载请求时...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值