如何将Jar包内嵌套的Jar文件添加至Classpath？

这个问题我碰到过好多次了——Java默认的系统类加载器根本不会去扫描Jar包内部嵌套的Jar文件，所以直接把主Jar加到Classpath里肯定找不到嵌套Jar里的类。下面给你几个靠谱的解决方案，你可以根据自己的场景选：

1. 解压嵌套Jar并合并成单个Jar #

这是最直接的办法，把主Jar里lib/目录下的所有嵌套Jar都解压出来，然后把解压后的类文件和主Jar的内容合并成一个新的Jar包。

如果你用Maven的话，用maven-shade-plugin就能自动完成这个操作，配置大概是这样：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.4.1</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <transformers>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <mainClass>com.your.package.MainClass</mainClass>
                    </transformer>
                </transformers>
            </configuration>
        </execution>
    </executions>
</plugin>

执行mvn package之后，生成的Jar就包含了所有嵌套Jar的类，直接运行就行。

优点：不需要额外的代码，合并后的Jar可以直接在任何Java环境运行；
缺点：如果嵌套Jar很多，最终Jar会很大；如果不同Jar里有同名类，会出现冲突覆盖的问题。

2. 自定义类加载器 #

如果不想修改Jar的结构，可以自己写一个类加载器，让它去读取主Jar里的嵌套Jar并加载其中的类。

比如继承URLClassLoader，在初始化的时候扫描主Jar的lib/目录，把所有嵌套Jar的URL添加到类加载器的路径中：

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URI;
import java.util.Enumeration;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

public class NestedJarClassLoader extends URLClassLoader {
    public NestedJarClassLoader(URL[] urls, ClassLoader parent) throws IOException {
        super(urls, parent);
        // 获取主Jar的URL
        URL mainJarUrl = getClass().getProtectionDomain().getCodeSource().getLocation();
        try (JarFile mainJar = new JarFile(new File(mainJarUrl.toURI()))) {
            Enumeration<JarEntry> entries = mainJar.entries();
            while (entries.hasMoreElements()) {
                JarEntry entry = entries.nextElement();
                // 筛选lib目录下的Jar文件
                if (entry.getName().startsWith("lib/") && entry.getName().endsWith(".jar") && !entry.isDirectory()) {
                    // 构建嵌套Jar的URL（格式：jar:主JarURL!/嵌套Jar路径!/）
                    URL nestedJarUrl = new URL("jar:" + mainJarUrl + "!/" + entry.getName() + "!/");
                    addURL(nestedJarUrl);
                }
            }
        } catch (Exception e) {
            throw new IOException("Failed to load nested jars", e);
        }
    }

    public static void main(String[] args) throws Exception {
        // 使用自定义类加载器加载主类
        ClassLoader loader = new NestedJarClassLoader(new URL[0], ClassLoader.getSystemClassLoader());
        Class<?> mainClass = loader.loadClass("com.your.package.MainClass");
        mainClass.getMethod("main", String[].class).invoke(null, (Object) args);
    }
}

把这个类打包到主Jar里，然后运行这个类的main方法，就能加载嵌套Jar里的类了。

优点：保持原有的Jar嵌套结构，不需要修改依赖；
缺点：需要自己处理类加载的逻辑，可能会遇到双亲委派模型的冲突，调试起来有点麻烦。

3. 提取嵌套Jar到Classpath #

如果只是临时解决问题，最简单的办法就是把主Jar里lib/目录下的所有Jar提取出来，放到一个单独的文件夹（比如和主Jar同目录的lib文件夹），然后用命令行指定完整的Classpath：

# Linux/Mac
java -cp your-main.jar:lib/*.jar com.your.package.MainClass

# Windows
java -cp your-main.jar;lib\*.jar com.your.package.MainClass

如果用构建工具（Maven/Gradle），可以把这些嵌套Jar作为项目的依赖添加进去，构建工具会自动帮你管理Classpath。

优点：操作简单，不需要写额外代码；
缺点：需要手动提取嵌套Jar，或者调整项目依赖配置，没法保持主Jar的“单文件”特性。

4. Java 9+ 模块化方案 #

如果你的项目用的是Java 9及以上，可以利用模块化系统来处理：

• 把主Jar和嵌套Jar都定义为模块（添加module-info.java），然后在主模块的module-info.java里声明对嵌套模块的依赖；
• 或者用jpackage工具把所有依赖打包成一个可执行的镜像，它会自动处理所有依赖的加载；
• 也可以把嵌套Jar作为自动模块，用--module-path指定所有Jar的路径。

优点：符合现代Java的模块化趋势，依赖管理更清晰；
缺点：需要适配Java 9+的模块化系统，老项目迁移可能有成本。

内容的提问来源于stack exchange，提问作者jana