ZipUtils之zip处理工具类

/**
 * @Author wzq
 * @Version 1.0
 * @Description //TODO zip处理工具类
 * @Date 2023/1/29
 **/
public class ZipUtils {

    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, boolean KeepDirStructure)
            throws RuntimeException{

        long start = System.currentTimeMillis();
        ZipOutputStream zos = null ;
        try {
            zos = new ZipOutputStream(out);
            File sourceFile = new File(srcDir);
            // 这里打成压缩包 name 默认是一级路径 这边不需要 可以设置为空 如果需要 直接设置为：sourceFile.getName()
            compress(sourceFile,zos,"",KeepDirStructure);
            long end = System.currentTimeMillis();
        } 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();
        } 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()前面需要带上父文件夹的名字加一斜杠,
                        // 不然最后压缩包中就不能保留原来的文件结构,即：所有文件都跑到压缩包根目录下了
                        if (ObjectUtil.isNull(name) || ObjectUtil.isEmpty(name)){
                            compress(file, zos, file.getName(),KeepDirStructure);
                        }
                        else {
                            compress(file, zos, name + "/" + file.getName(),KeepDirStructure);
                        }
                    } else {
                        compress(file, zos, file.getName(),KeepDirStructure);
                    }

                }
            }
        }
    }


    /**
     * zip可用
    * */
    public static void zipFiles(List<String> srcFiles, File zipFile) {
        try {
            if (srcFiles.size() != 0) {
                // 判断压缩后的文件存在不，不存在则创建
                if (!zipFile.exists()) {
                    zipFile.createNewFile();
                } else {
                    zipFile.delete();
                    zipFile.createNewFile();
                }
                // 创建 FileInputStream 对象
                InputStream fileInputStream = null;
                // 实例化 FileOutputStream 对象
                FileOutputStream fileOutputStream = new FileOutputStream(zipFile);
                // 实例化 ZipOutputStream 对象
                ZipOutputStream zipOutputStream = new ZipOutputStream(fileOutputStream);
                // 创建 ZipEntry 对象
                ZipEntry zipEntry = null;
                // 遍历源文件数组
                //第三方公司要求每个图片的命名方式需要和他们一致所以我使用的普通for循环，如没要求可用增强for循环，后缀名可截取图片的地址。
                for (int i = 0; i < srcFiles.size(); i++) {
                    // 将源文件数组中的当前文件读入 FileInputStream 流中
                    URL uri = new URL(srcFiles.get(i));
                    fileInputStream= uri.openStream();
                    // 实例化 ZipEntry 对象，源文件数组中的当前文件
                    //输出压缩前的名称   这里截取 是根据feign 处理的sso-file 的方法处理 图片命名（不跟服务器默认命名规则保持一致）
                    String uriPath = uri.toString().substring(uri.toString().indexOf("-----")+5,uri.toString().length());
                    zipEntry = new ZipEntry(uriPath);
                    zipOutputStream.putNextEntry(zipEntry);
                    // 该变量记录每次真正读的字节个数
                    int len;
                    // 定义每次读取的字节数组
                    byte[] buffer = new byte[1024];
                    while ((len = fileInputStream.read(buffer)) > 0) {
                        zipOutputStream.write(buffer, 0, len);
                    }
                }
                //关闭流
                zipOutputStream.closeEntry();
                zipOutputStream.close();
                fileInputStream.close();
                fileOutputStream.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void toZipByResponse(List<String> pathList, HttpServletResponse response,String touristName) throws IOException{
        //压缩操作
        if(ObjectUtil.isEmpty(touristName)){
            touristName = System.currentTimeMillis()+"";
        }
        //文件的名称
        String downloadFilename = touristName + ".zip";
        //转换中文否则可能会产生乱码
        downloadFilename = URLEncoder.encode(downloadFilename, "UTF-8");
        // 指明response的返回对象是文件流
        response.setContentType("application/octet-stream");
        // 设置在下载框默认显示的文件名
        response.setHeader("Content-Disposition", "attachment;filename=" + downloadFilename);
        //response.setCharacterEncoding("utf-8");
        ZipOutputStream zipOutputStream = null;

        try {
            zipOutputStream = new ZipOutputStream(response.getOutputStream());
            for (String pictureUrl : pathList) {
                //String fileName = pictureUrl.substring(pictureUrl.lastIndexOf("/") + 1);
                URL url = new URL(pictureUrl);
                //输出压缩前的名称   这里截取 是根据feign 处理的sso-file 的方法处理 图片命名（不跟服务器默认命名规则保持一致）
                String uriPath = url.toString().substring(url.toString().indexOf("-----")+5,url.toString().length());
                zipOutputStream.putNextEntry(new ZipEntry(uriPath));
                InputStream inputStream = new DataInputStream(url.openStream());

                byte[] buff = new byte[1024];
                int len;
                while ((len = inputStream.read(buff)) != -1) {
                    zipOutputStream.write(buff, 0, len);
                }
                zipOutputStream.closeEntry();
                inputStream.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (zipOutputStream != null) {
                try {
                    zipOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }