java 文件夹打包成zip

Dear 丶 2023-10-07 22:59 21阅读 0赞

## 调用 ##

FileOutputStream fos1 = new FileOutputStream(new File("zip生成路径"));
    ZipUtil.toZip("文件路径", fos1, response, true);

## zip打包工具类 ##

public class ZipUtil {
    
        private static final int BUFFER_SIZE = 2 * 1024;
    
        /**
         * 压缩成ZIP 方法1
         *
         * @param srcDir           压缩文件夹路径
         * @param out              压缩文件输出流
         * @param KeepDirStructure 是否保留原来的目录结构,true:保留目录结构;
         *                         false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
         * @throws RuntimeException 压缩失败会抛出运行时异常
         */
        public static void toZip(String srcDir, OutputStream out, HttpServletResponse response, boolean KeepDirStructure)
                throws RuntimeException {
    
            long start = System.currentTimeMillis();
            ZipOutputStream zos = null;
            try {
                zos = new ZipOutputStream(out);
                File sourceFile = new File(srcDir);
                compress(sourceFile, zos, sourceFile.getName(), KeepDirStructure);
                long end = System.currentTimeMillis();
                System.out.println("压缩完成，耗时：" + (end - start) + " ms");
    
    
            } catch (Exception e) {
                throw new RuntimeException("zip error from ZipUtils", e);
            } finally {
                if (zos != null) {
                    try {
                        zos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    
        /**
         * 压缩成ZIP 方法2
         *
         * @param srcFiles 需要压缩的文件列表
         * @param out      压缩文件输出流
         * @throws RuntimeException 压缩失败会抛出运行时异常
         */
        public static void toZip(List<File> srcFiles, OutputStream out) throws RuntimeException {
            long start = System.currentTimeMillis();
            ZipOutputStream zos = null;
            try {
                zos = new ZipOutputStream(out);
                for (File srcFile : srcFiles) {
                    byte[] buf = new byte[BUFFER_SIZE];
                    zos.putNextEntry(new ZipEntry(srcFile.getName()));
                    int len;
                    FileInputStream in = new FileInputStream(srcFile);
                    while ((len = in.read(buf)) != -1) {
                        zos.write(buf, 0, len);
                    }
                    zos.closeEntry();
                    in.close();
                }
                long end = System.currentTimeMillis();
                System.out.println("压缩完成，耗时：" + (end - start) + " ms");
            } catch (Exception e) {
                throw new RuntimeException("zip error from ZipUtils", e);
            } finally {
                if (zos != null) {
                    try {
                        zos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
    
        /**
         * 递归压缩方法
         *
         * @param sourceFile       源文件
         * @param zos              zip输出流
         * @param name             压缩后的名称
         * @param KeepDirStructure 是否保留原来的目录结构,true:保留目录结构;
         *                         false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
         * @throws Exception
         */
        private static void compress(File sourceFile, ZipOutputStream zos, String name,
                                     boolean KeepDirStructure) throws Exception {
            byte[] buf = new byte[BUFFER_SIZE];
            if (sourceFile.isFile()) {
                // 向zip输出流中添加一个zip实体，构造器中name为zip实体的文件的名字
                zos.putNextEntry(new ZipEntry(name));
                // copy文件到zip输出流中
                int len;
                FileInputStream in = new FileInputStream(sourceFile);
                while ((len = in.read(buf)) != -1) {
                    zos.write(buf, 0, len);
                }
                // Complete the entry
                zos.closeEntry();
                in.close();
            } else {
                File[] listFiles = sourceFile.listFiles();
                if (listFiles == null || listFiles.length == 0) {
                    // 需要保留原来的文件结构时,需要对空文件夹进行处理
                    if (KeepDirStructure) {
                        // 空文件夹的处理
                        zos.putNextEntry(new ZipEntry(name + "/"));
                        // 没有文件，不需要文件的copy
                        zos.closeEntry();
                    }
    
                } else {
                    for (File file : listFiles) {
                        // 判断是否需要保留原来的文件结构
                        if (KeepDirStructure) {
                            // 注意：file.getName()前面需要带上父文件夹的名字加一斜杠,
                            // 不然最后压缩包中就不能保留原来的文件结构,即：所有文件都跑到压缩包根目录下了
                            compress(file, zos, name + "/" + file.getName(), KeepDirStructure);
                        } else {
                            compress(file, zos, file.getName(), KeepDirStructure);
                        }
    
                    }
                }
            }
        }
    
        /**
         * 下载ZIP压缩包(会对下载后的压缩包进行删除)
         *
         * @param file     zip压缩包文件
         * @param response 响应
         * @author liukai
         */
        public static void downloadZip(File file, HttpServletResponse response) {
            OutputStream toClient = null;
            try {
                // 以流的形式下载文件。
                BufferedInputStream fis = new BufferedInputStream(new FileInputStream(file.getPath()));
                byte[] buffer = new byte[fis.available()];
                fis.read(buffer);
                fis.close();
                // 清空response
                response.reset();
                toClient = new BufferedOutputStream(response.getOutputStream());
                response.setCharacterEncoding("UTF-8");
                response.setContentType("application/octet-stream");
                response.setHeader("Content-Disposition", "attachment;filename=" + file.getName());
                toClient.write(buffer);
                toClient.flush();
            } catch (Exception e) {
                System.out.println("下载zip压缩包过程发生异常");
            } finally {
                if (toClient != null) {
                    try {
                        toClient.close();
                    } catch (IOException e) {
                        System.out.println("zip包下载关流失败");
                    }
                }
            }
        }
    
    
        /**
         * zip解压
         *
         * @param srcFile     zip源文件
         * @param destDirPath 解压后的目标文件夹
         * @throws RuntimeException 解压失败会抛出运行时异常
         */
        public static List<String> unZip(File srcFile, String destDirPath) throws RuntimeException {
    
            //记录解压出来的所有文件名
            List<String> filesName = new ArrayList<>();
            long start = System.currentTimeMillis();
            // 判断源文件是否存在
            if (!srcFile.exists()) {
                throw new RuntimeException(srcFile.getPath() + "所指文件不存在");
            }
            // 开始解压
            ZipFile zipFile = null;
            try {
                zipFile = new ZipFile(srcFile, Charset.forName("GBK"));
                Enumeration<?> entries = zipFile.entries();
    
                while (entries.hasMoreElements()) {
                    ZipEntry entry = (ZipEntry) entries.nextElement();
    
                    //    System.out.println("解压文件:" + entry.getName());
                    // 如果是文件夹，就创建个文件夹
                    if (entry.isDirectory()) {
                        String dirPath = destDirPath + "/" + entry.getName();
                        File dir = new File(dirPath);
                        dir.mkdirs();
                    } else {
                        //添加进filesName
                        filesName.add(entry.getName());
                        // 如果是文件，就先创建一个文件，然后用io流把内容copy过去
                        File targetFile = new File(destDirPath + "/" + entry.getName());
                        // 保证这个文件的父文件夹必须要存在
                        if (!targetFile.getParentFile().exists()) {
                            targetFile.getParentFile().mkdirs();
                        }
                        targetFile.createNewFile();
                        // 将压缩文件内容写入到这个文件中
                        InputStream is = zipFile.getInputStream(entry);
                        FileOutputStream fos = new FileOutputStream(targetFile);
                        int len;
                        byte[] buf = new byte[1024];
                        while ((len = is.read(buf)) != -1) {
                            fos.write(buf, 0, len);
                        }
                        // 关流顺序，先打开的后关闭
                        fos.close();
                        is.close();
                    }
                }
                long end = System.currentTimeMillis();
                System.out.println("解压完成，耗时：" + (end - start) + " ms");
            } catch (Exception e) {
                throw new RuntimeException("unzip error from ZipUtils", e);
            } finally {
                if (zipFile != null) {
                    try {
                        zipFile.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return filesName;
        }
    
    
        /**
         * 删除文件
         *
         * @param filePath
         * @return
         */
        public static boolean deleteFile(String filePath) {
            boolean flag = false;
            File file = new File(filePath);
            if (!file.exists()) {
                return flag;
            }
            if (!file.isDirectory()) {
                return flag;
            }
            String[] tempList = file.list();
            File temp;
            for (int i = 0; i < tempList.length; i++) {
                if (filePath.endsWith(File.separator)) {
                    temp = new File(filePath + tempList[i]);
                } else {
                    temp = new File(filePath + File.separator + tempList[i]);
                }
                if (temp.isFile()) {
                    temp.delete();
                }
                if (temp.isDirectory()) {
                    // 先删除文件夹里面的文件
                    deleteFile(filePath + "/" + tempList[i]);
                    // 再删除空文件夹
                    deleteFile(filePath + "/" + tempList[i]);
                    flag = true;
                }
            }
            return flag;
        }
    
        /**
         * 删除zip
         *
         * @param filePath
         * @return
         */
        public static void deleteZip(String filePath) {
            File file = new File(filePath);
            // zip文件  判断 是否存在
            if (file.getName().endsWith(".zip")) {  
                if (file.delete()) {
                    System.out.println("zip文件已经删除");
                } else {
                    System.out.println("zip文件删除失败");
                }
            }
        }
    }