Java解析嵌套jar中class文件过程

数码系统

相机 win10

测评 win11

手机智车

华为 Tesla

小米理想

苹果蔚来

游戏软件

LOL 抖音

原神微信

当前位置：首页

编程语言

Java解析嵌套jar中class文件过程

热心网友时间：2026-04-22

转载

一、简述

用Ma ven构建项目，最终打包成jar文件时，一个常见的结果是：这个jar包里，不仅包含了你自己的代码，还打包了所有依赖的库文件。这就形成了一个“嵌套”的结构。

免费影视、动漫、音乐、游戏、小说资源长期稳定更新！ 👉 点此立即查看 👈

Ja va解析嵌套jar中class文件过程

那么问题来了，如果想直接从这个“大包”里，解析出嵌套在内部那些依赖jar包中的class文件，该怎么办？别急，下面就来聊聊两种主流且实用的方法：一种是借助Spring Boot生态里的spring-boot-loader包提供的JarFileArchive；另一种则是使用Ja va标准库里的ja va.util.jar.JarFile。两种方式各有特点，咱们逐一拆解。

二、JarFileArchive方式

1. spring-boot-loader依赖引入

要使用第一种方法，首先得把工具包引入项目。在Ma ven的pom.xml里加上下面这段依赖即可：


    org.springframework.boot
    spring-boot-loader
    2.2.4.RELEASE

注意，版本号可以根据实际情况调整。

2. demo案例

这里有个细节需要提醒：不同版本的spring-boot-loader，其getNestedArchives方法签名可能不同。比如在较早版本中用的方法，在高版本里可能已被标记为废弃，转而使用参数更丰富的新方法。所以，实际编码时最好跟进一下你所使用版本的官方源码，做相应调整。

核心逻辑其实很清晰，看下面的代码示例就明白了：

   public static void main(String args[]) throws Exception {
        String jarPath = "C:\\Users\\root\\Desktop\\make-test.jar";
        // 方案一：spring-boot-loader
        long start1 = System.currentTimeMillis();
        getClassInfoByJarLib(jarPath);
        long end1 = System.currentTimeMillis();
        log.info("收集所有lib类ClassInfo,花费时间={}",(end1-start1));
    } 

    public static void getClassInfoByJarLib(String jarPath) {
        String filePath;
        String separator = File.separator;
        if("\\".equals(separator)){
            // windows系统使用如下路径
            filePath = "file:/"+ URLDecoder.decode(jarPath, StandardCharsets.UTF_8).replaceAll("\\\\","/")+"!/";
        }else if("/".equals(separator)){
            // linux系统使用如下路径
            filePath = "file:"+ URLDecoder.decode(jarPath, StandardCharsets.UTF_8).replaceAll("\\\\","/")+"!/";
        }else {
             throw new RuntimeException("未知操作系统，解析jarLib失败");
        } 
        String rootJarPath = "jar:"+ filePath;
        try {
            JarFileArchive jarFileArchive = new JarFileArchive(new Handler().getRootJarFileFromUrl(new URL(rootJarPath)));
            // getNestedArchives获取嵌套的jar等文件，参数是个EntryFilter，用于过滤
            jarFileArchive.getNestedArchives(entry -> entry.getName().startsWith("BOOT-INF/lib/") && entry.getName().endsWith(".jar"))
                    .forEach(archive -> {
                        archive.iterator().forEachRemaining(entry -> {
                            String entryName = entry.getName();
                            // 过滤出嵌套jar包中的字节码文件
                            if (entryName.endsWith(".class")) {
                                String className = entryName.replace('/', '.').replace(".class", "");
                                log.info("className:{}",className);
                            }
                        });
                    });
        } catch (IOException e) {
            log.error("解析嵌套jarLib中ClassInfo异常，jarPath={}",jarPath,e);
            throw new RuntimeException(e);
        }
    }

这段代码的关键在于，它利用JarFileArchive这个封装好的工具，能够非常方便地遍历出嵌套在BOOT-INF/lib/目录下的所有jar包，并进一步解析出里面的每一个class文件。路径处理和异常捕获也都考虑进去了，开箱即用。

三、JarFile方式

1. demo案例

如果你不想引入额外的依赖，纯用JDK自带的能力行不行？当然可以。Ja va标准库中的JarFile类同样能完成这个任务，只不过需要自己多写几行处理逻辑。

   public static void main(String args[]) throws Exception {
        String jarPath = "C:\\Users\\root\\Desktop\\make-test.jar";
        // 方案二：JarFile
        long start2 = System.currentTimeMillis();
        processJar(jarPath);
        long end2 = System.currentTimeMillis();
        log.info("收集所有lib类ClassInfo,花费时间={}",(end2-start2));
    } 
    private static void processJar(String jarPath){
        try (JarFile jarFile = new JarFile(new File(jarPath))) {
            jarFile.stream().parallel()
                    // 过滤出所有符合要求的jar包
                    .filter(entry -> !entry.isDirectory() && entry.getName().startsWith("BOOT-INF/lib/") && entry.getName().endsWith(".jar"))
                    .forEach(entry -> processNestedJar(jarFile, entry.getName()));
        } catch (IOException e) {
            log.error("解析嵌套jarLib中ClassInfo异常，jarPath={}",jarPath,e);
            throw new RuntimeException(e);
        }
    }

    private static void processNestedJar(JarFile jarFile, String entryName){
        // 处理嵌套jar文件
        try (InputStream nestedJarStream = jarFile.getInputStream(jarFile.getJarEntry(entryName));
            JarInputStream jarInputStream = new JarInputStream(nestedJarStream)) {
            JarEntry nestedEntry;
            while ((nestedEntry = jarInputStream.getNextJarEntry()) != null) {
                if (nestedEntry.isDirectory()) {
                    continue;
                }
                String nestedEntryName = nestedEntry.getName();
                if (!nestedEntryName.endsWith(".class")) {
                    continue;
                }
                try {
                    String className = nestedEntryName.replace('/', '.').replace(".class", "");
                    log.info("className:{}",className);
                } catch (Exception e) {
                    log.error("目标类={}查找失败",nestedEntryName,e);
                    throw new RuntimeException(e);
                }
            }
        } catch (IOException e) {
            log.error("目标类={}查找失败",entryName,e);
            throw new RuntimeException(e);
        }
    }

这种方式的核心是使用JarFile和JarInputStream进行两层遍历。第一层找到嵌套的jar包，第二层再像解压缩一样，逐个读取嵌套jar里的class条目。代码量稍多，但胜在零依赖，理解起来也更底层。