使用apache.commons.compress对文件进行压缩与解压缩的不同方式

使用apache.commons.compress对文件进行压缩与解压缩的不同方式

依赖

		<dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-compress</artifactId>
            <version>1.21</version>
        </dependency>

话不多说，直接上代码

package com.common.utils;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.compress.archivers.ArchiveEntry;
import org.apache.commons.compress.archivers.ArchiveInputStream;
import org.apache.commons.compress.archivers.ArchiveOutputStream;
import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream;
import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
import org.apache.commons.compress.archivers.zip.ZipArchiveInputStream;
import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream;
import org.apache.commons.compress.compressors.gzip.GzipCompressorOutputStream;
import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream;
import org.apache.commons.compress.compressors.lz4.FramedLZ4CompressorInputStream;
import org.apache.commons.compress.compressors.lz4.FramedLZ4CompressorOutputStream;
import org.apache.commons.compress.compressors.snappy.FramedSnappyCompressorInputStream;
import org.apache.commons.compress.compressors.snappy.FramedSnappyCompressorOutputStream;
import org.apache.commons.compress.utils.IOUtils;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.*;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Objects;
import java.util.zip.*;

/**
 * 公用压缩工具类，支持Gzip、Zip、Tar、LZ4、Snappy、Deflater压缩算法
 *
 * @description:
 * @author: 
 * @date: 2024/03/29 21:40
 */
@Slf4j
public class CommonsCompressUtil {

    public static class Gzip {
        /**
         * 将文件压缩成gzip
         *
         * @param sourceFile 源文件，如：archive.tar
         * @return 输入流
         */
        public static InputStream compress(byte[] sourceFile) {
            long d1 = System.currentTimeMillis();
            ByteArrayOutputStream compressedOutput = new ByteArrayOutputStream();
            try {
                ByteArrayInputStream sourceInput = new ByteArrayInputStream(sourceFile);
                GzipCompressorOutputStream gzOut = new GzipCompressorOutputStream(compressedOutput);

                int buffersize = 10240;
                final byte[] buffer = new byte[buffersize];
                int n;
                while (-1 != (n = sourceInput.read(buffer))) {
                    gzOut.write(buffer, 0, n);
                }
                gzOut.finish(); // 确保所有数据都被压缩并刷新到底层输出流

            } catch (IOException e) {
                log.info("压缩失败，原因：{}", e.getMessage());
            }
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(compressedOutput.toByteArray());
            log.info("压缩完毕，耗时：{}ms,", (System.currentTimeMillis() - d1));
            return byteArrayInputStream;
        }

        /**
         * 将gzip文件解压缩
         *
         * @param sourceFile 源文件，如：archive.tar.gzip
         * @return 输入流
         */
        public static InputStream uncompress(byte[] sourceFile) {
            long d1 = System.currentTimeMillis();
            ByteArrayInputStream compressedInput = new ByteArrayInputStream(sourceFile);
            ByteArrayOutputStream decompressedOutput = new ByteArrayOutputStream();
            try {
                GzipCompressorInputStream gzIn = new GzipCompressorInputStream(compressedInput);
                byte[] buffer = new byte[1024];
                int n;
                while (-1 != (n = gzIn.read(buffer))) {
                    decompressedOutput.write(buffer, 0, n);
                }
            } catch (Exception e) {
                log.info("解压缩失败，原因：{}", e.getMessage());
            }
            // 返回 ByteArrayInputStream 包装的解压数据
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(decompressedOutput.toByteArray());
            log.info("压缩完毕，耗时：{}ms,", (System.currentTimeMillis() - d1));
            return byteArrayInputStream;
        }
    }

    public static class LZ4 {
        /**
         * 将文件压缩成LZ4文件
         *
         * @param sourceFile 源文件，如：archive.tar
         */
        public static InputStream compress(byte[] sourceFile) {
            long d1 = System.currentTimeMillis();
            ByteArrayInputStream compressedInput = new ByteArrayInputStream(sourceFile);
            ByteArrayOutputStream decompressedOutput = new ByteArrayOutputStream();
            try (
                    FramedLZ4CompressorOutputStream lzOut = new FramedLZ4CompressorOutputStream(decompressedOutput);) {
                int buffersize = 10240;
                final byte[] buffer = new byte[buffersize];
                int n = 0;
                while (-1 != (n = compressedInput.read(buffer))) {
                    lzOut.write(buffer, 0, n);
                }
            } catch (IOException e) {
                log.info("压缩失败，原因：{}", e.getMessage());
            }
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(decompressedOutput.toByteArray());
            log.info("压缩完毕，耗时：{}ms,", (System.currentTimeMillis() - d1));
            return byteArrayInputStream;
        }

        /**
         * 将LZ4文件进行解压
         *
         * @param sourceFile 源文件，如：archive.tar.lz4
         */
        public static InputStream uncompress(byte[] sourceFile) {
            long d1 = System.currentTimeMillis();
            ByteArrayInputStream compressedInput = new ByteArrayInputStream(sourceFile);
            ByteArrayOutputStream decompressedOutput = new ByteArrayOutputStream();
            try (
                    FramedLZ4CompressorInputStream zIn = new FramedLZ4CompressorInputStream(compressedInput);) {
                int buffersize = 10240;
                final byte[] buffer = new byte[buffersize];
                int n = 0;
                while (-1 != (n = zIn.read(buffer))) {
                    decompressedOutput.write(buffer, 0, n);
                }
            } catch (IOException e) {
                log.info("解压缩失败，原因：{}", e.getMessage());
            }
            // 返回 ByteArrayInputStream 包装的解压数据
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(decompressedOutput.toByteArray());
            log.info("压缩完毕，耗时：{}ms,", (System.currentTimeMillis() - d1));
            return byteArrayInputStream;
        }
    }

    public static class Snappy {
        /**
         * 将文件压缩成sz
         *
         * @param sourceFile 源文件，如：archive.tar
         */
        public static InputStream compress(byte[] sourceFile) {
            long d1 = System.currentTimeMillis();
            ByteArrayInputStream compressedInput = new ByteArrayInputStream(sourceFile);
            ByteArrayOutputStream decompressedOutput = new ByteArrayOutputStream();
            try (
                    FramedSnappyCompressorOutputStream snOut = new FramedSnappyCompressorOutputStream(decompressedOutput);) {
                int buffersize = 10240;
                final byte[] buffer = new byte[buffersize];
                int n = 0;
                while (-1 != (n = compressedInput.read(buffer))) {
                    snOut.write(buffer, 0, n);
                }
            } catch (IOException e) {
                log.info("压缩失败，原因：{}", e.getMessage());
            }
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(decompressedOutput.toByteArray());
            log.info("压缩完毕，耗时：{}ms,", (System.currentTimeMillis() - d1));
            return byteArrayInputStream;
        }

        /**
         * 将sz文件解压
         *
         * @param sourceFile 源文件，如：archive.tar.sz
         */
        public static InputStream uncompress(byte[] sourceFile) {
            long d1 = System.currentTimeMillis();
            ByteArrayInputStream compressedInput = new ByteArrayInputStream(sourceFile);
            ByteArrayOutputStream decompressedOutput = new ByteArrayOutputStream();
            try (
                    FramedSnappyCompressorInputStream zIn = new FramedSnappyCompressorInputStream(compressedInput);) {
                int buffersize = 10240;
                final byte[] buffer = new byte[buffersize];
                int n = 0;
                while (-1 != (n = zIn.read(buffer))) {
                    decompressedOutput.write(buffer, 0, n);
                }
            } catch (IOException e) {
                log.info("解压缩失败，原因：{}", e.getMessage());
            }
            // 返回 ByteArrayInputStream 包装的解压数据
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(decompressedOutput.toByteArray());
            log.info("压缩完毕，耗时：{}ms,", (System.currentTimeMillis() - d1));
            return byteArrayInputStream;
        }
    }

    public static class Zip {
        /**
         * 将文件压缩成zip
         *
         * @param sourceFile 源文件或目录，如：archive.tar
         * @param targetFile 目标文件，如：archive.tar.zip
         */
        public static void compress(String sourceFile, String targetFile) {
            long d1 = System.currentTimeMillis();
            ByteArrayOutputStream fos = new ByteArrayOutputStream();
            ZipArchiveOutputStream bos = new ZipArchiveOutputStream(fos);
            try (ArchiveOutputStream aos = new ZipArchiveOutputStream(bos);) {
                Path dirPath = Paths.get(sourceFile);
                Files.walkFileTree(dirPath, new SimpleFileVisitor<Path>() {
                    @Override
                    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                        ArchiveEntry entry = new ZipArchiveEntry(dir.toFile(), dirPath.relativize(dir).toString());
                        aos.putArchiveEntry(entry);
                        aos.closeArchiveEntry();
                        return super.preVisitDirectory(dir, attrs);
                    }

                    @Override
                    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                        ArchiveEntry entry = new ZipArchiveEntry(
                                file.toFile(), dirPath.relativize(file).toString());
                        aos.putArchiveEntry(entry);
                        IOUtils.copy(new FileInputStream(file.toFile()), aos);
                        aos.closeArchiveEntry();
                        return super.visitFile(file, attrs);
                    }
                });
            } catch (IOException e) {
                System.out.println("压缩失败，原因：" + e.getMessage());
            }
            System.out.println("压缩完毕，耗时：" + (System.currentTimeMillis() - d1) + " ms");
        }

        /**
         * 将zip文件解压到指定目录
         *
         * @param zipPath 源文件，如：archive.zip
         * @param descDir 解压目录
         */
        public static void uncompress(String zipPath, String descDir) {
            long d1 = System.currentTimeMillis();
            try (InputStream fis = Files.newInputStream(Paths.get(zipPath));
                 InputStream bis = new BufferedInputStream(fis);
                 ArchiveInputStream ais = new ZipArchiveInputStream(bis);
            ) {
                ArchiveEntry entry;
                while (Objects.nonNull(entry = ais.getNextEntry())) {
                    if (!ais.canReadEntryData(entry)) {
                        continue;
                    }
                    String name = descDir + File.separator + entry.getName();
                    File f = new File(name);
                    if (entry.isDirectory()) {
                        if (!f.isDirectory() && !f.mkdirs()) {
                            f.mkdirs();
                        }
                    } else {
                        File parent = f.getParentFile();
                        if (!parent.isDirectory() && !parent.mkdirs()) {
                            throw new IOException("failed to create directory " + parent);
                        }
                        try (OutputStream o = Files.newOutputStream(f.toPath())) {
                            IOUtils.copy(ais, o);
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("解压失败，原因：" + e.getMessage());
            }
            System.out.println("解压完毕，耗时：" + (System.currentTimeMillis() - d1) + " ms");
        }

    }

    public static class Tar {
        /**
         * 将文件压缩成tar
         *
         * @param sourceFile 源文件或目录，如：archive
         * @param targetFile 目标文件，如：archive.tar
         */
        public static void compress(String sourceFile, String targetFile) {
            long d1 = System.currentTimeMillis();
            try (OutputStream fos = new FileOutputStream(targetFile);
                 OutputStream bos = new BufferedOutputStream(fos);
                 ArchiveOutputStream aos = new TarArchiveOutputStream(bos);) {
                Path dirPath = Paths.get(sourceFile);
                Files.walkFileTree(dirPath, new SimpleFileVisitor<Path>() {
                    @Override
                    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                        ArchiveEntry entry = new TarArchiveEntry(dir.toFile(), dirPath.relativize(dir).toString());
                        aos.putArchiveEntry(entry);
                        aos.closeArchiveEntry();
                        return super.preVisitDirectory(dir, attrs);
                    }

                    @Override
                    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                        ArchiveEntry entry = new TarArchiveEntry(
                                file.toFile(), dirPath.relativize(file).toString());
                        aos.putArchiveEntry(entry);
                        IOUtils.copy(new FileInputStream(file.toFile()), aos);
                        aos.closeArchiveEntry();
                        return super.visitFile(file, attrs);
                    }
                });
            } catch (IOException e) {
                System.out.println("压缩失败，原因：" + e.getMessage());
            }
            System.out.println("压缩完毕，耗时：" + (System.currentTimeMillis() - d1) + " ms");
        }

        /**
         * 将tar文件解压到指定目录
         *
         * @param tarPath 源文件，如：archive.tar
         * @param descDir 解压目录
         */
        public static void uncompress(String tarPath, String descDir) {
            long d1 = System.currentTimeMillis();
            try (InputStream fis = Files.newInputStream(Paths.get(tarPath));
                 InputStream bis = new BufferedInputStream(fis);
                 ArchiveInputStream ais = new TarArchiveInputStream(bis);
            ) {
                ArchiveEntry entry;
                while (Objects.nonNull(entry = ais.getNextEntry())) {
                    if (!ais.canReadEntryData(entry)) {
                        continue;
                    }
                    String name = descDir + File.separator + entry.getName();
                    File f = new File(name);
                    if (entry.isDirectory()) {
                        if (!f.isDirectory() && !f.mkdirs()) {
                            f.mkdirs();
                        }
                    } else {
                        File parent = f.getParentFile();
                        if (!parent.isDirectory() && !parent.mkdirs()) {
                            throw new IOException("failed to create directory " + parent);
                        }
                        try (OutputStream o = Files.newOutputStream(f.toPath())) {
                            IOUtils.copy(ais, o);
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("解压失败，原因：" + e.getMessage());
            }
            System.out.println("解压完毕，耗时：" + (System.currentTimeMillis() - d1) + " ms");
        }
    }



    public static class Deflaters {
   
        public static InputStream compress(byte[] data) throws IOException {
            // 创建一个ByteArrayOutputStream来存储压缩后的数据
            ByteArrayOutputStream compressedDataStream = new ByteArrayOutputStream();

            // 创建一个DeflaterOutputStream来压缩数据
            // 这里使用了最佳压缩级别（Deflater.BEST_COMPRESSION）
            try (DeflaterOutputStream deflaterOutputStream = new DeflaterOutputStream(compressedDataStream, new Deflater(Deflater.BEST_COMPRESSION))) {
                // 将数据写入DeflaterOutputStream进行压缩
                deflaterOutputStream.write(data);
                // 完成压缩操作
                deflaterOutputStream.finish();
                // 刷新输出流，确保所有数据都已经被写出
                deflaterOutputStream.flush();
            }

            // 将压缩后的数据封装为ByteArrayInputStream，这样就可以作为InputStream使用
            InputStream compressedInputStream = new ByteArrayInputStream(compressedDataStream.toByteArray());

            // 返回压缩后的InputStream
            return compressedInputStream;
        }

        public static InputStream uncompress(byte[] compressedData) throws IOException {
            // 创建一个ByteArrayOutputStream来存储解压缩后的数据
            ByteArrayOutputStream decompressedDataStream = new ByteArrayOutputStream();

            // 创建一个InflaterInputStream来解压缩数据
            try (InflaterInputStream inflaterInputStream = new InflaterInputStream(new ByteArrayInputStream(compressedData), new Inflater())) {
                // 创建一个缓冲区来读取解压缩的数据
                byte[] buffer = new byte[1024];
                int len;
                // 读取解压缩的数据到缓冲区，直到没有更多的数据
                while ((len = inflaterInputStream.read(buffer)) > 0) {
                    // 将缓冲区的数据写入ByteArrayOutputStream
                    decompressedDataStream.write(buffer, 0, len);
                }
            }

            // 将解压缩后的数据封装为ByteArrayInputStream，这样就可以作为InputStream使用
            InputStream decompressedInputStream = new ByteArrayInputStream(decompressedDataStream.toByteArray());

            // 返回解压缩后的InputStream
            return decompressedInputStream;
        }
    }


}