使用Java生成的ZIP压缩包解压时出现不可预料的压缩文件末端的解决方案
 
 
 
问题描述：
 
如下图所示，在解压Java程序生成的ZIP压缩包时出现不可预料的压缩文件末端，
 
 
 
 
问题分袖：
 
出现上面的情况，大概有两种情况，第一种是输出流没有关闭，第二种是输出流关闭顺序不正确。在写程序时一定要注意使用流完毕后一定要关闭，要不然输出的文件可能是不完整或者损坏的，再者如果关闭输出流的顺序不正确的话也会造成文件损坏或不完整。
 
 
 
解决方案：
 
检查程序输出流是否关闭或者是否关闭顺序正确
 
 
进入视线压缩的代码：
 
 
从上面代码可以看出应该先打开的流后关闭，后打开的流先关闭，继续看下去，
 
 
从代码中看出是关闭可输出流，但是关闭的顺序写错了，应该先关闭ZipOutputStream，后关闭OutputStream，
 
修改过后重新运行，问题解决
 
 
 
 
总结：巩固基础很重要。
 

在pom中添加解压jar依赖
 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.hf</groupId>
    <artifactId>uncompress</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>uncompress</name>
    <description>上传压缩文件(rar或者zip格式),解压</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <!--
        从Zip文件创建，添加，提取，更新，删除文件
        读/写密码保护的Zip文件
        支持AES 128/256加密
        支持标准邮​​编加密
        支持Zip64格式
        支持存储（无压缩）和Deflate压缩方法
        从Split Zip文件创建或提取文件（例如：z01，z02，... zip）
        支持Unicode文件名
        进度监视器
        -->
        <!--zip4j依赖,解压zip压缩-->
        <dependency>
            <groupId>net.lingala.zip4j</groupId>
            <artifactId>zip4j</artifactId>
            <version>1.3.2</version>
        </dependency>

        <!--解压rar压缩-->
        <dependency>
            <groupId>com.github.junrar</groupId>
            <artifactId>junrar</artifactId>
            <version>0.7</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
 
解压zip/rar的工具类
 
package com.hf.uncompress.utils;

import com.github.junrar.Archive;
import com.github.junrar.rarfile.FileHeader;
import lombok.extern.slf4j.Slf4j;
import net.lingala.zip4j.core.ZipFile;

import java.io.File;
import java.io.FileOutputStream;

/**
 * @Description: 解压rar/zip工具类
 * @Date: 2019/1/22
 * @Auther:
 */
@Slf4j
public class UnPackeUtil {

    /**
     * zip文件解压
     *
     * @param destPath 解压文件路径
     * @param zipFile  压缩文件
     * @param password 解压密码(如果有)
     */
    public static void unPackZip(File zipFile, String password, String destPath) {
        try {
            ZipFile zip = new ZipFile(zipFile);
            /*zip4j默认用GBK编码去解压,这里设置编码为GBK的*/
            zip.setFileNameCharset("GBK");
            log.info("begin unpack zip file....");
            zip.extractAll(destPath);
            // 如果解压需要密码
            if (zip.isEncrypted()) {
                zip.setPassword(password);
            }
        } catch (Exception e) {
            log.error("unPack zip file to " + destPath + " fail ....", e.getMessage(), e);
        }
    }

    /**
     * rar文件解压(不支持有密码的压缩包)
     *
     * @param rarFile  rar压缩包
     * @param destPath 解压保存路径
     */
    public static void unPackRar(File rarFile, String destPath) {
        try (Archive archive = new Archive(rarFile)) {
            if (null != archive) {
                FileHeader fileHeader = archive.nextFileHeader();
                File file = null;
                while (null != fileHeader) {
                    // 防止文件名中文乱码问题的处理
                    String fileName = fileHeader.getFileNameW().isEmpty() ? fileHeader.getFileNameString() : fileHeader.getFileNameW();
                    if (fileHeader.isDirectory()) {
                        //是文件夹
                        file = new File(destPath + File.separator + fileName);
                        file.mkdirs();
                    } else {
                        //不是文件夹
                        file = new File(destPath + File.separator + fileName.trim());
                        if (!file.exists()) {
                            if (!file.getParentFile().exists()) {
                                // 相对路径可能多级，可能需要创建父目录.
                                file.getParentFile().mkdirs();
                            }
                            file.createNewFile();
                        }
                        FileOutputStream os = new FileOutputStream(file);
                        archive.extractFile(fileHeader, os);
                        os.close();
                    }
                    fileHeader = archive.nextFileHeader();
                }
            }
        } catch (Exception e) {
            log.error("unpack rar file fail....", e.getMessage(), e);
        }
    }
}
 
页面HTML
 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

    <script src="./jquery-3.2.1.min.js" type="text/javascript"></script>
    <!--<script type="text/javascript">
        $("#ok").click(function () {
            alert(1);
        });
    </script>-->
</head>
<body>
<form action="/user/upload/zip" method="post" enctype="multipart/form-data">
    上传压缩包:<input type="file" name="zipFile"/>
    解压路径:<input type="text" name="destPath"/>
    解压密码(为空可不传):<input type="text" name="password"/></br>
    <button id="ok" value="测试"></button>

    <input type="submit" value="执行操作"/>
</form>
</body>

</html>
 
controller代码:
 
package com.hf.uncompress.controller;

import com.hf.uncompress.Result.AjaxList;
import com.hf.uncompress.service.FileUploadService;
import com.hf.uncompress.vo.PackParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

/**
 * @Description:
 * @Date: 2019/1/22
 * @Auther: 
 */

@Controller
@RequestMapping("/user")
@Slf4j
public class FileUploadController {

    @Autowired
    private FileUploadService fileUploadService;

    @GetMapping("/redirect")
    public String redirectHtml() {
        return "work";
    }

    @PostMapping("/upload/zip")
    @ResponseBody
    public String uploadZip(MultipartFile zipFile, @RequestBody PackParam packParam) {
        AjaxList<String> ajaxList = fileUploadService.handlerUpload(zipFile, packParam);
        return ajaxList.getData();
    }
}
 
service实现类代码
 
package com.hf.uncompress.service.impl;

import com.hf.uncompress.Result.AjaxList;
import com.hf.uncompress.enums.FileTypeEnum;
import com.hf.uncompress.service.FileUploadService;
import com.hf.uncompress.utils.UnPackeUtil;
import com.hf.uncompress.vo.PackParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;

/**
 * @Description:
 * @Date: 2019/1/22
 * @Auther: 
 */
@Service
@Slf4j
public class FileUploadServiceImpl implements FileUploadService {

    @Override
    public AjaxList<String> handlerUpload(MultipartFile zipFile, PackParam packParam) {

        if (null == zipFile) {
            return AjaxList.createFail("请上传压缩文件!");
        }
        boolean isZipPack = true;
        String fileContentType = zipFile.getContentType();
        //将压缩包保存在指定路径
        String packFilePath = packParam.getDestPath() + File.separator + zipFile.getName();
        if (FileTypeEnum.FILE_TYPE_ZIP.type.equals(fileContentType)) {
            //zip解压缩处理
            packFilePath += FileTypeEnum.FILE_TYPE_ZIP.fileStufix;
        } else if (FileTypeEnum.FILE_TYPE_RAR.type.equals(fileContentType)) {
            //rar解压缩处理
            packFilePath += FileTypeEnum.FILE_TYPE_RAR.fileStufix;
            isZipPack = false;
        } else {
            return AjaxList.createFail("上传的压缩包格式不正确,仅支持rar和zip压缩文件!");
        }
        File file = new File(packFilePath);
        try {
            zipFile.transferTo(file);
        } catch (IOException e) {
            log.error("zip file save to " + packParam.getDestPath() + " error", e.getMessage(), e);
            return AjaxList.createFail("保存压缩文件到:" + packParam.getDestPath() + " 失败!");
        }
        if (isZipPack) {
            //zip压缩包
            UnPackeUtil.unPackZip(file, packParam.getPassword(), packParam.getDestPath());
        } else {
            //rar压缩包
            UnPackeUtil.unPackRar(file, packParam.getDestPath());
        }
        return AjaxList.createSuccess("解压成功");
    }
}
 
使用到的枚举类:
 
package com.hf.uncompress.enums;

import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;

/**
 * @Description: 压缩文件类型
 * @Date: 2019/1/22
 * @Auther:
 */
@AllArgsConstructor
@NoArgsConstructor
public enum FileTypeEnum {
    FILE_TYPE_ZIP("application/zip", ".zip"),
    FILE_TYPE_RAR("application/octet-stream", ".rar");
    public String type;
    public String fileStufix;

    public static String getFileStufix(String type) {
        for (FileTypeEnum orderTypeEnum : FileTypeEnum.values()) {
            if (orderTypeEnum.type.equals(type)) {
                return orderTypeEnum.fileStufix;
            }
        }
        return null;
    }
}
 
同一返回值定义:
 
package com.hf.uncompress.Result;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @Description: 返回值处理
 * @Date: 2019/1/22
 * @Auther: 
 */
@AllArgsConstructor
@NoArgsConstructor
@Data
public class AjaxList<T> {
    private boolean isSuccess;
    private T data;

    public static <T> AjaxList<T> createSuccess(T data) {
        return new AjaxList<T>(true, data);
    }

    public static <T> AjaxList<T> createFail(T data) {
        return new AjaxList<T>(false, data);
    }
}
 
前端上传封装的vo
 
package com.hf.uncompress.vo;

import lombok.Data;

/**
 * @Description: 上传压缩的参数
 * @Date: 2019/1/23
 * @Auther: 
 */
@Data
public class PackParam {
    /**
     * 解压密码
     */
    private String password;

    /**
     * 解压文件存储地址
     */
    private String destPath;
}
 
在application.properties中定义其上传的阀域
 
#设置上传单个文件的大小限制
spring.servlet.multipart.max-file-size=500MB
# 上传文件总的最大值
spring.servlet.multipart.max-request-size=500MB
spring.thymeleaf.cache=false
 
 

createApk(file) {
            if(typeof FileReader==='undefined'){
                alert('您的浏览器不支持上传，请升级您的浏览器');//检查浏览器是否支持FileReader
                return false;
            }       
            var _this = this;
            var leng=file.length;
            for(var i=0;i<leng;i++){
                var reader = new FileReader();
                reader.readAsDataURL(file[i]); 
                reader.onload =function(e){
                    let res=e.target.result.split(';')//截取 data:;  base64 转换后默认会有data属性判断文件格式;分为两段，前段为data，后端为文件base64编码

                    if(res[0]!='data:application/apk;'){// 不同浏览器会有不一样的解析；so 这一步单独处理
                        _this.apk.app='data:application/apk;'+res[1]
                    }else{
                        _this.apk.app= e.target.result 
                    }
                };                 
            }                        
        }

前言
 
新搭建的集群，需要进行各种测试，于是让一个同事导入一些测试数据，大约1.4T左右。我进行了一个简单的hive测试
 
//故意增加shuffle
SELECT DISTINCT(COUNT id) FROM test_table;
 
谁知道…就这么一个简单的SQL，半个小时过去后，仍然没有出结果
 
追查原因
 
原来同事从ftp拉取过来的数据是gzip格式的，他直接导入到Hive表中…，而gzip格式的数据是不可切分的
 
如何理解不可切分
 
为了进一步理解gzip等不可切分的压缩格式，我做了个测试
 
 
上传测试数据
 
 说明：
 使用linux自带的gzip将testdata（拷贝了bigtable的数据，因为直接gzip bigtable，会删除原始数据）
 或者使用：
 
 说明：
 这样不但可以将原有的文件保留，而且可以将压缩包放到任何目录中，解压缩也一样可以看到bigtable.gz和testdata.gz大小一致
 
 
在hdfs根目录创建一个data目录、
 
 
[root@node02 data]# hadoop fs -mkdir /data
[root@node02 data]# hadoop fs -ls /
Found 2 items
drwxr-xr-x   - root supergroup          0 2020-01-04 05:47 /data
drwxrwxrwx   - root supergroup          0 2019-06-26 06:23 /tmp
 
上传压缩后的数据
 由于数据太小(大约50M)，仅有一个block，为了测试，自定义block块为10M：
 
hadoop fs -D dfs.blocksize=10485760 -put bigtable.gz /data
 

 
 
 
 
 
从上图中明显可以看到：gzip格式的数据，不支持切分的真正含义，并不是说HDFS不会将文件分布式的存储在各个节点，而是在计算的时候，不支持切分，也就是仅仅有一个split，从而也就是仅有一个map，这样的效率是及其低下的。
 （后面还会更详细的讲解）
 正常支持切分的数据，执行流程如下：
 
 

 而不持支切分的数据，如gzip格式的数据，就只有一个map:
 
 这样直接导致的结果就是：
 一个map任务处理N个HDFS块，而其中大多数块并没有存储在执行该map任务的节点上，执行的效率会非常低
 
既然这样，难道压缩数据就没有意义了吗？当然不是，而且在生产环境中数据都是经过压缩处理的，接下来详细讲解HDFS数据的压缩
 
详解HDFS文件压缩
 
 
文件压缩的两大好处
 （1）减少存储文件所需要的磁盘空间
 （2）加速数据在网络和磁盘上的传输
 
 
与Hadoop结合使用的常见压缩方法
 
 
压缩格式
工具
算法
文件扩展名
是否可切分
DEFLATE
无
DEFLATE
.deflate
否
gzip
gzip
DEFLATE
.gz
否
bzip2
bzip2
bzip2
.bz2
是
LZO
lzop
LZO
.lzo
否
LZ4
无
LZ4
.lz4
否
Snappy
无
Snappy
.snappy
否
 
 
说明：
 
 
DEFLATE是一个标准压缩算法，该算法的标准实现是zlib。没有可用于生成DEFLATE文件的常用命令行工具，因为通常都用gzip格式。注意，gzip文件格式只是在DEFLATE格式上增加了文件头和一个文件尾。.deflate扩展名是Hadoop约定的。
如果LZO文件已经在预处理过程中被索引了，那么LZO文件是可切分的。
 
 
详细描述文件的压缩
 所有压缩算法都需要权衡空间/时间：压缩和解压缩速度更快，其代价通常是只能节省少量的空间。上表列出所有压缩工具都提供9个不同选项来控制压缩时必须考虑的权衡：选项-1为优化压缩速度，-9为优化压缩空间。例如，下述命令通过最快压缩方法创建一个名为file.gz的压缩文件：
 gzip -1 file
 不同压缩工具有不同的压缩特性。gzip是一个通用的压缩工具，在空间/时间性能的权衡中，属于其他两个压缩方法之间。bzip2的压缩能力强于gzip（即省空间），但压缩速度更慢一点。尽管gzip的解压速度比要锁速度快，但仍比其他压缩格式要慢一些。另一方面，LZO、LZ4和Snappy均优化压缩速度，其速度比gzip快一个数据量级，但压缩效率稍逊一筹。Snappy和LZ4的解压缩速度比LZO高出很多，通过下面的一张图更形象的看出：压缩比和压缩速度是相反的
 
 上表中的“是否可切分”列表示对应的压缩算法是否支持切分（splitable），也就是说，是否可以搜素数据流的任意位置并进一步往下读取数据。可切分压缩格式尤其适合MapReduce（这个原因上面有讲解，下面进行更详细的描述）
 
更详细的描述压缩和输入分片
 
在考虑如何压缩将有MapReduce处理的数据时，理解这些压缩格式是否支持切分（splitable）是非常重要的。以一个存储在HDFS文件系统中且压缩前大小为1GB的文件为例。如果HDFS的块大小设置为128MB，那么该文件将被存储在8个块中，把这个文件作为输入数据的MapReduce作业，将创建8个输入分片，其中每个分片作为一个单独的map任务的输入被独立处理。
 
现在想象一下，文件是经过gzip压缩的，且压缩后文件大小为1GB。与以前一样，HDFS将这个文件保存为8个数据块。但是，将每个数据块单独作为一个输入分片是无法实现工作的，因为无法实现从gzip压缩数据流的任意位置读取数据，所以让map任务独立与其他任务进行数据读取是行不通的。gzip格式使用DEFLATE算法来存储压缩后的数据，而DEFLATE算法将数据存储在一系列连续的压缩块中。问题在于每个块的起始位置并没有以任何形式标记，所以读取时无法从数据流的任意当前位置前进到下一块的起始位置读取下一个数据块，从而实现与整个数据流的同步。由于上述原因，gzip并不支持文件切分。
 
在这种情况下，MapReduce会采用正确的做法，它不会尝试切分gzip压缩文件，因为它知道输入的时gzip压缩文件（通过文件扩展名看出）且gzip不持支切分。这是可行的，但牺牲了数据的本地性：一个map任务处理8个HDFS块，而其中大多数块并没有存储在执行该map任务的节点上。而且，map任务数量越少，作业的粒度就越大，因而运行的时间可能会更长。
 
在前面假设的例子中，如果文件时通过LZO压缩的，我们会面临相同的问题，因为这个压缩格式也不支持数据读取和数据流同步。但是，在预处理LZO文件的时候使用包含在Hadoop LZO库文件中的索引工具时可能的，你可以在Google和Github网站上获得该库。该工具构建了切分点索引，如果使用恰当的MapReduce输入格式可有效实现文件的可切分特性。
 
另一方面，bzip2文件提供不同数据块之间的同步标识（pi的48位近似值），因而它支持切分。可以参考前面的表，了解每个压缩格式是否支持可切分
 
该使用哪种压缩格式
 
Hadoop应用处理的数据集非常大，因此需要借助与压缩。使用哪种压缩格式，与待处理的文件的大小、格式和所使用的工具有关。下面有一些建议，大致是按照效率从高到底排列的。
 
使用容器文件格式，例如顺序文件（Sequence File）、Avro数据文件、ORCFile或者Parquet文件，所有这些文件格式同时支持压缩和切分。通常最好与一个快速压缩工具联合使用，例如，LZO、LZ4或者Snappy
使用支持切分的压缩格式，例如bzip2（尽管bzip2非常慢），或者使用通过索引实现切分的压缩格式，例如LZO
在应用中将文件切分成块，并使用任意一种压缩格式为每个数据块建立压缩文件（不论它是否支持切分）。这种情况下，需要合理选择数据块大小，以确保压缩后的数据块的大小近似于HDFS块的大小
存储未经压缩的文件
 
 
 
对于大文件来说，不要使用不支持切分整个文件的压缩格式，因为会失去数据的本地性，进而造成MapReduce应用效率低下
 
 
后记
 
本文内容参考Hadoop权威指南