类加载器详解_人生

类加载器详解

创始人

2025-05-31 05:53:06

类与类加载器的关系类加载器用于实现类的加载动作，但它在java中起到的作用远远不仅于类加载阶段。对于任何一个类来说，都需要类本身和加载这个类的类加载器一同确立其在java JVM中的唯一性。通俗来讲：比较两个类是否相等，只有两个类是由同一个类加载器加载的前提下才有意义。否则，即使两个类来自同一个class文件，但是由于加载他们的类加载器不同，那这两个类就必不相等。
这里的“相等”，包括代表类的Class对象的equals()方法，isAssignableForm()方法和，isInstance()方法的返回结果。也包括instanceOf关键字对象所属关系判定等情况。如果没有注意到类加载器的影响，在某些情况下会产生迷惑人的结果。

类加载的过程

加载：将字节码文件通过IO流读取到JVM的方法区，并同时在堆中生成Class对像。

验证：校验字节码文件的正确性。

准备：为类的静态变量分配内存，并初始化为默认值；对于final static修饰的变量，在编译时就已经分配好内存了。

解析：将类中的符号引用转换为直接引用。

初始化：对类的静态变量初始化为指定的值，执行静态代码。

类加载器的分类
主要分为两类:
JVM内置的类加载器,有Bootstrap加载器、ExtClassLoader加载器和AppClassLoader加载器三种,分别负责加载不同目录下的.class文件
用户自定义的类加载器,负责的加载目录自己决定。

2.1 引导类加载器 Bootstrap
引导类加载器属于JVM的一部分，由C++代码实现。

引导类加载器负责加载\jre\lib路径下的核心类库，由于安全考虑只加载包名 java、javax、sun开头的类。

package classloader.bootstrap;

import sun.misc.Launcher;

import java.net.URL;

public class Demo01 {
public static void main(String[] args) {
//Bootstrap 引导类加载器
//打印为null,是因为Bootstrap是C++实现的。
ClassLoader classLoader = Object.class.getClassLoader();
System.out.println(classLoader);

    //查看引导类加载器会加载那些jar包URL[] urLs = Launcher.getBootstrapClassPath().getURLs();for (URL urL : urLs) {System.out.println(urL);}
}

}

2.2 扩展类加载器 ExtClassLoader
全类名:sum.misc.Launch$ExtClassLoader，Java语言实现。

扩展类加载器的父加载器是Bootstrap启动类加载器 (注:不是继承关系)

扩展类加载器负责加载\jre\lib\ext目录下的类库。

加载的jar包

获取扩展类加载器

注: JDK9是jdk.internal.loader.ClassLoaders$PlatformClassLoader类

2.3 系统类加载器 AppClassLoader
全类名: sun.misc.Launcher$AppClassLoader

系统类加载器的父加载器是ExtClassLoader扩展类加载器（注: 不是继承关系）。

系统类加载器负责加载 classpath环境变量所指定的类库，是用户自定义类的默认类加载器。

获取系统类加载器

注: JDK9是jdk.internal.loader.ClassLoaders$AppClassLoader类

2.4 三者之间的关系
AppClassLoader的父加载器是ExtClassLoader
ExtClassLoader的父加载器是Bootstrap
Bootstrap是根加载器

三者之间是没有继承关系的。

AppClassLoader和ExtClassLoader都实现了抽象类ClassLoader。

抽象类ClassLoader有一个字段parent, AppClassLoader和ExtClassLoader通过设置该字段引用,指定父加载器。（是组合关系）

AppClassLoader 的parent指向 ExtClassLoader
ExtClassLoader 的parent指向 null,(null的原因是因为Bootstrap是C++实现的,通过代码中逻辑判断来转向Bootstrap)

// The parent class loader for delegation
// Note: VM hardcoded the offset of this field, thus all new fields
// must be added after it.
private final ClassLoader parent;
1
2
3
4
5
6
7
8
9
10
11
2.5 自定义类加载器
自定义类加载器是为了加载在jvm三个加载器负责的目录范围之外的类

package com;

import java.io.*;

/**

@Date: 2022/5/2 10:09
@author: ZHX

@Description: 自定义类加载器
*/
public class MyClassLoader extends ClassLoader {

private String classPath;

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

//parent: 指定父加载器, AppClassLoader/ExtClassLoader/Bootstrap
public MyClassLoader(ClassLoader parent, String classPath) {
super(parent);
this.classPath = classPath;
}

@Override
protected Class findClass(String name) throws ClassNotFoundException {
//要求返回的是你要加载的字节码文件的Class对象.

 //这里都是我们说了算的。//步骤：//1. 从本地或网络某处读一个输入流到内存中 .//2. 将流内容字节数组 封装成Class对象 (直接调ClassLoader的defineClass方法，JVM会帮我们按照.class文件格式创建好的。)//1.//处理得到完整路径String path = this.classPath + name.replace(".", File.separator) + ".class";//2.读取到内存try (FileInputStream fis = new FileInputStream(path); ByteArrayOutputStream baos = new ByteArrayOutputStream()) {byte[] buffer = new byte[1024];int len = 0;while ((len = fis.read(buffer)) != -1) {//用ByteArrayOutputStream暂存一下。baos.write(buffer, 0, len);}byte[] allByte = baos.toByteArray();//将字节数组生成Class对象return super.defineClass(name, allByte, 0, allByte.length);} catch (IOException e) {throw new ClassNotFoundException(name + "加载失败");}

}

//测试下
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//使用自己的类加载器，加载D:\ + com.ali.Hello
MyClassLoader myClassLoader = new MyClassLoader(“d:\”); //
//加载全限定名类
Class clazz = myClassLoader.loadClass(“com.ali.Hello”);

 clazz.newInstance();System.out.println(clazz.getClassLoader()); //out: 使用的类加载器 MyClassLoader@481248

}
}

加载jar包的写法:

从jar包加载类:String path = “jar:file:\” + classPath + “!/” + name.replace(“.”, File.separator) + “.class”;
1
2.6 注：谁来准备类加载器呢?
AppClassLoader和ExtClassLoader是Launcher的静态内部类，在程序启动时JVM会创建Launcher对象，Launcher构造器会同时会创建扩展类加载器和应用类加载器。

Launcher类

双亲委派机制
双亲委派机制就是: 每个类加载器都很懒，加载类时都先让父加载器去尝试加载，父加载器加载不了时自己才去加载。

图片来源 : https://www.bilibili.com/video/BV16T4y1P79h?p=2

例如: 加载自定义类Demo.class的流程

首先使用AppClassLoader类加载器尝试加载，AppClassLoader加载器会先检查它的缓存，查看该类是否已经被加载，有则不加载，没有则向上交给ExtClassLoader加载器。
ExtClassLoader加载器同样会先检查它的缓存，查看该类是否已经被加载，有则不加载，没有则向上交给Bootstrap加载器。
Bootstrap加载器同样会先检查它的缓存，查看该类是否已经被加载。有则不加载，没有则尝试从它负责的目录中加载，
Bootstrap加载器加载失败(不在它负责的目录范围)则向下交给ExtClassLoader加载器。
ExtClassLoader加载器会从它负责的目录中尝试加载，加载失败则向下交给AppClassLoader加载器
AppClassLoader加载器从它负责的classpath尝试加载，加载完成。
双亲委派机制的好处:

避免类的重复加载：当父加载器已经加载该类时，就没有必要子加载器再加载一遍，保证被加载类的唯一性。

同时Java有沙箱安全机制：自定义类的包名以 java.开头被禁止，防止核心API被篡改，判断逻辑在defineClass方法中。

打破双亲委派机制

双亲委派机制的实现其实就是在loadClass方法中实现的。
直接调用findClass方法就可以跳过双亲委派机制,这样就可以直接加载,而不用向上委托了。
1
2
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//使用上面自定义的类加载器。
MyClassLoader myClassLoader1 = new MyClassLoader(“d:\”);

    //find方法调用，加载 全限定名类Class clazz1 = myClassLoader1.findClass("com.ali.Hello");System.out.println(clazz1.hashCode()); //out: 26508395System.out.println(clazz1.getClassLoader()); //out: 使用的类加载器 MyClassLoader@481248

}

//如果要想一个类加载两次，就需要创建两个类加载器。（因为判断缓存中该字节码文件是否已经已经被加载是在defineClass方法中,而该方法为final我们没法改写.）
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
//使用上面自定义的类加载器。
MyClassLoader myClassLoader1 = new MyClassLoader(“d:\”);
MyClassLoader myClassLoader2 = new MyClassLoader(“d:\”);

//加载 全限定名类
Class clazz1 = myClassLoader1.findClass("com.ali.Hello");
Class clazz2 = myClassLoader2.findClass("com.ali.Hello");System.out.println(clazz1.hashCode());//out: 22913620
System.out.println(clazz2.hashCode());//out: 29768086System.out.println(clazz1.getClassLoader()); //out: 使用的类加载器 MyClassLoader@481248
System.out.println(clazz2.getClassLoader()); //out: 使用的类加载器 MyClassLoader@1947c6b

}

ClassLoader抽象类
所有的类加载器(除了Bootstrap)都要继承ClassLoader抽象类。

主要方法

方法名作用
public Class loadClass(String name) 双亲委派机制的实现 protected Class findClass(String name) 读取字节码文件到内存并调用defindClass方法生成Class对象
protected final Class defineClass(String name, byte[] b, int off, int len) 先判断是否加载过，然后将字节数组解析成Class对象 protected final void resolveClass(Class c) 连接指定的类
loadClass()方法源码

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 statssun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);sun.misc.PerfCounter.getFindClasses().increment();}}if (resolve) {resolveClass(c);}return c;
}

}

URLClassLoader类
java.net.URLClassLoader继承了ClassLoader类. 拓展了功能，能够从网络或本地加载类。默认的父加载器是AppClassLoader系统类加载器。

加载磁盘上的类

package classloader.urlclassloader;

/**

@Date: 2022/4/30 9:35
@author: ZHX
@Description:
*/
public class LoadLocal {

public LoadLocal(){
System.out.println(“本地的字节码文件”);
}

}

package classloader.urlclassloader;

import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;

/**

@Date: 2022/4/30 0:51
@author: ZHX

@Description:
*/
public class Demo {

public static void main(String[] args) throws MalformedURLException, ClassNotFoundException, InstantiationException, IllegalAccessException {

 File file = new File("D:\\Project\\java-advence\\day16-classloader\\src\\main\\java\\");URL url = file.toURI().toURL();URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{url});Class clazz = urlClassLoader.loadClass("classloader.urlclassloader.LoadLocal");clazz.newInstance(); //out: 本地的字节码文件

}
}

加载网络上的类

package classloader.urlclassloader;

/**

@Date: 2022/4/30 9:35
@author: ZHX
@Description:
*/
public class LoadURL {

public LoadURL(){
System.out.println(“网络上的字节码文件”);
}
}

package classloader.urlclassloader;

import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;

/**

@Date: 2022/4/30 0:51
@author: ZHX
@Description:
*/
public class Demo {

public static void main(String[] args) throws MalformedURLException, ClassNotFoundException, InstantiationException, IllegalAccessException {
//放到了tomcat服务器上。
URL url = new URL(“http://localhost/”);
```
 URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{url});Class clazz = urlClassLoader.loadClass("classloader.urlclassloader.LoadURL");clazz.newInstance(); //out: 网络上的字节码文件
```
}

二、线程上下文类加载器
1、线程上下文类加载器，打破双亲委派加载链模式（不用父类加载器先加载，可以按照自己的想法实现）
2、线程上下文类加载器，默认是app类加载器，也可以设置改变

三、tomcat

四、osgi （面向Java的动态模块系统）(通过类隔离实现逻辑上的模块化)
l OSGI的作用

在java中，OSGI是一个实现java模块化互访的平台，我们可以理解为是一个更高级的JVM。它提供了逻辑上的模块化控制。

l OSGI对模块的定义

在OSGI中，模块称之为bundle，一个bundle在物理上而言就是一个jar包。Jar包中有一个描述jar包的信息文件，位于jar内部的META-INF目录下的MANIFEST.MF文件。OSGI通过MANIFEST这个文件获取模块的定义信息，比如模块间的互访信息，模块的版本信息等。Note：对于MANIFEST.MF文件的操作，由于这个文件有很多使用约束，比如一行不能超过72个字符，所以一般都是通过IDE工具对它进行编辑

bundle是OSGi的部署(和模块)单元。
在OSGi运行时，bundle具有如下三种状态：installed，resolved，active。
在Spring中最主要的单元模块是应用程序上下文（application context），在应用程序上下文里包括了一些bean（被Spring的应用程序上下文所管理的对象）。在OSGi bundle和Spring应用程序上下文之间有很自然的紧密联系。
使用Spring Dynamic Modules（Spring DM），一个active的bundle可以包含一个Spring 应用程序上下文，它负责在bundle里实例化、配置、组装和装饰对象（bean）。这些bean即可作为OSGi服务输出而提供给其他bundle，也能透明地注入其他OSGi服务的引用。

在这里插入图片描述

osgi最明显的缺陷

bundle尽管可以为隔离的服务建立独立生命周期管理的热部署方式，以及明确的服务导出和导入依赖能力，但是其最终基于jvm，无法对bundle对应的服务实现计算资源的隔离，一个服务的故障依然会导致整个jvm crush,这使得在一个运行时的osgi上部署模块级服务只获得了模块部署和启停隔离，服务明确依赖的好处，但是没办法实现计算节点的线性扩展，在当前分布式，微服务，网络计算的趋势下，使得osgi只适合构建单一服务节点的内部应用，但是其分离的bundle的部署负担对于微服务架构来说，有点用大炮打蚊子的臭味。

osgi与tomcat类加载的区别：

tomcat中各个应用是隔离的
osgi各个模块是隔离的，但是模块之间可以通过导出、导入方式实现通信，代码共享
需要注意的是被导入的代码还是要使用原来的类加载器加载

五、sofaark
作为开源界早负盛名的动态模块系统，基于 OSGi 规范的 Equinox、Felix 等同样具备类隔离能力，然而他们更多强调的是一种编程模型，面向模块化开发，有一整套模块生命周期的管理，定义模块通信机制以及复杂的类加载模型。作为专注于解决依赖冲突的隔离框架，SOFAArk 专注于类隔离，简化了类加载模型，因此显得更加轻量。其次在 OSGi 规范中，所有的模块定义成 Bundle 形式，作为应用开发者，他需要了解 OSGi 背后的工作原理，对开发者要求比较高。在 SOFAArk 中，定义了两层模块类型，Ark Plugin 和 Ark Biz，应用开发者只需要添加隔离的 Ark Plugin 依赖，底层的类加载模型对应用开发者俩说是透明的，基本不会带来额外的学习成本。

六、

词库加载错误:未能找到文件“E:\highferrum_mysql\Configuration\Dict_Stopwords.txt”。

上一篇：聊一聊系统重构

下一篇：【漏洞复现】WebLogic Server 远程代码执行漏洞(CVE-2023-21839/CNVD-2023-04389)

类加载器详解

相关内容

热门资讯