ZIP文件操作工具类

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FilenameUtils;

import java.io.*;
import java.nio.charset.Charset;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;


@Slf4j
public class PfZipUtil {
    public static final int BUFFER_SIZE = 2048;

    private PfZipUtil() {
    }

    public static void zipFile(String toZipFilePath, String zipFilePath) throws IOException {
        InputStream inputStream = null;
        ZipOutputStream zipOutputStream = null;
        File toZipFile = new File(toZipFilePath);
        File zipFile = new File(zipFilePath);
        try {
            inputStream = new FileInputStream(toZipFile);
            zipOutputStream = new ZipOutputStream(new FileOutputStream(zipFile));
            zipOutputStream.putNextEntry(new ZipEntry(toZipFile.getName()));
            int currentByte = -1;
            log.debug(String.valueOf(currentByte));
            byte[] data = new byte[BUFFER_SIZE];
            while ((currentByte = inputStream.read(data, 0, BUFFER_SIZE)) != -1) {
                zipOutputStream.write(data, 0, currentByte);
            }
            zipOutputStream.flush();
        } finally {
            SafeCloseUtil.safeClose(inputStream);
            SafeCloseUtil.safeClose(zipOutputStream);
            if (toZipFile.exists()) {
                boolean isDeleted = toZipFile.delete();
                if (!isDeleted) {
                    log.warn("delete file failed " + toZipFile.getAbsolutePath());
                }
            }
        }
    }

    public static void zipFiles(File[] toZipFilePath, String zipFilePath) throws IOException {
        InputStream inputStream = null;
        zipFilePath = PfStringUtil.getLegalPath(zipFilePath);
        File zipFile = new File(zipFilePath);
        FileOutputStream outputStream = new FileOutputStream(zipFile);
        ZipOutputStream zipOutputStream = new ZipOutputStream(outputStream);
        try {
            for (File file : toZipFilePath) {
                inputStream = new FileInputStream(file.getAbsolutePath());
                zipOutputStream.putNextEntry(new ZipEntry(file.getName()));
                int currentByte = -1;
                log.debug(String.valueOf(currentByte));
                byte[] data = new byte[BUFFER_SIZE];
                while ((currentByte = inputStream.read(data, 0, BUFFER_SIZE)) != -1) {
                    zipOutputStream.write(data, 0, currentByte);
                }
                zipOutputStream.closeEntry();
                inputStream.close();
            }
            zipOutputStream.close();
        } finally {
            SafeCloseUtil.safeClose(inputStream);
            SafeCloseUtil.safeClose(zipOutputStream);
            for (File file : toZipFilePath) {
                if (file.exists()) {
                    boolean isDeleted = file.delete();
                    if (!isDeleted) {
                        log.warn("delete file failed " + file.getAbsolutePath());
                    }
                }
            }
        }
    }

    public static void createZip(String sourcePath, String zipPathNo) {
        String zipPath = FileUtil.verifyNonNullString(zipPathNo);
        if (zipPath == null) {
            return;
        }
        FileOutputStream fos = null;
        ZipOutputStream zos = null;
        try {
            fos = new FileOutputStream(zipPath);
            zos = new ZipOutputStream(fos);
            String sourcePath2 = FileUtil.verifyNonNullString(sourcePath);
            if (sourcePath2 != null) {
                writeZip(new File(sourcePath2), "", zos);
            }
        } catch (FileNotFoundException e) {
            log.error("creat zipfile error", e);
        } finally {
            try {
                if (zos != null) {
                    zos.close();
                }
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                log.error("creat zipfile error", e);
            }

        }
    }

    private static void writeZip(File file, String parentPath, ZipOutputStream zos) {
        if (file.exists()) {
            if (file.isDirectory()) {// 处理文件夹
                parentPath += file.getName() + File.separator;
                File[] files = file.listFiles();
                if (files != null && files.length != 0) {
                    for (File f : files) {
                        writeZip(f, parentPath, zos);
                    }
                } else { // 空目录则创建当前目录
                    try {
                        zos.putNextEntry(new ZipEntry(parentPath));
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            } else {
                FileInputStream fis = null;
                try {
                    fis = new FileInputStream(file);
                    ZipEntry ze = new ZipEntry(parentPath + file.getName());
                    zos.putNextEntry(ze);
                    byte[] content = new byte[1024];
                    int len = -1;
                    log.debug(String.valueOf(len));
                    while ((len = fis.read(content)) != -1) {
                        zos.write(content, 0, len);
                        zos.flush();
                    }

                } catch (FileNotFoundException e) {
                    log.error("creat zipfile error", e);
                } catch (IOException e) {
                    log.error("creat zipfile error", e);
                } finally {
                    try {
                        if (fis != null) {
                            fis.close();
                        }
                    } catch (IOException e) {
                        log.error("creat zipfile error", e);
                    }
                }
            }
        }
    }

    private static void createDirIfNotExists(String destPath, String entryName) {
        String destPath2 = FileUtil.verifyNonNullString(destPath + File.separator + entryName);
        if (destPath2 != null) {
            File file = new File(destPath2);
            if (!file.exists()) {
                boolean success = file.mkdirs();
                if (!success) {
                    log.info("mkdir error,path:" + file);
                }
            }
        }
    }

    /**
     * @param zipFileName
     * @param destPath
     * @return 解压文件的根目录
     */
    public static File unZip(String zipFileName, String destPath) {

        zipFileName = FileUtil.verifyNonNullString(zipFileName);
        destPath = FileUtil.verifyNonNullString(destPath);
        if (zipFileName == null || zipFileName.length() <= 0) {
            log.warn("zipFileName is empty!");
            return null;
        }
        if (destPath == null || destPath.length() <= 0) {
            log.warn("destPath is empty!");
            return null;
        }

        FileInputStream fin = null;
        ZipInputStream in = null;
        FileOutputStream os = null;
        try {
            String zipFileName1 = FileUtil.verifyNonNullString(zipFileName);
            fin = new FileInputStream(zipFileName1);
            in = new ZipInputStream(fin);
            // ZIP 文件条目
            ZipEntry entry;

            while ((entry = in.getNextEntry()) != null) {
                String entryName = entry.getName();
                // 判断是否为目录条目，目录条目定义为其名称以 '/'
                // 结尾的条目。
                entryName = FilenameUtils.normalize(entryName);
                if (entry.isDirectory()) {
                    createDirIfNotExists(destPath, entryName);
                } else {
                    // 如果压缩包存在路径conf/explain.xml，存在conf文件夹，但java读取不到conf文件夹，而是直接读取其中的文件。我们要先判断conf文件夹是否已经
                    // 创建，如果没有必须先建立conf，否则解压失败
                    String path = destPath + File.separator + entryName;
                    /**
                     * 下面两行代码是为了屏蔽掉路径中的"/"，统一为"\",
                     */
                    String path2 = FileUtil.verifyNonNullString(path);
                    if (path2 != null) {
                        File file = new File(path2);
                        String tempPath = file.getPath();

                        tempPath = tempPath.substring(0, tempPath.lastIndexOf(File.separator));
                        String tempPath2 = FileUtil.verifyNonNullString(tempPath);
                        if (tempPath2 != null) {
                            File tempFile = new File(tempPath2);
                            if (!tempFile.exists()) {
                                boolean success = tempFile.mkdirs();
                                if (!success) {
                                    log.info("mkdir error,path:");
                                }
                            }
                        }
                    }
                    String destPath2 = FileUtil.verifyNonNullString(destPath + File.separator + entryName);
                    if (destPath2 != null) {
                        os = new FileOutputStream(destPath2);
                        // Transfer bytes from the ZIP
                        // file to the output file
                        byte[] buf = new byte[1024];
                        int len = 0;
                        log.debug(String.valueOf(len));
                        while ((len = in.read(buf)) > 0) {
                            os.write(buf, 0, len);
                        }
                        os.close();
                        in.closeEntry();
                    }
                    //fin.close();
                }
            }
            return new File(destPath);
        } catch (IOException e) {
            log.error(e.getMessage(), e);
        } finally {
            closeFileResource(fin, in, os);
        }
        return null;
    }

    /**
     * 计算ZIP文件的解压大小
     *
     * @param inputStream 输入流
     *                    注：输入流由调用方负责关闭
     * @return 解压大小
     */
    public static long getUncompressedSize(InputStream inputStream) throws IOException {
        ZipInputStream zipInputStream = new ZipInputStream(inputStream, Charset.forName("GBK"));
        byte[] buffer = new byte[8 * 1024 * 1024];
        long uncompressedSize = 0;
        ZipEntry zipEntry;
        while ((zipEntry = zipInputStream.getNextEntry()) != null) {
            long size = zipEntry.getSize();
            // ZipEntry的size可能为-1，表示未知
            if (size == -1) {
                int len;
                while ((len = zipInputStream.read(buffer, 0, buffer.length)) != -1) {
                    uncompressedSize += len;
                }
            } else {
                uncompressedSize += size;
            }
            zipInputStream.closeEntry();
        }
        return uncompressedSize;
    }

    private static void closeFileResource(FileInputStream fin, ZipInputStream in, FileOutputStream os) {
        if (fin != null) {
            try {
                fin.close();
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }

        }
        if (in != null) {
            try {
                in.close();
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }

        }
        if (os != null) {
            try {
                os.close();
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }

        }
    }

}