Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.dahuatech.hutool.core.util.ZipUtil Maven / Gradle / Ivy
package com.dahuatech.hutool.core.util;
import com.dahuatech.hutool.core.exceptions.UtilException;
import com.dahuatech.hutool.core.io.FastByteArrayOutputStream;
import com.dahuatech.hutool.core.io.FileUtil;
import com.dahuatech.hutool.core.io.IORuntimeException;
import com.dahuatech.hutool.core.io.IoUtil;
import java.io.*;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.zip.*;
/**
* 压缩工具类
*
* @author Looly
*/
public class ZipUtil {
private static final int DEFAULT_BYTE_ARRAY_LENGTH = 32;
/** 默认编码，使用平台相关编码 */
private static final Charset DEFAULT_CHARSET = CharsetUtil.defaultCharset();
/**
* 打包到当前目录，使用默认编码UTF-8
*
* @param srcPath 源文件路径
* @return 打包好的压缩文件
* @throws UtilException IO异常
*/
public static File zip(String srcPath) throws UtilException {
return zip(srcPath, DEFAULT_CHARSET);
}
/**
* 打包到当前目录
*
* @param srcPath 源文件路径
* @param charset 编码
* @return 打包好的压缩文件
* @throws UtilException IO异常
*/
public static File zip(String srcPath, Charset charset) throws UtilException {
return zip(FileUtil.file(srcPath), charset);
}
/**
* 打包到当前目录，使用默认编码UTF-8
*
* @param srcFile 源文件或目录
* @return 打包好的压缩文件
* @throws UtilException IO异常
*/
public static File zip(File srcFile) throws UtilException {
return zip(srcFile, DEFAULT_CHARSET);
}
/**
* 打包到当前目录
*
* @param srcFile 源文件或目录
* @param charset 编码
* @return 打包好的压缩文件
* @throws UtilException IO异常
*/
public static File zip(File srcFile, Charset charset) throws UtilException {
final File zipFile =
FileUtil.file(srcFile.getParentFile(), FileUtil.mainName(srcFile) + ".zip");
zip(zipFile, charset, false, srcFile);
return zipFile;
}
/**
* 对文件或文件目录进行压缩 em = (Enumeration) zipFile.entries();
ZipEntry zipEntry;
File outItemFile;
while (em.hasMoreElements()) {
zipEntry = em.nextElement();
// FileUtil.file会检查slip漏洞，漏洞说明见http://blog.nsfocus.net/zip-slip-2/
outItemFile = buildFile(outFile, zipEntry.getName());
if (zipEntry.isDirectory()) {
// 创建对应目录
outItemFile.mkdirs();
} else {
// 写出文件
write(zipFile, zipEntry, outItemFile);
}
}
} finally {
IoUtil.close(zipFile);
}
return outFile;
}
/**
* 解压 em = (Enumeration) zipFileObj.entries();
ZipEntry zipEntry;
while (em.hasMoreElements()) {
zipEntry = em.nextElement();
if ((false == zipEntry.isDirectory()) && name.equals(zipEntry.getName())) {
return IoUtil.readBytes(zipFileObj.getInputStream(zipEntry));
}
}
} catch (IOException e) {
throw new UtilException(e);
} finally {
IoUtil.close(zipFileObj);
}
return null;
}
// ----------------------------------------------------------------------------- Gzip
/**
* Gzip压缩处理
*
* @param content 被压缩的字符串
* @param charset 编码
* @return 压缩后的字节流
* @throws UtilException IO异常
*/
public static byte[] gzip(String content, String charset) throws UtilException {
return gzip(StrUtil.bytes(content, charset));
}
/**
* Gzip压缩处理
*
* @param buf 被压缩的字节流
* @return 压缩后的字节流
* @throws UtilException IO异常
*/
public static byte[] gzip(byte[] buf) throws UtilException {
return gzip(new ByteArrayInputStream(buf), buf.length);
}
/**
* Gzip压缩文件
*
* @param file 被压缩的文件
* @return 压缩后的字节流
* @throws UtilException IO异常
*/
public static byte[] gzip(File file) throws UtilException {
BufferedInputStream in = null;
try {
in = FileUtil.getInputStream(file);
return gzip(in, (int) file.length());
} finally {
IoUtil.close(in);
}
}
/**
* Gzip压缩文件
*
* @param in 被压缩的流
* @return 压缩后的字节流
* @throws UtilException IO异常
* @since 4.1.18
*/
public static byte[] gzip(InputStream in) throws UtilException {
return gzip(in, DEFAULT_BYTE_ARRAY_LENGTH);
}
/**
* Gzip压缩文件
*
* @param in 被压缩的流
* @param length 预估长度
* @return 压缩后的字节流
* @throws UtilException IO异常
* @since 4.1.18
*/
public static byte[] gzip(InputStream in, int length) throws UtilException {
final ByteArrayOutputStream bos = new ByteArrayOutputStream(length);
GZIPOutputStream gos = null;
try {
gos = new GZIPOutputStream(bos);
IoUtil.copy(in, gos);
} catch (IOException e) {
throw new UtilException(e);
} finally {
IoUtil.close(gos);
}
// 返回必须在关闭gos后进行，因为关闭时会自动执行finish()方法，保证数据全部写出
return bos.toByteArray();
}
/**
* Gzip解压缩处理
*
* @param buf 压缩过的字节流
* @param charset 编码
* @return 解压后的字符串
* @throws UtilException IO异常
*/
public static String unGzip(byte[] buf, String charset) throws UtilException {
return StrUtil.str(unGzip(buf), charset);
}
/**
* Gzip解压处理
*
* @param buf buf
* @return bytes
* @throws UtilException IO异常
*/
public static byte[] unGzip(byte[] buf) throws UtilException {
return unGzip(new ByteArrayInputStream(buf), buf.length);
}
/**
* Gzip解压处理
*
* @param in Gzip数据
* @return 解压后的数据
* @throws UtilException IO异常
*/
public static byte[] unGzip(InputStream in) throws UtilException {
return unGzip(in, DEFAULT_BYTE_ARRAY_LENGTH);
}
/**
* Gzip解压处理
*
* @param in Gzip数据
* @param length 估算长度，如果无法确定请传入{@link #DEFAULT_BYTE_ARRAY_LENGTH}
* @return 解压后的数据
* @throws UtilException IO异常
* @since 4.1.18
*/
public static byte[] unGzip(InputStream in, int length) throws UtilException {
GZIPInputStream gzi = null;
FastByteArrayOutputStream bos;
try {
gzi = (in instanceof GZIPInputStream) ? (GZIPInputStream) in : new GZIPInputStream(in);
bos = new FastByteArrayOutputStream(length);
IoUtil.copy(gzi, bos);
} catch (IOException e) {
throw new UtilException(e);
} finally {
IoUtil.close(gzi);
}
// 返回必须在关闭gos后进行，因为关闭时会自动执行finish()方法，保证数据全部写出
return bos.toByteArray();
}
// ----------------------------------------------------------------------------- Zlib
/**
* Zlib压缩处理
*
* @param content 被压缩的字符串
* @param charset 编码
* @param level 压缩级别，1~9
* @return 压缩后的字节流
* @since 4.1.4
*/
public static byte[] zlib(String content, String charset, int level) {
return zlib(StrUtil.bytes(content, charset), level);
}
/**
* Zlib压缩文件
*
* @param file 被压缩的文件
* @param level 压缩级别
* @return 压缩后的字节流
* @since 4.1.4
*/
public static byte[] zlib(File file, int level) {
BufferedInputStream in = null;
try {
in = FileUtil.getInputStream(file);
return zlib(in, level, (int) file.length());
} finally {
IoUtil.close(in);
}
}
/**
* 打成Zlib压缩包
*
* @param buf 数据
* @param level 压缩级别，0~9
* @return 压缩后的bytes
* @since 4.1.4
*/
public static byte[] zlib(byte[] buf, int level) {
return zlib(new ByteArrayInputStream(buf), level, buf.length);
}
/**
* 打成Zlib压缩包
*
* @param in 数据流
* @param level 压缩级别，0~9
* @return 压缩后的bytes
* @since 4.1.19
*/
public static byte[] zlib(InputStream in, int level) {
return zlib(in, level, DEFAULT_BYTE_ARRAY_LENGTH);
}
/**
* 打成Zlib压缩包
*
* @param in 数据流
* @param level 压缩级别，0~9
* @param length 预估大小
* @return 压缩后的bytes
* @since 4.1.19
*/
public static byte[] zlib(InputStream in, int level, int length) {
final ByteArrayOutputStream out = new ByteArrayOutputStream(length);
deflater(in, out, level, false);
return out.toByteArray();
}
/**
* Zlib解压缩处理
*
* @param buf 压缩过的字节流
* @param charset 编码
* @return 解压后的字符串
* @since 4.1.4
*/
public static String unZlib(byte[] buf, String charset) {
return StrUtil.str(unZlib(buf), charset);
}
/**
* 解压缩zlib
*
* @param buf 数据
* @return 解压后的bytes
* @since 4.1.4
*/
public static byte[] unZlib(byte[] buf) {
return unZlib(new ByteArrayInputStream(buf), buf.length);
}
/**
* 解压缩zlib
*
* @param in 数据流
* @return 解压后的bytes
* @since 4.1.19
*/
public static byte[] unZlib(InputStream in) {
return unZlib(in, DEFAULT_BYTE_ARRAY_LENGTH);
}
/**
* 解压缩zlib
*
* @param in 数据流
* @param length 预估长度
* @return 解压后的bytes
* @since 4.1.19
*/
public static byte[] unZlib(InputStream in, int length) {
final ByteArrayOutputStream out = new ByteArrayOutputStream(length);
inflater(in, out, false);
return out.toByteArray();
}
/**
* 获取Zip文件中指定目录下的所有文件，只显示文件，不显示目录
*
* @param zipFile Zip文件
* @param dir 目录前缀
* @return 文件列表
* @since 4.6.6
*/
public static List listFileNames(ZipFile zipFile, String dir) {
if (StrUtil.isNotBlank(dir)) {
// 目录尾部添加"/"
dir = StrUtil.addSuffixIfNot(dir, StrUtil.SLASH);
}
final List fileNames = new ArrayList<>();
String name;
for (ZipEntry entry : Collections.list(zipFile.entries())) {
name = entry.getName();
if (StrUtil.isEmpty(dir) || name.startsWith(dir)) {
final String nameSuffix = StrUtil.removePrefix(name, dir);
if (StrUtil.isNotEmpty(nameSuffix)
&& false == StrUtil.contains(nameSuffix, CharUtil.SLASH)) {
fileNames.add(nameSuffix);
}
}
}
return fileNames;
}
// ----------------------------------------------------------------------------------------------
// Private method start
/**
* 获得 {@link ZipOutputStream}
*
* @param zipFile 压缩文件
* @param charset 编码
* @return {@link ZipOutputStream}
*/
private static ZipOutputStream getZipOutputStream(File zipFile, Charset charset) {
return getZipOutputStream(FileUtil.getOutputStream(zipFile), charset);
}
/**
* 获得 {@link ZipOutputStream}
*
* @param out 压缩文件流
* @param charset 编码
* @return {@link ZipOutputStream}
*/
private static ZipOutputStream getZipOutputStream(OutputStream out, Charset charset) {
return new ZipOutputStream(out, ObjectUtil.defaultIfNull(charset, DEFAULT_CHARSET));
}
/**
* 递归压缩文件夹 pathParts = StrUtil.split(fileName, '/', false, true);
final int lastPartIndex = pathParts.size() - 1; // 目录个数
for (int i = 0; i < lastPartIndex; i++) {
// 由于路径拆分，slip不检查，在最后一步检查
outFile = new File(outFile, pathParts.get(i));
}
//noinspection ResultOfMethodCallIgnored
outFile.mkdirs();
// 最后一个部分如果非空，作为文件名
fileName = pathParts.get(lastPartIndex);
}
return FileUtil.file(outFile, fileName);
}
// ----------------------------------------------------------------------------------------------
// Private method end
}
