类加载

最新推荐文章于 2025-09-12 18:08:49 发布
转载 最新推荐文章于 2025-09-12 18:08:49 发布 · 86 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://juejin.im/post/5a3717736fb9a0450f220615
文章标签：

#java #移动开发 #c/c++

###前言

类加载机制是做热修复以及插件化的很重要的理论基础。

###Java中的ClassLoader回顾

如下图所示：

###ClassLoader的特性

ClassLoader的主要特性是双亲委托机制，即加载一个类的时候，先判断已经存在的类是否被加载过，如果没有，先去委托父亲去加载。如果父亲都没有加载成功的话，那么最终由自己加载。最终这个类最终没有合适的CLassLoader加载，那么就会抛出异常，相关的ClassLoader源码如下：

protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
        // 先判断这个类是否已经被加载过
        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
            }
        }
        return c;
}
复制代码

其中CLassLoader的findClass方法是空实现，需要自己继承然后实现：

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

这种双亲委托机制有两种好处：

  1. 实现类加载的共享功能，提升类加载的效率。
  2. 实现类加载的隔离功能，提升系统的安全性。比如，通过这种方式，系统的String类只能由系统的ClassLoader加载。

###Android中的ClassLoader整体概述

Android中的ClassLoader的整体架构继承关系如下：

其中，ClassLoader分别为：

  • BootClassLoader：与Java中的Bootstrap ClassLoader类似，主要加载Android Framework中的字节码文件。
  • PathClassLoader：与Java中的App ClassLoader类似，主要加载已经安装到系统中的APK中的字节码文件。
  • DexClassLoader：与Java中的Customer ClassLoader类似，主要加载自定义路径下的APK或者JAR中的字节码文件（Android中主要是指dex文件，即classes.dex）。

其中，BaseDexClassLoader是PathClassLoader以及DexClassLoader的父类，PathClassLoader以及DexClassLoader的逻辑都在这个父类中实现。

BootClassLoader和PathClassLoader是一个普通的APP所需要的（定制ROM另外说），最基本的ClassLoader，通过下面的代码可以证明：

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    ClassLoader cl = this.getClassLoader();
    Log.e(TAG, "onCreate: " + cl);
    while (cl.getParent() != null) {
        cl = cl.getParent();
        Log.e(TAG, "onCreate: " + cl);
    }

}
复制代码

打印结果只有BootClassLoader和PathClassLoader：

09-06 14:29:01.571 3165-3165/com.nan.loadapkdemo E/MainActivity: onCreate: dalvik.system.PathClassLoader[DexPathList[[zip file "/data/app/com.nan.loadapkdemo-1/base.apk", zip file "/data/app/com.nan.loadapkdemo-1/split_lib_dependencies_apk.apk", zip file "/data/app/com.nan.loadapkdemo-1/split_lib_slice_0_apk.apk", zip file "/data/app/com.nan.loadapkdemo-1/split_lib_slice_1_apk.apk", zip file "/data/app/com.nan.loadapkdemo-1/split_lib_slice_2_apk.apk", zip file "/data/app/com.nan.loadapkdemo-1/split_lib_slice_3_apk.apk", zip file "/data/app/com.nan.loadapkdemo-1/split_lib_slice_4_apk.apk", zip file "/data/app/com.nan.loadapkdemo-1/split_lib_slice_5_apk.apk", zip file "/data/app/com.nan.loadapkdemo-1/split_lib_slice_6_apk.apk", zip file "/data/app/com.nan.loadapkdemo-1/split_lib_slice_7_apk.apk", zip file "/data/app/com.nan.loadapkdemo-1/split_lib_slice_8_apk.apk", zip file "/data/app/com.nan.loadapkdemo-1/split_lib_slice_9_apk.apk"],nativeLibraryDirectories=[/data/app/com.nan.loadapkdemo-1/lib/x86, /system/lib, /vendor/lib]]]
09-06 14:29:01.571 3165-3165/com.nan.loadapkdemo E/MainActivity: onCreate: java.lang.BootClassLoader@b173b34
复制代码

###ClassLoader源码分析

先来给出源码的位置：

  • BootClassLoader在ClassLoader.java文件的后面（直接通过Android Studio查看源码即可）
  • BaseDexClassLoader地址：http://androidxref.com/7.1.1_r6/xref/libcore/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java
  • PathClassLoader地址：http://androidxref.com/7.1.1_r6/xref/libcore/dalvik/src/main/java/dalvik/system/PathClassLoader.java
  • DexClassLoader地址：http://androidxref.com/7.1.1_r6/xref/libcore/dalvik/src/main/java/dalvik/system/DexClassLoader.java

先来看看BootClassLoader的实现：

class BootClassLoader extends ClassLoader {

    private static BootClassLoader instance;

    @FindBugsSuppressWarnings("DP_CREATE_CLASSLOADER_INSIDE_DO_PRIVILEGED")
    public static synchronized BootClassLoader getInstance() {
        if (instance == null) {
            instance = new BootClassLoader();
        }

        return instance;
    }

    public BootClassLoader() {
        super(null);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        return Class.classForName(name, false, null);
    }

    @Override
    protected URL findResource(String name) {
        return VMClassLoader.getResource(name);
    }

    @SuppressWarnings("unused")
    @Override
    protected Enumeration<URL> findResources(String resName) throws IOException {
        return Collections.enumeration(VMClassLoader.getResources(resName));
    }

    @Override
    protected Package getPackage(String name) {
        if (name != null && !name.isEmpty()) {
            synchronized (this) {
                Package pack = super.getPackage(name);

                if (pack == null) {
                    pack = definePackage(name, "Unknown", "0.0", "Unknown", "Unknown", "0.0",
                            "Unknown", null);
                }

                return pack;
            }
        }

        return null;
    }

    @Override
    public URL getResource(String resName) {
        return findResource(resName);
    }

    @Override
    protected Class<?> loadClass(String className, boolean resolve)
           throws ClassNotFoundException {
        Class<?> clazz = findLoadedClass(className);

        if (clazz == null) {
            clazz = findClass(className);
        }

        return clazz;
    }

    @Override
    public Enumeration<URL> getResources(String resName) throws IOException {
        return findResources(resName);
    }
}
复制代码

BaseDexClassLoader主要负责加载Framework的东西，没什么好说的，不是我们的重点。

下面来分析PathClassLoader以及DexClassLoader。

PathClassLoader如下：

public class PathClassLoader extends BaseDexClassLoader {

    public PathClassLoader(String dexPath, ClassLoader parent) {
        super(dexPath, null, null, parent);
    }
    
    public PathClassLoader(String dexPath, String librarySearchPath, ClassLoader parent) {
        super(dexPath, null, librarySearchPath, parent);
    }
}
复制代码

DexClassLoader如下：

public class DexClassLoader extends BaseDexClassLoader {
  
    public DexClassLoader(String dexPath, String optimizedDirectory,
            String librarySearchPath, ClassLoader parent) {
        super(dexPath, new File(optimizedDirectory), librarySearchPath, parent);
    }
}
复制代码

需要说明的是一些参数信息：

  • dexPath：需要加载含有dex文件（classes.dex）的路径，一般是jar，apk。
  • optimizedDirectory：解压dex文件后临时存放内容的文件夹路径，一般放在内存储中，PathClassLoader不需要这个参数（因为不能加载指定路径的字节码），所以传null
  • librarySearchPath：包含native lib的目录路径，没有传null
  • parent：父类加载器

下面看父类BaseDexClassLoader的构造函数实现：

public BaseDexClassLoader(String dexPath, File optimizedDirectory,
        String librarySearchPath, ClassLoader parent) {
    super(parent);
    this.pathList = new DexPathList(this, dexPath, librarySearchPath, optimizedDirectory);
}
复制代码

主要就是构造了DexPathList对象，这个对象是用来存储一个或多个dex文件的信息，即内部有一个Element[]数组，数组存放的是DexFile对象。DexPathList对象构造的时候会通过make（Dex、Path）Elements方法去初始化这个Element[]数组：

private static Element[] makeElements(List<File> files, File optimizedDirectory,
                                      List<IOException> suppressedExceptions,
                                      boolean ignoreDexFiles,
                                      ClassLoader loader) {
    Element[] elements = new Element[files.size()];
    int elementsPos = 0;
    /*
     * Open all files and load the (direct or contained) dex files
     * up front.
     */
    for (File file : files) {
        File zip = null;
        File dir = new File("");
        DexFile dex = null;
        String path = file.getPath();
        String name = file.getName();

        if (path.contains(zipSeparator)) {
            String split[] = path.split(zipSeparator, 2);
            zip = new File(split[0]);
            dir = new File(split[1]);
        } else if (file.isDirectory()) {
            // We support directories for looking up resources and native libraries.
            // Looking up resources in directories is useful for running libcore tests.
            elements[elementsPos++] = new Element(file, true, null, null);
        } else if (file.isFile()) {
            if (!ignoreDexFiles && name.endsWith(DEX_SUFFIX)) {
                // Raw dex file (not inside a zip/jar).
                try {
                    dex = loadDexFile(file, optimizedDirectory, loader, elements);
                } catch (IOException suppressed) {
                    System.logE("Unable to load dex file: " + file, suppressed);
                    suppressedExceptions.add(suppressed);
                }
            } else {
                zip = file;

                if (!ignoreDexFiles) {
                    try {
                        dex = loadDexFile(file, optimizedDirectory, loader, elements);
                    } catch (IOException suppressed) {
                        suppressedExceptions.add(suppressed);
                    }
                }
            }
        } else {
            System.logW("ClassLoader referenced unknown path: " + file);
        }

        if ((zip != null) || (dex != null)) {
            elements[elementsPos++] = new Element(dir, false, zip, dex);
        }
    }
    if (elementsPos != elements.length) {
        elements = Arrays.copyOf(elements, elementsPos);
    }
    return elements;
}
复制代码

这个方法的核心就是把初始化DexFile，并且装载到Element[]数组中。

上面就分析完了classes.dex文件是如何通过ClassLoader的初始化装载进来的，下面继续分析一个类是如何通过PathClassLoader或者DexClassLoader进行加载的，这时候就需要看父类BaseDexClassLoader的findClass方法了：

@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
    List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
    Class c = pathList.findClass(name, suppressedExceptions);
    if (c == null) {
        ClassNotFoundException cnfe = new ClassNotFoundException("Didn't find class \"" + name + "\" on path: " + pathList);
        for (Throwable t : suppressedExceptions) {
            cnfe.addSuppressed(t);
        }
        throw cnfe;
    }
    return c;
}
复制代码

这里面看到，实际上就是调用了PathList的findClass方法：

public Class findClass(String name, List<Throwable> suppressed) {
    for (Element element : dexElements) {
        DexFile dex = element.dexFile;

        if (dex != null) {
            Class clazz = dex.loadClassBinaryName(name, definingContext, suppressed);
            if (clazz != null) {
                return clazz;
            }
        }
    }
    if (dexElementsSuppressedExceptions != null) {
        suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
    }
    return null;
}
复制代码

这个方法就是遍历初始化创建好的内部Element[]数组里面的DexFile对象，最终是通过DexFile的loadClassBinaryName进行加载的：

public Class loadClassBinaryName(String name, ClassLoader loader, List<Throwable> suppressed) {
    return defineClass(name, loader, mCookie, this, suppressed);
}
复制代码

defineClass的实现如下：

private static Class defineClass(String name, ClassLoader loader, Object cookie,
                                 DexFile dexFile, List<Throwable> suppressed) {
    Class result = null;
    try {
        result = defineClassNative(name, loader, cookie, dexFile);
    } catch (NoClassDefFoundError e) {
        if (suppressed != null) {
            suppressed.add(e);
        }
    } catch (ClassNotFoundException e) {
        if (suppressed != null) {
            suppressed.add(e);
        }
    }
    return result;
}
复制代码

到最后，defineClassNative是一个native方法：

private static native Class defineClassNative(String name, ClassLoader loader, Object cookie,
                                              DexFile dexFile)
复制代码

defineClassNative是通过C/C++实现，这个方法去dex文件中查找指定name的类，并且拼接成Class字节码，返回给Java层。通过native实现是为了提高效率。

整个加载流程一气呵成，如下图所示：

###实现动态加载

如下面所示，演示了最简单的动态加载的方案：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        String apkPath = getExternalCacheDir().getAbsolutePath() + "/bundle.apk";
        loadApk(apkPath);
    }

    private void loadApk(String apkPath) {
        File optFile = getDir("opt", MODE_PRIVATE);
		// 通过DexClassLoader加载制定的APK文件
        DexClassLoader dexClassLoader = new DexClassLoader(apkPath, optFile.getAbsolutePath(), null, getClassLoader());
        try {
			// 通过反射去使用对象
            Class clz = dexClassLoader.loadClass("com.loubinfeng.www.boundle.Printer");
            if (clz != null) {
                Object instance = clz.newInstance();
                Method method = clz.getMethod("print");
                method.invoke(instance);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
复制代码

###实现动态加载的难点

实现动态加载难点比较多：

  • 资源的访问问题
  • 四大组件的生命周期管理问题
  • 插件ClassLoader的管理
  • so库的动态加载等等

相关文章：http://www.infoq.com/cn/articles/android-dynamic-loading

如果觉得我的文字对你有所帮助的话，欢迎关注我的公众号：

我的群欢迎大家进来探讨各种技术与非技术的话题，有兴趣的朋友们加我私人微信huannan88，我拉你进群交（♂）流（♀）。

classloader类加载器_基于java类的加载方式详解
08-29
Java类加载器（ClassLoader）是Java虚拟机（JVM）中的一个重要组成部分，用于将Java类文件加载到JVM中，以便能够执行Java程序。在Java中，类加载器的设计采用了一种称为“双亲委派模式”（Parent Delegation Model）...
Java基于自定义类加载器实现热部署过程解析
08-19
"Java基于自定义类加载器实现热部署过程解析" Java中基于自定义类加载器实现热部署是指在不重启应用的情况下，当类的定义即字节码文件修改后，能够替换该Class创建的对象。热部署是Java中的一个重要概念，它可以...
Java 类加载机制详解
weixin_43114485的博客
06-23 1279
Java类加载机制是Java运行时的核心，包含加载、验证、准备、解析、初始化等阶段，遵循双亲委派模型确保安全性和唯一性。类加载器分为启动类、扩展类、应用类和自定义类加载器，自定义类加载器可实现热部署和隔离。常见问题包括类冲突和加载异常，可通过调整类路径或隔离解决。该机制在热部署、插件化等场景有重要应用，深入理解有助于排查问题和优化性能。
类加载机制
伟庭的博客
02-18 2555
类加载机制
类加载机制详解
qq_65834915的博客
12-27 1366
当一个区域被填满后，将存活的对象复制到另一个区域，清理掉已被回收的对象。Java的垃圾回收机制是自动管理内存的一种方式，负责回收不再使用的对象所占用的内存空间，以防止内存泄露和优化内存使用。溢出：方法区（可以通过加载大量的类（尤其是动态生成的类）或者使用反射机制创建大量的元数据来撑爆。静态变量的分配：为类中的静态变量开辟内存空间，所有静态变量默认值为其类型对应的默认值。在加载之后，JVM会对加载的字节码进行验证，确保符合Java语言的规范。避免类冲突：每个类只会在顶层加载一次，有效的避免了同名类的冲突。
JVM之类加载器
缘友一世的博客
11-11 1193
一个Tomcat程序中是可以运行多个Web应用的，如果这两个应用中出现了相同限定名的类，比如Servlet类，Tomcat要保证这两个类都能加载并且它们应该是不同的类。如果不打破双亲委派机制，当应用类加载器加载Web应用1中的MyServlet之后，Web应用2中相同限定名的MyServlet类就无法被加载。Tomcat使用了自定义类加载器来实现应用之间类的隔离。每一个应用会有一个独立的类加载器加载对应的类。先来分析ClassLoader的原理，ClassLoader中包含了4个核心方法。
JVM类加载机制
weixin_41812379的博客
04-11 6032
类加载机制 类是在运行期间第一次使用时动态加载的，而不是一次性加载所有类。因为如果一次性加载，那么会占用很多的内存。 JVM类加载过程分为五个部分：加载、验证、准备、解析、初始化。 加载 加载只是类加载的其中一个阶段，不表示整个类加载。 加载的主要过程： 通过类的完全限定名称获取定义该类的二进制字节流。 将该字节流表示的静态存储结构转换为方法区的运行时存储结构。 在堆中生成一个代表该类的 Class 对象，作为方法区中该类各种数据的访问入口。 可以看到下面这张图，加载过程把类的字节码放到了方法区，使用
类加载器详解
热门推荐
我的博客
08-28 1万+
类加载器的分类 JVM支持两种类型的类加载器,分别为引导类加载器(BootstrapClassLoader)和自定义类加载器(User-Defined ClassLoader) 从概念上来讲, 自定义类加载器一般指的是程序中由开发人员自定义的一类,类加载器,但是Java虚拟机规范却没有这么定义,而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器 无论类加载器的类型如何划分,在程序中我们最常见的类加载器始终只有3个,如下所示: 所以具体为引导类加载器(BootstrapClassL
JVM解密: 解构类加载与GC垃圾回收机制
trong_ 的烂笔头
08-30 2057
介绍JVM的内存划分，类加载过程以及GC垃圾回收机制中的查找垃圾和回收垃圾的算法。
自定义类加载器以及打破双亲委派
问题很多的小明
09-10 2343
0x01 自定义类加载器 自定义类加载器加载一个类需要：继承ClassLoader，重写findClass 1 被加载的类： import java.io.Serializable; public class Test360 implements Serializable { public static String admin(){ return "1111111"; } static String name=
JVM-类加载器 && 双亲委派机制
qq_43259860的博客
02-11 1555
原文连接JVM是Java Virtual Machine（Java虚拟机）的缩写，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。由一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域等组成。JVM屏蔽了与操作系统平台相关的信息，使得Java程序只需要生成在Java虚拟机上运行的目标代码（字节码），就可在多种平台上不加修改的运行，这也是Java能够“一次编译，到处运行的”原因。
类加载之双亲委派
weixin_45440755的博客
08-13 1292
双亲委派（Parent Delegation）是 Java 类加载机制中的一个重要概念。它指的是当一个类加载器（ClassLoader）需要加载某个类时，它会首先将加载请求委派给它的父类加载器，依次递归，直到顶层的启动类加载器（Bootstrap ClassLoader）。只有在父类加载器无法加载该类时，才会由子类加载器尝试加载。这种机制的优势在于确保了类的唯一性避免了同一个类被多个类加载器加载导致的类重复问题。
Java类加载器加载类顺序
12-22
java ClassLoader的学习 　java是一门解释执行的语言，由开发人员编写好的java源文件先编译成字节码文件.class... 　一个类如果要被JVM所调度执行，必须先把这个类加载到JVM内存里，java.lang下有个很重要的类ClassL
java 类加载与自定义类加载器详解
08-31
Java中的类加载器通常分为三种：启动类加载器（Bootstrap ClassLoader）、扩展类加载器（Extension ClassLoader）和应用程序类加载器（Application ClassLoader）。它们遵循双亲委派模型，即较低层次的类加载器会将...
深入理解Java 类加载全过程
08-31
Java 类加载全过程是Java程序运行的关键部分，它涉及到类从磁盘加载到内存，并成为可执行对象的过程。本文将详细探讨这一过程的四个主要阶段：加载、链接（验证、准备、解析）、初始化以及使用和卸载。 **1. 加载**...
性能测试工具JvisualVM/jconsole使用
最新发布
平时的经验总结，学习历程
09-12 214
port是jmx的另一个通信端口。可以不设置，启动后系统会自动随机指定端口。如果关闭了防火墙，没有网络访问策略，可以不设置。如果服务器需要开通端口访问策略此处需要配置开通策略的端口。然后在windows客户机，安装jdk目录下的bin目录下找到jvisualvm.exe或jconsole，通过远程连接方式监控jvm的cpu 内存 线程 类加载的情况。com.sun.management.jmxremote.port 是客户端连接的端口。主要介绍远程使用方式，在启动参数添加如下参数。
还在重启应用改 Topic？Spring Boot 动态 Kafka 消费的“终极形态”
郑龙飞
09-10 736
/ 用于存储 @KafkaListener 的“蓝图”// ... 可按需添加 concurrency, autoStartup 等其他属性(元数据采集与注册)@Component@OverrideClass<?= null &&!通过巧妙地结合和动态配置中心，我们实现了一个功能极其强大的动态 Kafka 消费管理方案。
【lucene】bitsetiterator
risc123456的博客
09-09 531
某些自定义 `FieldCache` 或 `DocValues` 去重逻辑，会先把出现过的 docID 记到 `BitSet`，再用 `BitSetIterator` 一次性吐出。`BitSet` 本身只有 `get()/set()/nextSetBit(int)`，没有标准的迭代器语义，于是就有了 `BitSetIterator` 做适配。- `cost()` 直接返回 `cardinality()`，方便上层 `ConjunctionDISI/DisjunctionDISI` 做排序、选 lead。
计算机毕设 java 高校饭堂点餐系统 基于微信小程序 + SSM 的高校餐饮服务平台 Java+MySQL 的点餐与运营系统
毕设源码伍学长
09-10 1020
在高校饭堂就餐需求增长的背景下，传统点餐依赖窗口排队、效率低，存在高峰期拥堵、菜品信息不透明等问题，难以满足师生便捷就餐需求。采用 Java 技术、SSM 框架、Uni-weixin 技术及 MySQL 数据库，开发高校饭堂点餐系统（微信小程序端 + 服务端），整合菜品展示、在线点餐、订单跟踪等功能，支持管理员、商家、用户三类角色协同，打造专业化餐饮服务平台。该系统既能帮助管理员监管平台内容，商家高效管理菜品与订单，又能让用户便捷查询菜品、完成点餐，提升高校饭堂服务效率与用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值