JVM CDS动态归档在Spring Boot fat jar中Class-Path通配符失效？AppCDS与SpringBootClassLoader集成 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

JVM CDS 动态归档在 Spring Boot Fat Jar 中 Class-Path 通配符失效问题深度解析

大家好，今天我们来深入探讨一个在 Spring Boot 应用中遇到的一个比较棘手的问题：JVM Class Data Sharing (CDS) 动态归档在 Spring Boot Fat Jar 中使用 Class-Path 通配符失效，以及它与 SpringBootClassLoader 集成时可能出现的问题。

什么是 JVM CDS？

在深入问题之前，我们先快速回顾一下 JVM CDS 的概念。CDS 是一种 JVM 特性，旨在通过在不同 JVM 实例之间共享已加载的类元数据，来减少 JVM 的启动时间和内存占用。它主要分为两种类型：

静态 CDS (Static CDS)： 在 JVM 启动之前，通过工具生成一个包含类元数据的归档文件。JVM 启动时加载该归档文件，从而避免重复加载和解析类。
动态 CDS (Dynamic CDS)： 在 JVM 运行期间，通过 -XX:DumpLoadedClassList=<file> 参数记录已加载的类列表，然后使用 -XX:SharedClassListFile=<file> 和 -Xshare:dump 参数生成归档文件。后续 JVM 实例可以使用 -Xshare:auto 参数加载该归档文件，实现类共享。

CDS 的优势在于：

缩短启动时间： 避免重复加载和解析类，显著减少 JVM 的启动时间。
降低内存占用： 多个 JVM 实例可以共享同一份类元数据，降低内存占用。

Spring Boot Fat Jar 与 Class-Path

Spring Boot Fat Jar (也称为 Uber Jar 或可执行 JAR) 是一种将应用程序的所有依赖项（包括应用程序代码、第三方库、以及嵌入式的 servlet 容器）打包到一个单独的可执行 JAR 文件中的方式。这使得应用程序的部署和分发变得非常简单。

Fat Jar 通常采用以下两种方式处理依赖：

Unpack 方式： 将所有依赖 JAR 文件解压，并将类文件合并到 Fat Jar 的根目录或指定的目录中。
Nested JAR 方式： 将所有依赖 JAR 文件以嵌套 JAR 的形式存储在 Fat Jar 中，通常位于 BOOT-INF/lib 目录下。Spring Boot 使用 SpringBootClassLoader 来加载这些嵌套的 JAR 文件。

Class-Path 是 JAR 文件 manifest 文件中的一个属性，用于指定 JAR 文件所依赖的其他 JAR 文件或目录。例如：

Manifest-Version: 1.0
Created-By: 1.8.0_301 (Oracle Corporation)
Main-Class: com.example.demo.DemoApplication
Class-Path: lib/commons-lang3-3.12.0.jar lib/spring-web-5.3.10.jar

在传统的 Java 应用中，JVM 会根据 Class-Path 属性来加载指定的 JAR 文件。然而，在 Spring Boot Fat Jar 中，由于 SpringBootClassLoader 的存在，Class-Path 的行为可能会有所不同。

问题：动态 CDS 在 Spring Boot Fat Jar 中 Class-Path 通配符失效

现在，让我们来聚焦核心问题：在 Spring Boot Fat Jar 中，当使用动态 CDS 并结合 Class-Path 通配符时，可能会出现归档失效的情况。

问题描述：

假设你的 Spring Boot Fat Jar 包含以下结构：

my-app.jar
├── BOOT-INF
│   ├── classes
│   │   └── com
│   │       └── example
│   │           └── demo
│   │               └── DemoApplication.class
│   └── lib
│       ├── commons-lang3-3.12.0.jar
│       ├── spring-web-5.3.10.jar
│       └── ... 其他依赖 JAR 文件 ...
└── META-INF
    └── MANIFEST.MF

你的 MANIFEST.MF 文件包含类似以下的 Class-Path 属性：

Manifest-Version: 1.0
Created-By: 1.8.0_301 (Oracle Corporation)
Main-Class: com.example.demo.DemoApplication
Class-Path: BOOT-INF/lib/*.jar

你期望 JVM 能够加载 BOOT-INF/lib 目录下所有的 JAR 文件，并将其类信息包含到动态 CDS 归档中。然而，实际情况可能是：只有部分或根本没有来自 BOOT-INF/lib 目录下的类被包含到归档中。导致后续 JVM 实例无法有效地利用 CDS，启动时间并没有明显改善。

原因分析：

这个问题通常与以下几个因素有关：

SpringBootClassLoader 的特殊性： SpringBootClassLoader 并不是标准的 URLClassLoader，它使用自定义的类加载机制来加载嵌套的 JAR 文件。它不会直接使用 MANIFEST.MF 中的 Class-Path 属性来加载类。相反，它会根据 Spring Boot 的内部机制来确定需要加载的 JAR 文件。
Class-Path 通配符的局限性： Class-Path 通配符（如 *.jar）在标准 URLClassLoader 中通常可以正常工作，但 SpringBootClassLoader 可能不支持或以不同的方式处理通配符。它可能只会加载显式列出的 JAR 文件，而忽略通配符。
动态 CDS 的类加载顺序依赖： 动态 CDS 的工作原理依赖于 JVM 在运行期间记录已加载的类列表。如果 SpringBootClassLoader 在归档过程中没有按照预期的方式加载所有必要的类（由于 Class-Path 通配符失效），那么生成的归档文件将不完整。
JAR URL 的形式： Spring Boot 使用特殊的 JAR URL 格式来引用嵌套的 JAR 文件，例如 jar:file:/path/to/my-app.jar!/BOOT-INF/lib/commons-lang3-3.12.0.jar。这种 URL 格式可能导致动态 CDS 无法正确识别和处理类信息。

验证问题：

为了验证这个问题，你可以执行以下步骤：

构建包含 Class-Path 通配符的 Spring Boot Fat Jar。
使用 -XX:DumpLoadedClassList=<file> 参数运行应用程序，记录已加载的类列表。
检查生成的类列表文件，确认是否包含了 BOOT-INF/lib 目录下所有 JAR 文件中的类。
使用 -XX:SharedClassListFile=<file> 和 -Xshare:dump 参数创建动态 CDS 归档。
使用 -Xshare:auto 参数运行应用程序，并观察启动时间。
如果启动时间没有明显改善，并且类列表文件不完整，则表明 Class-Path 通配符失效，动态 CDS 没有生效。

解决方案

针对这个问题，我们可以尝试以下几种解决方案：

显式列出所有 JAR 文件：

最直接的解决方案是避免使用 Class-Path 通配符，而是显式地列出 BOOT-INF/lib 目录下所有的 JAR 文件。虽然这种方法比较繁琐，但可以确保 SpringBootClassLoader 加载所有必要的类。
```
Manifest-Version: 1.0
Created-By: 1.8.0_301 (Oracle Corporation)
Main-Class: com.example.demo.DemoApplication
Class-Path: BOOT-INF/lib/commons-lang3-3.12.0.jar BOOT-INF/lib/spring-web-5.3.10.jar BOOT-INF/lib/... 其他 JAR 文件 ...
```
可以使用构建工具（如 Maven 或 Gradle）来自动生成包含所有 JAR 文件名的 Class-Path 属性。

自定义 SpringBootClassLoader：

可以考虑自定义 SpringBootClassLoader，使其能够正确处理 Class-Path 通配符。这需要深入了解 SpringBootClassLoader 的内部机制，并修改其类加载逻辑。这种方法比较复杂，但可以提供更大的灵活性。

以下是一个简单的示例，展示了如何自定义 SpringBootClassLoader：

import org.springframework.boot.loader.LaunchedURLClassLoader;
import java.net.URL;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.jar.JarFile;
import java.util.Enumeration;

public class CustomSpringBootClassLoader extends LaunchedURLClassLoader {

    public CustomSpringBootClassLoader(URL[] urls, ClassLoader parent) {
        super(urls, parent);
    }

    // Override the addURL method to handle wildcard Class-Path entries
    @Override
    public void addURL(URL url) {
        try {
            File file = new File(url.toURI());
            if (file.isDirectory()) {
                // If it's a directory, add all JAR files within it
                File[] jarFiles = file.listFiles(pathname -> pathname.getName().toLowerCase().endsWith(".jar"));
                if (jarFiles != null) {
                    for (File jarFile : jarFiles) {
                        super.addURL(jarFile.toURI().toURL());
                    }
                }
            } else {
                super.addURL(url);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        // Example usage: create URLs from the Class-Path entry and use the custom classloader
        String classPath = System.getProperty("java.class.path"); // Get the classpath
        String[] classPathEntries = classPath.split(File.pathSeparator);
        List<URL> urls = new ArrayList<>();
        for (String entry : classPathEntries) {
            try {
                File entryFile = new File(entry);
                if (entryFile.exists()) {
                    urls.add(entryFile.toURI().toURL());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        CustomSpringBootClassLoader classLoader = new CustomSpringBootClassLoader(urls.toArray(new URL[0]), ClassLoader.getSystemClassLoader());

        // Now you can use the custom classloader to load classes
        try {
            Class<?> myClass = classLoader.loadClass("com.example.MyClass");
            Object instance = myClass.newInstance();
            System.out.println("Loaded class: " + myClass.getName());
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

注意： 这只是一个简单的示例，可能需要根据你的具体需求进行修改。在实际应用中，你需要将自定义的 ClassLoader 集成到 Spring Boot 的启动流程中。

使用 Spring Boot Devtools (仅用于开发环境)：

Spring Boot Devtools 包含一个 RestartClassLoader，它在应用程序发生更改时会重新加载类。虽然它主要用于开发环境，但它也可以用于解决 Class-Path 通配符的问题。Devtools 的类加载机制可能与标准的 SpringBootClassLoader 不同，从而能够正确处理通配符。

警告： Devtools 不适合用于生产环境，因为它会影响应用程序的性能和安全性。
考虑其他的类共享机制：

如果动态 CDS 在 Spring Boot Fat Jar 中始终无法正常工作，可以考虑其他的类共享机制，例如：
- AppCDS (Application CDS)： AppCDS 是 JDK 9 引入的一种新的 CDS 变体，它允许应用程序自定义类列表，并将其包含到归档文件中。AppCDS 提供了更大的灵活性，可以更好地控制类共享。
- JHipster 的 CDS 支持： JHipster 是一个流行的 Java 应用生成器，它内置了对 CDS 的支持。JHipster 使用特殊的构建配置和类加载器来确保 CDS 能够正常工作。
避免使用 Fat Jar (如果可能)：

如果可能，可以考虑避免使用 Fat Jar，而是将应用程序部署为传统的 WAR 文件或目录结构。这样可以避免 SpringBootClassLoader 带来的问题，并简化类加载过程。

AppCDS 与 SpringBootClassLoader 集成

AppCDS (Application Class Data Sharing) 是一个强大的工具，允许开发者创建定制的类数据共享归档，从而优化 Spring Boot 应用的启动时间和资源利用率。然而，与 SpringBootClassLoader 的集成并非总是直截了当，需要仔细配置。

核心思路:

AppCDS 需要一个类列表文件，该文件列出了所有需要共享的类。在 Spring Boot 应用中，这意味着我们需要确保这个列表包含了所有来自应用本身以及依赖库的类。由于 SpringBootClassLoader 的特殊性，我们需要一种方法来准确地获取这些类的信息。

步骤:

生成类列表文件:

使用 -XX:DumpLoadedClassList: 这是最常用的方法。在应用启动时，添加 JVM 参数 -XX:DumpLoadedClassList=my_app.classlist。这会让 JVM 在应用关闭时，将所有加载的类名写入 my_app.classlist 文件。 注意： 确保应用在dump类列表时，已经加载了所有需要的类，否则将导致归档不完整。可以通过访问应用的各个功能点来确保这一点。

自定义工具类: 编写一个工具类，使用反射和类加载器来遍历所有类，并将它们写入文件。这种方法更加灵活，但需要更多的代码。

import org.springframework.boot.loader.LaunchedURLClassLoader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.net.URL;
import java.net.URLClassLoader;

public class ClassListGenerator {

    public static void main(String[] args) throws IOException {
        List<String> classNames = new ArrayList<>();
        ClassLoader classLoader = ClassListGenerator.class.getClassLoader();

        if (classLoader instanceof LaunchedURLClassLoader) {
            URL[] urls = ((LaunchedURLClassLoader) classLoader).getURLs();
            for (URL url : urls) {
                 if (url.getProtocol().equals("jar")) {
                         String jarPath = url.getPath();
                         if(jarPath.contains("!/")){
                              jarPath = jarPath.substring(0,jarPath.indexOf("!/"));
                         }

                         JarClassEnumerator.enumerateClasses(jarPath, classNames);
                 }
            }

        } else {
            System.err.println("ClassLoader is not a LaunchedURLClassLoader. Cannot generate class list.");
            return;
        }

        Files.write(Paths.get("my_app.classlist"), classNames);
        System.out.println("Class list generated successfully: my_app.classlist");
    }
}

//辅助类枚举jar包里的类
import java.io.IOException;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

public class JarClassEnumerator {

    public static void enumerateClasses(String jarPath, List<String> classNames) {
        try (JarFile jarFile = new JarFile(jarPath)) {
            jarFile.stream()
                    .filter(entry -> entry.getName().endsWith(".class"))
                    .map(JarEntry::getName)
                    .map(className -> className.replace("/", ".").replace(".class", ""))
                    .forEach(classNames::add);
        } catch (IOException e) {
            System.err.println("Error reading JAR file: " + jarPath + " - " + e.getMessage());
        }
    }
}

注意: 这个工具类需要正确处理 Spring Boot Fat Jar 的嵌套 JAR 结构。

创建 AppCDS 归档:

使用 jcmd 工具创建一个 AppCDS 归档。
```
jcmd <pid> JDK.createCDSArchive classlist=my_app.classlist name=my_app_cds
```
- <pid> 是正在运行的 Spring Boot 应用的进程 ID。
- classlist=my_app.classlist 指定了类列表文件。
- name=my_app_cds 指定了归档文件的名称。
使用 AppCDS 归档启动应用:

在启动 Spring Boot 应用时，添加以下 JVM 参数：
```
java -XX:SharedArchiveFile=my_app_cds.jsa -XX:UseAppCDS -jar my-app.jar
```
- -XX:SharedArchiveFile=my_app_cds.jsa 指定了 AppCDS 归档文件的路径。
- -XX:UseAppCDS 启用了 AppCDS。

注意事项:

类加载器隔离: 确保 AppCDS 使用的类加载器与 SpringBootClassLoader 兼容。如果存在类加载器隔离问题，可能会导致类加载失败。可以尝试使用 -Djava.system.class.loader=org.springframework.boot.loader.LaunchedURLClassLoader 强制使用 SpringBootClassLoader 作为系统类加载器。 不建议，容易出问题
依赖管理: AppCDS 需要访问所有依赖库。确保类列表文件包含了所有必要的类，并且这些类在运行时可用。
动态类加载: 如果应用使用了动态类加载（例如，通过反射），则需要确保这些类也被包含到类列表文件中。
版本兼容性: AppCDS 的行为可能因 JVM 版本而异。确保你的 JVM 版本支持 AppCDS，并阅读相关文档。
验证: 启动应用后，使用 jcmd <pid> VM.cds_stats 命令来验证 AppCDS 是否成功加载。

示例:

假设你有一个简单的 Spring Boot 应用，它依赖于 commons-lang3 库。你可以按照以下步骤创建和使用 AppCDS 归档：

添加依赖: 在 pom.xml 文件中添加 commons-lang3 依赖。
生成类列表文件: 使用 -XX:DumpLoadedClassList 参数启动应用，并访问应用的各个功能点。
创建 AppCDS 归档: 使用 jcmd 工具创建 AppCDS 归档。
使用 AppCDS 归档启动应用: 使用 -XX:SharedArchiveFile 和 -XX:UseAppCDS 参数启动应用。
验证: 使用 jcmd <pid> VM.cds_stats 命令验证 AppCDS 是否成功加载。

表格总结解决方案

解决方案	优点	缺点	复杂度	适用场景
显式列出 JAR 文件	简单直接，确保所有类都被加载。	维护成本高，每次添加或删除依赖都需要手动更新 `Class-Path`。	低	依赖数量较少，且不经常变化的场景。
自定义 SpringBootClassLoader	可以灵活地处理 `Class-Path` 通配符，并实现自定义的类加载逻辑。	复杂度高，需要深入了解 `SpringBootClassLoader` 的内部机制，并且容易引入错误。	高	需要高度定制化的类加载行为，并且对 Spring Boot 的内部机制有深入了解的场景。
使用 Spring Boot Devtools	在开发环境中可以方便地解决 `Class-Path` 通配符的问题。	不适合用于生产环境，会影响应用程序的性能和安全性。	中	仅适用于开发环境。
使用其他的类共享机制	AppCDS 提供了更大的灵活性，可以更好地控制类共享。 JHipster 内置了对 CDS 的支持，可以简化 CDS 的配置。	AppCDS 的配置比较复杂，需要深入了解其工作原理。 JHipster 引入了额外的依赖和配置，可能会增加应用程序的复杂度。	中/高	需要更高级的类共享功能，并且愿意投入更多的时间和精力进行配置的场景。
避免使用 Fat Jar	可以避免 `SpringBootClassLoader` 带来的问题，并简化类加载过程。	需要额外的部署和配置工作，可能会增加应用程序的部署复杂度。	低	可以接受非 Fat Jar 部署方式的场景。
AppCDS集成	允许定制类数据共享归档，优化启动时间和资源利用率。	与 `SpringBootClassLoader` 集成复杂，需要准确生成类列表，处理类加载器隔离和依赖管理问题。	高	追求极致启动性能优化，愿意投入时间和精力解决复杂配置问题的场景。

选择合适的解决方案

选择哪种解决方案取决于你的具体需求和约束。如果你的应用程序的依赖数量较少，并且不经常变化，那么显式列出 JAR 文件可能是一个不错的选择。如果你需要高度定制化的类加载行为，并且对 Spring Boot 的内部机制有深入了解，那么自定义 SpringBootClassLoader 可能更适合你。如果动态 CDS 在 Spring Boot Fat Jar 中始终无法正常工作，可以考虑其他的类共享机制。

问题根源和解决方案的思考

我们深入分析了 JVM CDS 在 Spring Boot Fat Jar 中使用 Class-Path 通配符失效的问题，并提供了多种解决方案。问题的根源在于 SpringBootClassLoader 的特殊性以及 Class-Path 通配符的局限性。要解决这个问题，需要深入了解 Spring Boot 的类加载机制，并根据具体情况选择合适的解决方案。

AppCDS 集成需要细致的配置和验证

AppCDS 作为一个强大的优化工具，在 Spring Boot 应用中能够显著提升性能。但要成功集成 AppCDS，必须细致地配置类列表生成、归档创建和启动参数，并进行充分的验证，确保其真正生效。

总结和选择

总而言之，在 Spring Boot Fat Jar 中使用动态 CDS 并非一帆风顺，需要仔细考虑 SpringBootClassLoader 的影响，并选择合适的解决方案。希望今天的分享能够帮助大家更好地理解这个问题，并找到适合自己的解决方案。感谢大家的聆听！