Java可执行jar自解压jar内指定文件到指定目录

最新推荐文章于 2024-06-19 19:32:00 发布

keyleaf~~~~

最新推荐文章于 2024-06-19 19:32:00 发布

阅读量2.4k

点赞数 1

分类专栏： java工具文章标签： jar

本文链接：https://blog.csdn.net/keylkeaf/article/details/110197434

版权

java工具专栏收录该内容

6 篇文章 5 订阅

订阅专栏

Java可执行jar自解压jar内指定文件到指定目录

参考链接

感谢大神【手动膜拜】
https://www.devx.com/tips/Tip/22124
打开慢的话可以直接看下图
在这里插入图片描述

需求说明

需求来源于最近的一个springboot服务，源于各种原因其内打包了部分文件或者脚本，需要在jar运行的时候自动解压到jar外目录，方便自身或者其他服务调用。

比如下图中的scratches目录，想将这个目录以及目录下的所有文件都提取到jar外。

springboot服务中的目录结构

在这里插入图片描述

打成jar包之后的目录结构

在这里插入图片描述

最终要达成的效果

在这里插入图片描述

实现步骤

要有个springboot服务吧

服务搭建就不多说了，入口类的main方法中调用extractFilesFromJar方法就可以了。具体参数在代码中有描述

关于extractFilesFromJar

该方法中用了遍历，比较粗暴，但考虑到是在springboot服务启动之前进行解压操作，对本身业务服务没有影响，所以没仔细研究更好的解决方案。这里扔块土坷垃，引引大家的玉石（抛砖引玉）【手动狗头】。

资源关闭问题简单一说，因为用的jdk是1.8，实现了Closeable接口的类都可以自动进行关闭，如果你用的jdk版本不支持，还请自行处理关闭逻辑。

代码

package com.shuzang.rosefinch;

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

import java.io.IOException;

@SpringBootApplication(exclude = {
        DataSourceAutoConfiguration.class,
        DruidDataSourceAutoConfigure.class
})
@Slf4j
public class RosefinchApplication {

    public static void main(String[] args) {

        // 这里的入参图方便写死了，这个可以从启动参数中传入，进而从args中获取
        extractFilesFromJar("BOOT-INF/classes/scratches/", "/Users/keyleaf/Documents/jobs/private/rosefinch/target/test111/");

        SpringApplication.run(RosefinchApplication.class, args);
    }

    /**
     * 提取当前运行jar中的指定目录/文件到jar外的指定目录
     * 参考链接 https://www.devx.com/tips/Tip/22124
     *
     * @param targetFileInJar 需要从jar中提取的文件目录  这里的地址请参考打成jar之后的目录结构来！！！
     * @param destDir 提取到jar包外的路径地址
     */
    private static void extractFilesFromJar(String targetFileInJar, String destDir) {
        // 测试
//        log.info(String.valueOf(RosefinchApplication.class.getProtectionDomain().getCodeSource().getLocation()));
        // 获取当前执行的jar名称
        String jarFile = System.getProperty("java.class.path");
        log.info(jarFile);
        if (StringUtils.isBlank(jarFile) || !jarFile.endsWith(".jar")) {
            log.error("定位jar失败");
            return;
        }
        try (java.util.jar.JarFile jar = new java.util.jar.JarFile(jarFile)) {
            java.util.Enumeration enumEntries = jar.entries();
            while (enumEntries.hasMoreElements()) {
                java.util.jar.JarEntry jarEntry = (java.util.jar.JarEntry) enumEntries.nextElement();
                String name = jarEntry.getName();
                // 根据路径定位目标文件
                if (!name.startsWith(targetFileInJar)) {
                    continue;
                }
                // 优化路径名称，这里也可以直接用jarEntry.getName()来看下效果
                String fixedName = jarEntry.getName().replace(targetFileInJar, "");
                java.io.File file = new java.io.File(destDir + java.io.File.separator + fixedName);
                // if its a directory, create it
                if (jarEntry.isDirectory()) {
                    file.mkdirs();
                    continue;
                }
                try (java.io.InputStream is = jar.getInputStream(jarEntry);
                     java.io.FileOutputStream fos = new java.io.FileOutputStream(file)) {
                    // write contents of 'is' to 'fos'
                    while (is.available() > 0) {
                        fos.write(is.read());
                    }
                }
            }
        } catch (IOException e) {
            log.error("提取文件异常", e);
        }
    }

}

反编译之后的代码

可以看下资源关闭的步骤是自动给实现了的。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.shuzang.rosefinch;

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

@SpringBootApplication(
    exclude = {DataSourceAutoConfiguration.class, DruidDataSourceAutoConfigure.class}
)
public class RosefinchApplication {
    private static final Logger log = LoggerFactory.getLogger(RosefinchApplication.class);

    public RosefinchApplication() {
    }

    public static void main(String[] args) {
        extractFilesFromJar("BOOT-INF/classes/scratches/", "/Users/keyleaf/Documents/jobs/private/rosefinch/target/test111/");
        SpringApplication.run(RosefinchApplication.class, args);
    }

    private static void extractFilesFromJar(String targetFileInJar, String destDir) {
        String jarFile = System.getProperty("java.class.path");
        log.info(jarFile);
        if (!StringUtils.isBlank(jarFile) && jarFile.endsWith(".jar")) {
            try {
                JarFile jar = new JarFile(jarFile);
                Throwable var4 = null;

                try {
                    Enumeration enumEntries = jar.entries();

                    while(true) {
                        while(true) {
                            JarEntry jarEntry;
                            String name;
                            do {
                                if (!enumEntries.hasMoreElements()) {
                                    return;
                                }

                                jarEntry = (JarEntry)enumEntries.nextElement();
                                name = jarEntry.getName();
                            } while(!name.startsWith(targetFileInJar));

                            String fixedName = jarEntry.getName().replace(targetFileInJar, "");
                            File file = new File(destDir + File.separator + fixedName);
                            if (jarEntry.isDirectory()) {
                                file.mkdirs();
                            } else {
                                InputStream is = jar.getInputStream(jarEntry);
                                Throwable var11 = null;

                                try {
                                    FileOutputStream fos = new FileOutputStream(file);
                                    Throwable var13 = null;

                                    try {
                                        while(is.available() > 0) {
                                            fos.write(is.read());
                                        }
                                    } catch (Throwable var60) {
                                        var13 = var60;
                                        throw var60;
                                    } finally {
                                        if (fos != null) {
                                            if (var13 != null) {
                                                try {
                                                    fos.close();
                                                } catch (Throwable var59) {
                                                    var13.addSuppressed(var59);
                                                }
                                            } else {
                                                fos.close();
                                            }
                                        }

                                    }
                                } catch (Throwable var62) {
                                    var11 = var62;
                                    throw var62;
                                } finally {
                                    if (is != null) {
                                        if (var11 != null) {
                                            try {
                                                is.close();
                                            } catch (Throwable var58) {
                                                var11.addSuppressed(var58);
                                            }
                                        } else {
                                            is.close();
                                        }
                                    }

                                }
                            }
                        }
                    }
                } catch (Throwable var64) {
                    var4 = var64;
                    throw var64;
                } finally {
                    if (jar != null) {
                        if (var4 != null) {
                            try {
                                jar.close();
                            } catch (Throwable var57) {
                                var4.addSuppressed(var57);
                            }
                        } else {
                            jar.close();
                        }
                    }

                }
            } catch (IOException var66) {
                log.error("提取文件异常", var66);
            }
        } else {
            log.error("定位jar失败");
        }
    }
}