引言

在项目中，可以通过标准库 java.util.zip 来实现ZIP文件的压缩和解压缩。压缩时，将多个文件或目录打包成一个 ZIP 文件；解压缩时，将 ZIP 文件中的内容提取到指定目录。

添加依赖

项目默认已经包含了 java.util.zip ，因此无需额外添加依赖。

压缩、解压缩工具

在 xiaomayi-common/xiaomayi-core 核心模块的 utils 工具目录中创建并定义了文件压缩、解压缩工具类。

package com.xiaomayi.core.utils;

import java.io.*;
import java.nio.charset.Charset;
import java.util.Enumeration;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;

/**
 * <p>
 * ZIP压缩工具类
 * </p>
 * 特别注意：依赖非静态set方法，切记不然无法读取值
 *
 * @author 小蚂蚁云团队
 * @since 2024-02-21
 */
public class ZipUtils {

    private static final int BUFFER_SIZE = 20 * 1024;

    /**
     * 压缩文件夹到指定zip文件
     *
     * @param srcDir     源文件夹
     * @param targetFile 目标知道zip文件
     * @throws IOException IO异常，抛出给调用者处理
     */
    public static void zip(String srcDir, String targetFile, boolean KeepDirStructure) throws IOException {
        try (
                OutputStream outputStream = new FileOutputStream(targetFile);
        ) {
            zip(srcDir, outputStream, KeepDirStructure);
        }
    }

    /**
     * 压缩成ZIP
     *
     * @param srcDir           压缩文件夹路径
     * @param out              压缩文件输出流
     * @param KeepDirStructure 是否保留原来的目录结构,true:保留目录结构;
     *                         false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
     * @throws RuntimeException 压缩失败会抛出运行时异常
     */
    public static void zip(String srcDir, OutputStream out, 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();
                }
            }
        }
    }

    /**
     * 压缩文件
     *
     * @param srcFiles   需要压缩的文件列表
     * @param targetFile 压缩文件输出
     * @throws IOException 压缩失败会抛出运行时异常
     */
    public static void zip(List<File> srcFiles, String targetFile) throws IOException {
        try (
                OutputStream outputStream = new FileOutputStream(targetFile);
        ) {
            zip(srcFiles, outputStream);
        }
    }

    /**
     * 文件压缩
     *
     * @param srcFiles 需要压缩的文件列表
     * @param out      压缩文件输出流
     * @throws RuntimeException 压缩失败会抛出运行时异常
     */
    public static void zip(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);
                    }
                }
            }
        }
    }

    /**
     * 文件解压
     *
     * @param zipFileName 解压文件路径
     * @param destDirPath 解压目标文件路径
     */
    public static void unzip(String zipFileName, String destDirPath) {
        File srcFile = new File(zipFileName);
        unZip(srcFile, destDirPath);
    }

    /**
     * 文件解压
     *
     * @param srcFile     解压文件路径
     * @param destDirPath 解压目标文件路径
     * @throws RuntimeException
     */
    public static void unZip(File srcFile, String destDirPath) throws RuntimeException {
        long start = System.currentTimeMillis();
        // 判断源文件是否存在
        if (!srcFile.exists()) {
            throw new RuntimeException(srcFile.getPath() + "所指文件不存在");
        }
        // 开始解压
        ZipFile zipFile = null;
        try {
            //指定编码格式，不然会报错：java.lang.IllegalArgumentException: MALFORMED
            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 {
                    // 如果是文件，就先创建一个文件，然后用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[BUFFER_SIZE];
                    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();
                }
            }
        }
    }

}

压缩、解压缩实现

在 E盘 准备三个文件，分别是 文件1.xlsx、文件2.xlsx、文件1.docx，如下图：

文件压缩、解压缩实现：

package com.xiaomayi.admin.controller.demo;

import com.xiaomayi.core.utils.R;
import com.xiaomayi.core.utils.ZipUtils;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * 压缩、解压缩文件 前端控制器
 * </p>
 *
 * @author 小蚂蚁云团队
 * @since 2024-05-26
 */
@Slf4j
@RestController
@RequestMapping("/zip")
@AllArgsConstructor
public class UnZipController {

    /**
     * 文件压缩
     *
     * @return 返回结果
     * @throws IOException 异常处理
     */
    @GetMapping("/compress")
    public R compress() throws IOException {
        // 设置源文件路径
        String sourceFolderPath = "E:\\compress";
        // 设置压缩文件路径
        String zipFilePath = "E:\\compress.zip";
        // 实现文件压缩
        ZipUtils.zip(sourceFolderPath, zipFilePath, true);
        return R.ok();
    }

    /**
     * 指定文件列表压缩
     *
     * @return 返回结果
     * @throws IOException 异常处理
     */
    @GetMapping("/compress2")
    public R compress2() throws IOException {
        // 设置文件列表
        List<File> srcFiles = new ArrayList<>();
        srcFiles.add(new File("E:\\compress\\文件1.xlsx"));
        srcFiles.add(new File("E:\\compress\\文件2.xlsx"));
        srcFiles.add(new File("E:\\compress\\文件1.docx"));
        // 压缩文件路径
        String zipFilePath = "E:\\compress.zip";
        // 实现文件压缩
        ZipUtils.zip(srcFiles, zipFilePath);
        return R.ok();
    }

    /**
     * 文件解压缩
     *
     * @return 返回结果
     * @throws IOException 异常处理
     */
    @GetMapping("/decompress")
    public R decompress() throws IOException {
        // 设置压缩文件路径
        String zipFilePath = "E:\\compress.zip";
        // 设置解压文件路径
        String destDirectory = "E:\\compress2";
        // 实现文件解压缩
        ZipUtils.unzip(zipFilePath, destDirectory);
        return R.ok();
    }

}

总结

在项目中，可以通过 OutputStream 和 java.util.zip 包实现ZIP文件的压缩和解压缩。压缩时，将文件或目录写入 ZipOutputStream；解压缩时，从 ZipInputStream 读取文件并写入目标目录。