精华内容
下载资源
问答
  • zip4j--Java操作zip压缩文件接口

    千次下载 热门讨论 2012-07-09 12:37:31
    Java操作zip压缩格式的开源项目,功能强大而且使用方便,能完全满足Java操作Zip压缩文件,官方网址为:http://www.lingala.net/zip4j/ 可以下载到jar包、源码和示例,好像没有提供API文档。 不过需要使用代理访问...
  • 利用perl写一脚本压缩本地文件夹上传到服务器,具体, #!/usr/bin/perl -w use Archive::Zip qw( :ERROR_CODES :CONSTANTS ); use File::Path; use File::Copy; my $zip = Archive::Zip->new(); use strict; my ( $...
  • 好了,让我们进入本次文章的主题,文件压缩和解压在项目中还是比较常见的,比如常用的导出和导入功能,有时候就需要导出或导入为zip格式,对于压缩这类的需求我一直是使用zip4j来处理,简单实用,java中虽然有自带...

    引言

    大家好,我又来水文了,说句题外话,代码生成器前后端分离响应式主题已经支持权限管理模块生成了,感兴兴趣的朋友可以去尝试下。好了,让我们进入本次文章的主题,文件的压缩和解压在项目中还是比较常见的,比如常用的导出和导入功能,有时候就需要导出或导入为zip格式,对于压缩这类的需求我一直是使用zip4j来处理,简单实用,java中虽然有自带的处理压缩的包,但中文会乱码,apache的ant包可以解决乱码问题,但使用起来较为繁琐,zip4j则要简单很多,下面一起看一下zip4j的使用方法以及我前阵子在项目中遇到的乱码问题以及解决方法吧!

    压缩

    zip4j的压缩文件的方法十分简单粗暴,首先引入pom依赖:

    <!-- https://mvnrepository.com/artifact/net.lingala.zip4j/zip4j -->
            <dependency>
                <groupId>net.lingala.zip4j</groupId>
                <artifactId>zip4j</artifactId>
                <version>1.3.2</version>
            </dependency>
    

    下面是压缩文件的代码:

    /**
    * 压缩带根目录
    */
    public static void zipFile(String dir, String filePath) {
    		try {
    			ZipFile zip = new ZipFile(filePath);
    			zip.setFileNameCharset("UTF-8");
    			File file = zip.getFile();
    			if (!file.getParentFile().exists()) {
    				file.getParentFile().mkdirs();
    			}
    			//为了不被原有文件干扰,保证每次重新生成
    			if (file.exists()) {
    				file.delete();
    			}
    			ZipParameters parameters = new ZipParameters();
    			parameters.setCompressionMethod(Zip4jConstants.COMP_DEFLATE);
    			parameters.setCompressionLevel(Zip4jConstants.DEFLATE_LEVEL_NORMAL);
    			// 要打包的文件夹
    			File currentFile = new File(dir);
    			if (currentFile.isDirectory()) {
    				zip.addFolder(currentFile, parameters);
    			} else {
    				zip.addFile(currentFile, parameters);
    			}
    		} catch (Exception e) {
    			throw new ForbiddenException("压缩出错!!");
    		}
    	}
    /**
    * 压缩根目录内的文件,不带根目录
    */
    public static void zipFileList(String dir, String filePath) {
    		try {
    			ZipFile zip = new ZipFile(filePath);
    			zip.setFileNameCharset("UTF-8");
    			File file = zip.getFile();
    			if (!file.getParentFile().exists()) {
    				file.getParentFile().mkdirs();
    			}
    			//为了不被原有文件干扰,保证每次重新生成
    			if (file.exists()) {
    				file.delete();
    			}
    			ZipParameters parameters = new ZipParameters();
    			parameters.setCompressionMethod(Zip4jConstants.COMP_DEFLATE);
    			parameters.setCompressionLevel(Zip4jConstants.DEFLATE_LEVEL_NORMAL);
    			// 要打包的文件夹
    			File zipfloder = new File(dir);
    			File[] files = zipfloder.listFiles();
    			assert files != null;
    			if (files.length == 0) {
    				zip.addFolder(dir, parameters);
    				return;
    			}
    			for (File theFile : files) {
    				if (theFile.isDirectory()) {
    					zip.addFolder(theFile, parameters);
    				}
    				if (theFile.isFile()) {
    					zip.addFile(theFile, parameters);
    				}
    			}
    		} catch (Exception e) {
    			throw new ForbiddenException("压缩出错!!");
    		}
    	}
    

    解压及防止乱码

    如上压缩代码所示,zip4j在压缩文件的时候可以指定编码类型,那么解压的时候也必须使用同样的编码类型进行解压,否则就会出现乱码现象,但用户上传的时候,如果是使用window系统压缩,编码类型为gbk,如果是使用linux或者mac压缩,那么编码类型为utf-8,这点我们是不可控的,如果想要防止解压乱码,需要得知压缩包的编码类型才可以!

    我最近做的一个项目就遇到了这个问题,本来以为判断压缩包的编码类型是件简单的事情,结果网上一搜,五花八门,什么方法都有,包括读取二进制流,判断字节的值等对于压缩文件来说都是不可用的,最后到了想要修改设计的地步,让用户自行选择压缩平台,然后根据用户的选择使用对应的编码解压,这也不失为一种好的方法,只是对于用户来说多了一步选择的操作。

    后来我又仔细寻找了一番,终于发现了较为靠谱的方法:使用cpdetecpor第三方工具包来判断,因为只需要判断gbk或utf-8,准确率目前可以达到百分之百,这个工具包使用了内置的探测器去探测编码,按照“谁最先返回非空的探测结果,就以该结果为准”的原则返回探测到的字符集编码,因此不保证完全正确,但经过项目的实践,可以认为完全正确。(maven仓库里没有收录这个工具包,可以在文末得到获取方式,下载安装到本地maven仓库即可)

    相关的解压以及判断编码类型的代码如下:

    // 解压加密的压缩文件
    	public static void unZip(File zipFile, String dest, String pwd) {
    		try {
    			// 首先创建ZipFile指向磁盘上的.zip文件
    			ZipFile zFile = new ZipFile(zipFile);
    			String charset = getCharset(zipFile);
    			if (charset == null) {
    				throw new ForbiddenException("文件不合法,可能已经被损坏!请重新打包尝试!");
    			}
    			zFile.setFileNameCharset(charset);
    			// 验证.zip文件是否合法,包括文件是否存在、是否为zip文件、是否被损坏等
    			if (!zFile.isValidZipFile()) {
    				throw new ForbiddenException("文件不合法,可能已经被损坏!请重新打包尝试!");
    			}
    			// 解压目录
    			File destDir = new File(dest);
    			if (destDir.isDirectory() && !destDir.exists()) {
    				destDir.mkdir();
    			}
    			if (zFile.isEncrypted()) {
    				// 设置密码
    				zFile.setPassword(pwd.toCharArray());
    			}
    			zFile.extractAll(dest);
    		} catch (ZipException e) {
    			throw new ForbiddenException("解析压缩文件过程中出现错误!!");
    		}
    	}
    
    
    	private static String getCharset(File file) {
    		/*
    		 * detector是探测器,它把探测任务交给具体的探测实现类的实例完成。
    		 * cpDetector内置了一些常用的探测实现类,这些探测实现类的实例可以通过add方法 加进来,如ParsingDetector、
    		 * JChardetFacade、ASCIIDetector、UnicodeDetector。
    		 * detector按照“谁最先返回非空的探测结果,就以该结果为准”的原则返回探测到的
    		 * 字符集编码。使用需要用到三个第三方JAR包:antlr.jar、chardet.jar和cpdetector.jar
    		 * cpDetector是基于统计学原理的,不保证完全正确。
    		 */
    		CodepageDetectorProxy detector = CodepageDetectorProxy.getInstance();
    		/*
    		 * ParsingDetector可用于检查HTML、XML等文件或字符流的编码,构造方法中的参数用于
    		 * 指示是否显示探测过程的详细信息,为false不显示。
    		 */
    		detector.add(new ParsingDetector(false));
    		/*
    		 * JChardetFacade封装了由Mozilla组织提供的JChardet,它可以完成大多数文件的编码
    		 * 测定。所以,一般有了这个探测器就可满足大多数项目的要求,如果你还不放心,可以
    		 * 再多加几个探测器,比如下面的ASCIIDetector、UnicodeDetector等。
    		 */
    		detector.add(JChardetFacade.getInstance());
    		// ASCIIDetector用于ASCII编码测定
    		detector.add(ASCIIDetector.getInstance());
    		// UnicodeDetector用于Unicode家族编码的测定
    		detector.add(UnicodeDetector.getInstance());
    		java.nio.charset.Charset charset = null;
    		try {
    			charset = detector.detectCodepage(file.toURI().toURL());
    		} catch (Exception ex) {
    			ex.printStackTrace();
    		}
    		if (charset != null) {
    			String name = charset.name();
    			if (name.startsWith("UTF")) {
    				return "UTF-8";
    			} else {
    				return "GBK";
    			}
    		}
    		return null;
    	}
    

    通过此方法可以比较有效的解决解压不同平台压缩的压缩包产生的乱码问题。

    结语

    文章到这里就结束了,大家可以收藏一下,说不定哪天能用上,或者你有什么更好的方法也欢迎告知我哦,毕竟这个方案并不是完全准确的。今天上班摸鱼更新了一版代码生成器,前后端分离响应式主题现在也支持权限管理模块生成了,同时顺手修复了一些明显的bug,今年已经接近尾声了,大家是不是都在等着年终奖呢,不知道今年发几个月。。。人艰不拆,努力奋斗吧!

    关注公众号 螺旋编程极客 发送 zip4j 可获取相关工具包,感兴趣的朋友也可以下载代码生成器使用,期待您的关注!

    展开全文
  • 上传压缩文件(rar或者zip格式),解压 <java.version>1.8 <groupId>org.springframework.boot <artifactId>spring-boot-starter-web <groupId>org.projectlombok <artifactId>lombok <optional>...

    在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

     

    展开全文
  • Linux文件系统很庞大复杂,不过有很多时候,在我们需要将文件分享给其他人的时候,经常会用到文件压缩,因为如果文件太大的话在分享给其他人时就需要传输更多的数据。下载一个几十M的压缩包和下载几百M的源文件,...

    你好,我是goldsunC
    让我们一起进步吧!

    前言

    我们知道,在面向对象的程序设计中,一切皆对象。而在Linux操作系统中,一切皆文件,因此我们总会跟文件打交道。

    Linux文件系统很庞大复杂,不过有很多时候,在我们需要将文件分享给其他人的时候,经常会用到文件压缩,因为如果文件太大的话在分享给其他人时就需要传输更多的数据。下载一个几十M的压缩包和下载几百M的源文件,估计大家都会选择前者吧。或者有时候我们需要对文件进行备份,源文件数据量太大会占用更多磁盘空间,也需要压缩。例如以上的情况,我们经常会用到文件压缩和解压这一操作。

    用惯了Windows的我们可能觉得这是一个很简单的事情,有很多软件能轻松实现文件压缩和解压,比如鄙人最喜欢的Bandzip,非常轻量级的一个小压缩软件,使用它只需要简单的点几下就能轻松实现文件压缩和解压的操作,简直不要太方便。但是用Linux的话,如果我们用shell来操作,可就没法简单点几下就完成任务了。我们需要掌握一些简单的压缩知识以及命令操作。

    什么是文件压缩

    目前我们使用的计算机系统中都是使用所谓的字节单位(byte)来计量。而事实上,bit才是计算机最小的计量单位,而1Byte=8bit,如果我们只需要记忆一个数字1,那系统会如何记录?是的,它会这么记录:

    00000001

    因为一个字节等于八个比特,每个比特值为0或1,如果记录一个数字1,它会在最右边占据1个位,而其它的7个位则会被自动地填上0。其实那7个位应该是空的才对。不过,计算机为了要满足我们的操作系统数据的读写,所以就会将该数据转为字节的形式来记录。

    而一些聪明的计算机工程师就是利用一些复杂的计算方式,将这些没有用到的空间丢出来,以让文件占用的空间变小,这就是压缩的技术。

    还有一种压缩技术,它是将重复的数据进行统计记录。例如,如果某个数据为[111111······]共有100个1时,那么压缩技术会记录为[100个1]而不是真的有100个1的位存在。这样也能给精简文件记录的容量。

    压缩技术简单来讲,就是将文件中的一些没有用到的空间填满,让空间利用率更高而已。但是既然你压缩了文件,那么我们的操作系统当然无法之间读取他们,因此,如果想要使用这些被压缩过的文件,就必须将它还原为未压缩前的状态,这也就是解压缩

    压缩文件最大的好处就是让文件的容量变小,以至于你可以在相同的空间存放更多的文件,或者在网络传输时传输的更快。

    Linux常见压缩指令

    在Linux环境中,压缩文件的扩展名大多是:.tar.tar.gz.tgz.gz.Z.bz2.xz

    如果你有一些Linux基础,我们知道在Linux中文件的扩展名并没有什么实际的作用,那为什么会有这样的扩展名呢?

    这是因为Linux支持的压缩命令非常多,且不同的命令所使用的压缩技术并不相同,因此彼此之间就可能无法互通压缩/解压缩文件。所以使用扩展名以让你知道该文件是使用了哪种压缩命令压缩的,好用来对照着解压缩。虽然Linux文件的属性和文件名没有绝对关系,但是清晰的文件名可以用来帮我们人类这小脑袋来辨别。

    *.Z            compress程序压缩的文件;
    *.zip        zip程序压缩的文件;
    *.gz        gzip程序压缩的文件;
    *.bz2        bzip2程序压缩的文件;
    *.xz        xz程序压缩的文件;
    *.tar        tar程序打包的文件,没有被压缩;
    *.tar.gz    tar程序打包的文件,经过gzip的压缩;
    *.tar.bz2    tar程序打包的文件,经过bzip2的压缩;
    *.tar.xz    tar程序打包的文件,经过xz的压缩;

    Linux上常见的压缩命令是gzipbzip2xz,而compress实际上已经被gzip替换了。其中zip命令其实早就有了,主要是为了支持Windows常见的zip压缩包。

    gzip是由GNU计划所开发出来的压缩命令,bzip2xz是GNU后来开发出的压缩比更好的压缩命令。不过不管哪个命令,通常仅能针对一个文件来压缩和解压缩,如此以来,每次压缩与解压缩都要一大堆文件岂不烦人,这个时候,打包,tar就显得非常重要。

    tar可以将很多个文件打包成为一个文件,就算是目录也不在话下,不过单纯的tar并没有压缩功能,仅仅能够打包而已,后来在GNU计划中,将整个tar与压缩的功能结合在了一起,如此就能更方便的进行压缩与打包了。

    gizp

    gzip几乎是应用最广的压缩命令了,它所建立的压缩文件扩展名为.gz。该命令基本语法如下:

    gzip [-cdtv#] filename

    其各选项参数简介如下:

    • -c:将解压缩的数据输出到屏幕上,可通过数据流重定向来处理;

    • -d:解压缩的参数;

    • -t:可以用来检验一个压缩文件的一致性,看看文件是否有错误;

    • -v:可以显示出原文件和压缩文件的压缩比等信息;

    • -#:#为数字的意思,代表压缩等级,其取值在[1-9],其中1最快,压缩比最差,9最慢,压缩比最好,默认情况下是6;

    如下图所示,在我的Templates目录下有一个文件services,如果我想要将其压缩,我可以这么做:

    24fc02ac6e921062036c53e6eddbf95a.png

    从图中可以看到,gzip -v services即可将该文件压缩,同时压缩之后压缩文件的扩展名加上了.gz,而加上了-v参数使得打印出了文件的压缩比等信息,可以看到文件被压缩了将近80%,这个效果已经很不错了。

    需要注意的是,当使用gzip进行压缩时,压缩之后源文件就不再存在了。此外,使用gzip压缩的文件在Windows系统中可以被WinRAR7zipBandzip等这些软件解压缩,很好用。

    而当我们把文件压缩之后,一般情况下会把文件先解压缩再访问,而实际上,我们可以使用zcatzmorezlesszgrep等命令来之间读取压缩文件。是不是很熟悉?只是在我们的常用命令前加了z而已。

    如图所示使用zmore读取一页services.gz文件:

    f6d79d5168308e39a1b2c749be9956ab.png

    另外,实际上我们可以在压缩文件的时候不删除源文件,如例:

    gzip -c services > services.gz

    这样的话压缩文件之后源文件还在,同时生成了压缩文件。其重点在于-c>的使用,-c可以将原本要转成压缩文件的数据内容变成文字类型在屏幕上输出,然后我们可以通过>这个符号,将原本应该从屏幕输出的数据,转成输出到文件还不是屏幕,所以就能够建立出一个新的压缩文件。

    bzip2和xz

    学会了gzip,其实bzip2xz差不多也就会了,这两个用法和gzip差不多,主要是为了提供更好的压缩比而诞生的。

    bzip2命令基本语法如下:

    bzip2 [-cdkzv#] filename

    其各选项参数简介如下:

    • -c:将压缩过程产生的数据输出到屏幕上;

    • -d:解压缩的参数;

    • -k:保留原始文件,而不删除原始文件;

    • -z:压缩的参数(默认值,可不加);

    • -v:可以显示出原文件和压缩文件的压缩比等信息;

    • -#:与gzip同样,为压缩比参数;

    xz命令基本语法如下:

    xz [-dtlkc#] filename

    • -d:解压缩;

    • -t:可以用来检验一个压缩文件的一致性,看看文件是否有错误;

    • -l:列出压缩文件的相关信息;

    • -k:保留原始文件,而不删除原始文件;

    • -c:将压缩过程产生的数据输出到屏幕上;

    总的来说,gzip->bzip2->xz是一个压缩比越来越好,但是执行时间越来越长的变化。如果你在意时间成本,可以使用gzip,如果想压缩的更好,使用xz,至于bzip2,则比较折中。

    打包指令

    tar

    前面谈到的压缩指令大多都只能对单一文件进行压缩,虽然gzipbzip2xz也能够对目录进行压缩,不过它们对目录的压缩是指将目录内的所有文件分别进行压缩的操作。而不像在Windows系统,可以通过软件直接将许多数据包成一个文件的样式。

    在Linux下,则有专门的打包指令:tar

    这个指令不仅仅可以对文件进行打包,同时可以通过压缩指令的支持,将文件同时进行压缩。

    tar命令基本语法如下:

    • 打包与压缩:tar [-z|-j-J] [cv] [-f 待建立的新文件名] filename

    • 查看文件名:tar [-z|-j-J] [tv] [-f 既有的tar文件名]

    • 解压缩:tar [-z|-j|-J] [xv] [-f 既有的tar文件名] [-C 目录]

    各选项参数简介如下:

    • -c:建立打包文件,可搭配-v来查看过程中被打包的文件名;

    • -t:查看打包文件的内容含有哪些文件名,重点是查看文件名;

    • -x:解包或解压缩功能,可搭配-C在特点目录解压,默认在当前目录;

    • -z:通过gzip支持进行压缩和解压缩,文件名最好是*.tar.gz;

    • -j:通过bzip2的支持进行压缩和解压缩,文件名最好是*.tar.bz2;

    • -J:通过xz的支持进行压缩和解压缩,文件名最好是*.tar.xz;

    • -v:在压缩或解压缩过程中,将正在处理的文件名显示出来;

    • -f:参数后加要被处理的文件名;

    • -C 目录:指定目录解压;

    • -p保留备份数据的原本权限与属性,常用于备份重要的配置文件。

    • -P保留绝对路径,即运行备份数据中包含根目录。

    • --exclude=FILE在压缩过程中,不要打包FILE。

    tar命令的参数比较多,也说明了其能实现的操作比较多。

    其中的-c,-t,-x三个参数不能同时出现,因为它们分别代表打包压缩、查看文件名、解压缩之意。

    其中的-z,-j,-J三个参数也不能同时出现,因为它们分别代表用哪一种压缩命令进行支持。

    打包指令使用方法也比较简单,只需要明白各个参数的意义使用时加以选择即可,不过比较重要的是字体加粗的三个参数。

    其中-p指保留数据的原本权限与属性,这个比较好理解,Linux本就是一个权限非常严格的系统,毕竟是一个多人多任务的系统,权限的管理非常重要,不明白的同学可自行学习。保留原本权限与属性可以使得打包后的文件与原来的文件更加一模一样

    -P指数据中包含/根目录,也就是说默认情况下是不包含根目录的。为什么要去掉根目录?主要是为了安全。因为我们使用tar备份的数据有可能会解压缩回来使用,如果去掉了根目录,解压缩后的文件就会在当前文件夹产生,而如果包含了根目录,解压缩后的文件会可能会覆盖原本文件下的数据。

    举个例子,你打包了/etc/下的所有文件进行备份,如果去掉了根目录/,那么如果你解压时在的是Templates文件夹,那么文件目录就变成了Templates/etc/,而如果没有去掉根目录,他就会覆盖你原本来的/etc。也就是备份数据就会把当前系统文件覆盖。这时候你可能会想,既然是备份,不就是为了恢复那个状态吗,直接覆盖了不是更好?不过万一你那个备份的数据版本比较旧呢?你只是打开查看一下一些内容而已,结果备份数据直接把你当前数据覆盖了,你如何是好?

    --exclude==FILE的意思是在打包的时候不包含指定的文件,例如一个文件下有四个文件,你想打包其中的三个,你只需要在打包的时候使用此参数指定那个文件即可。

     • end • 

    走在路上

    goldsunC

    5c72cb4bf964277051697cbf103e2aca.png
    展开全文
  • sftp文件上传下载改名压缩解压

    千次阅读 2017-11-21 11:54:25
    //上传文件--贷款申请阶段上传影像 public static void main(String[] args) { ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext( new String[] { "/spring-base.xml" , "/...
    希望能帮到大家,有疑问联系
    package com.qb.modules.organtrans.interactive.jinshang;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.util.Date;
    import java.util.List;
    import java.util.Properties;
    
    import org.apache.commons.io.FileUtils;
    import org.apache.commons.io.FilenameUtils;
    import org.apache.commons.io.IOUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.apache.tools.ant.taskdefs.Copyfile;
    import org.drools.io.impl.ClassPathResource;
    import org.drools.lang.DRLExpressions.neg_operator_key_return;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.stereotype.Service;
    import org.springframework.web.multipart.MultipartFile;
    
    import com.jcraft.jsch.ChannelSftp;
    import com.qb.modules.organtrans.attachment.dto.AttachmentDTO;
    import com.qb.modules.organtrans.attachment.service.AttachmentService;
    import com.qb.modules.organtrans.common.Constants;
    import com.qb.modules.organtrans.orgpackconfig.service.OrgPackConfigService;
    import com.qb.modules.organtrans.util.FileUtil;
    import com.qb.modules.organtrans.util.SFTPUtils;
    import com.qb.modules.util.CommonUtil;
    import com.qb.modules.util.ConfigUtil;
    import com.qb.modules.util.ZipCompress;
    import com.qb.platform.core.fastdfs.task.SynSingleFileDownloadWorker;
    import com.qb.platform.core.fastdfs.task.SynSingleFileUploadWorker;
    import com.qb.platform.tools.common.DateUtil;
    
    import net.sf.ehcache.hibernate.ccs.EhcacheNonstrictReadWriteCache;
    @Service
    public class SftpOperateUtils {
        private static final Logger logger =  LoggerFactory.getLogger(SftpOperateUtils.class);  
    
        @Autowired
        OrgPackConfigService orgPackConfigService;
        @Autowired
        AttachmentService attachmentService;
        @Autowired
        SynSingleFileDownloadWorker synSingleFileDownloadWorker;
        @Autowired
        SynSingleFileUploadWorker synSingleFileUploadWorker;
        //上传文件--贷款申请阶段上传影像
        public static void main(String[] args) {
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
                    new String[] { "/spring-base.xml", "/spring-shiro.xml" });
            SftpOperateUtils sftpOperateUtils = context.getBean(SftpOperateUtils.class);
    
            try {
                //boolean uploadSignContract = sftpOperateUtils.uploadSignContract("564564",220L, "5,12cba975f00e05","QT1",3L,"fsdf.jpg");
                sftpOperateUtils.js_downLoadConract("2017091200001801", "2017091200001801", 1L, "QT15", 5L);
                //boolean b = fillMaterial("123456","12365411",1L,2L,"03","QT15");
            //boolean b = sftpOperateUtils.fillMaterial("104788","2017123456", 1L, 2L, "03", "QT15");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public  boolean fillMaterial(String appsleqid, MultipartFile[] attachmets, Long listId, Long listType,String node,String fileTypeCode) throws Exception {
    
                boolean isOK = false;
                File endfile = null;
                String filepath = null;
                String filename = null;
                //获取sftp上传路径
                String local =  ConfigUtil.getConfig(Constants.DirPath.COMMON_TEMP)+File.separator+appsleqid;
                endfile = new File(local);
                if(!endfile.exists() && !endfile.isDirectory()){
                    //endfile.mkdir();
                    endfile.mkdirs();
                }
                String dellocal =  ConfigUtil.getConfig(Constants.DirPath.COMMON_TEMP);
                //创建文件夹  
                String sftpPath = CommonUtil.getPropertiesValue("sftp.properties", "jinshang.fillmaterial")+"/"+appsleqid;
                OutputStream outputStream= null;
                SFTPUtils sftputils = new SFTPUtils();
                //获取晋商sftp服务器信息
                SFTPUtils sftp1 = getSftp();
                ChannelSftp sftp = sftp1.getSFTPClient();
            try {
                if (node.equals("03")) {//补全影像资料
    
                    for (MultipartFile multipartFile : attachmets) {
                         filename = multipartFile.getOriginalFilename();
                        File file = new File(filename);
                        String path = file.getAbsolutePath();
                        multipartFile.transferTo(file);
                        File startfile = new File(path);
    
                        filepath = synSingleFileUploadWorker.uploadSeaweed(file);
                        //2 入attachment表
                        AttachmentDTO attachmentDTO;
                        attachmentDTO= new AttachmentDTO();
                        attachmentDTO.setListId(listId);
                        attachmentDTO.setListType(listType);
                        attachmentDTO.setFileName(filename);
                        attachmentDTO.setCreateDate(new Date());
                        attachmentDTO.setFileTypeCode(fileTypeCode);
                        attachmentDTO.setFilePath(filepath);
                        attachmentService.insertAttachment(attachmentDTO);
                        //移动到临时目录并打包
                        startfile.renameTo(new File(local+"\\"+startfile.getName()));
                    }
                        //压缩
                        String zipoutpath = local+".zip";
                        ZipCompress.zipFiles(new File(local).listFiles(), new File(zipoutpath));
                        //创建文件夹
                        sftputils.mkDir(sftpPath, sftp);
                        //上传
                        sftp.put(zipoutpath,sftpPath);
                        //删除本地文件
                        delFolder(dellocal);
                        isOK=true;
                }
            } catch (Exception e) {
                isOK =false;
                e.printStackTrace();
                logger.error("执行方法fillMaterial异常:", e);
            } finally {
                outputStream.flush();
                outputStream.close();
                sftp.disconnect();
            }
    
            return isOK;
        }
    
    
        /**
         *  下载文件并入库记录对应关系
         * Description: 
         * @param
         * @return 返回下载的地址
         * @throws Exception 
         * @throws
         * @Author 
         * Create Date: 2017年11月17日 上午10:25:54
         */
        //(respon.getApplseqcontractid(),info.getIouSupportDTO().getBusiUuid(),info.getId(),"QT14",FileUtil.TYPE_CONTRACT_FILE);
        public String js_downLoadConract(String path, String applseq, Long listId, String fileTypeCode,
                Long listType) throws Exception {
    
            String filepath = null;
            String destt = null;
            SFTPUtils sftp = getSftp();
            //获取合同下载路径
            String sftpDir = CommonUtil.getPropertiesValue("sftp.properties", "jinshang.supply.upload")+path;
            //创建本地文件夹
            String dellocal =  ConfigUtil.getConfig(Constants.DirPath.COMMON_TEMP);
            String directoryPath = ConfigUtil.getConfig(Constants.DirPath.COMMON_TEMP)+ File.separator + applseq;
            File dirPath = new File(directoryPath);
            if (!dirPath.exists() && !dirPath.isDirectory()) {
                dirPath.mkdirs(); // 没有则创建
            }
            String filename = applseq+".zip";
            String localfile = directoryPath +File.separator + filename;
            String sftpfile = sftpDir+"/"+filename;
            try {
                    if (sftp.isFileExist(filename,sftpDir)) {//如果当前路径,存在以这个流水号命名的文件
                        logger.error("从SFTP下载文开始,js_"
                                + "LoadConract-sftp.get(sftpFile, localFile)-start:" + applseq);
                        sftp.get(sftpfile, localfile);
                        logger.error("从SFTP下载文结束,js_downLoadConract-sftp.get(sftpFile, localFile)-end:" + applseq);
                    }
            } catch (Exception e) {
                logger.error("文件解析失败,js_downLoadConract-sftp-error:" + applseq + "," + e.getMessage());
                e.printStackTrace();
            }finally {
                try {
                    sftp.disconnect();
                } catch (Exception e) {
                    logger.error("关闭SFTP连接时异常,js_downLoadConract-error," + e.getMessage());
                    e.printStackTrace();
                }
            }
                //解压缩合同
                String dest = directoryPath+File.separator+applseq;
                ZipCompress.unZip(localfile, dest, true);
                File file = new File(localfile);
                file.delete();
                File file2 = new File(directoryPath);
                if (file2.isDirectory()) {
                    String[] filelist = file2.list();
                for (int i = 0; i < filelist.length; i++) {
                     destt = directoryPath + "\\" + filelist[i];
                    }
                }
            //2 入attachment表
            try {
                filepath = synSingleFileUploadWorker.uploadSeaweed( new File(destt) );
                AttachmentDTO attachmentDTO;
                attachmentDTO= new AttachmentDTO();
                attachmentDTO.setListId(listId);
                attachmentDTO.setListType(listType);
                attachmentDTO.setFileName(filename);
                attachmentDTO.setCreateDate(new Date());
                attachmentDTO.setFileTypeCode(fileTypeCode);
                attachmentDTO.setFilePath(filepath);
                attachmentService.insertAttachment(attachmentDTO);
                 //删除本地文件
                  delFolder(dellocal);
    
            } catch (IOException e) {
                logger.error("入attachment表异常,js_downLoadConract-error," + e.getMessage());
                e.printStackTrace();
            }
    
            return filepath;
        }
    
        //胡文使用,下载并上传
        public   boolean download(String id,String appsleqid ,String coorgId){
            //创建本地路径
            boolean isOk=false;
            String localpath =  ConfigUtil.getConfig(Constants.DirPath.COMMON_TEMP)+File.separator+appsleqid;
            String dellocal =  ConfigUtil.getConfig(Constants.DirPath.COMMON_TEMP);
            File localdir = new File( localpath );
            //创建文件夹  
            if(!localdir.exists() && !localdir.isDirectory()){
                localdir.mkdir();
            }
            try {
                List<String> orgPackConfigList=orgPackConfigService.selectOrgPackByCoOrgID(Long.valueOf( coorgId),Constants.TemplateType.CONTRACT_EXCEL);
                //查
                  List<AttachmentDTO> attachmentDTOs = attachmentService.searchAttachemnt(id,FileUtil.TYPE_CONTRACT_FILE,orgPackConfigList);
                //写
                  for (AttachmentDTO attachmentDTO : attachmentDTOs) {
                      String fileExt = FilenameUtils.getExtension(attachmentDTO.getFileName());
                      String attachmentFilePath = localpath + System.getProperty("file.separator")+"/"+appsleqid+"."+fileExt;
                      String attachmentFilePath1 = localpath +File.separator+appsleqid+"."+fileExt;
                      File attachmentFile = new File( attachmentFilePath );
                      String fileName = attachmentDTO.getFileName();
                      FileUtils.writeByteArrayToFile(attachmentFile, synSingleFileDownloadWorker.downloadSeaweed( attachmentDTO.getFilePath()));
                }
    
                  String zipoutpath = localpath+".zip";
                  ZipCompress.zipFiles(localdir.listFiles(), new File(zipoutpath));
                  String sftpPath = CommonUtil.getPropertiesValue("sftp.properties", "jinshang.sign")+"/"+appsleqid;
                  SFTPUtils sftp1 = getSftp();
                  ChannelSftp sftp = sftp1.getSFTPClient();
                  SFTPUtils sftputils = new SFTPUtils();
                  sftputils.mkDir(sftpPath, sftp);
                  sftp.put(zipoutpath,sftpPath);
                  sftp.disconnect();
                  //删除本地文件
                  delFolder(dellocal);
                  isOk=true;
            } catch (Exception e) {
                 isOk=false;
                logger.error("执行方法download异常:", e);
            }finally {
    
            }
            return isOk;
    
        }
    
    
    
        /**
         * 
         * Description: 根据影像服务器地址 下载入库 记录对应关系 并上传到晋商sftp
         * @paramu ploadType 01 上传 03 补传 
         * @return boolean
         * @throws IOException 
         * @throws Exception 
         * @throws
         * @Author 
         * Create Date: 2017年11月17日 上午11:03:39
         */
        public boolean uploadSignContract(String busiUuid, Long listId, String downPath, String fileTypeCode,
                long listType,String fileName,String remark)  { 
            SFTPUtils utils = null;
            String sftpPath = CommonUtil.getPropertiesValue("sftp.properties", "jinshang.sign.contract.upload")+File.separator + busiUuid;
            boolean isOk = false;
            String tempPath=""; 
            try {
                // 入库 上传到晋商sftp
                if (StringUtils.isNotBlank(downPath)) {
                    byte[] contractFile = synSingleFileDownloadWorker.downloadSeaweed(downPath);
                    utils = getSftp();
                      tempPath = ConfigUtil.getConfig(Constants.DirPath.COMMON_TEMP) + File.separator
                            + DateUtil.getDateToStringSS(new Date());
                      File   file = new File(tempPath);
                    if (!file.exists() && !file.isDirectory()) {
                        file.mkdirs(); // 没有则创建
                    }
                    String filePathAll=tempPath+File.separator+fileName;
                    File f=new File(filePathAll); 
                    //压缩
                    FileUtils.writeByteArrayToFile(f, contractFile);
                    File f2 = new File(tempPath);
                    String zipfile = busiUuid+".zip";
                    File zipoutfile = new File(zipfile);
                    ZipCompress.zipFiles(f2.listFiles(), zipoutfile);
                    utils.upload(sftpPath,zipfile);
                    AttachmentDTO dto = new AttachmentDTO();
                    dto.setListId(listId);
                    dto.setFileTypeCode(fileTypeCode);
                    dto.setFilePath(downPath);
                    dto.setListType(listType);
                    dto.setFileName(fileName+File.separator+fileName);
                    dto.setCreateDate(new Date());
                    dto.setRemark(remark);
                    attachmentService.insertAttachment(dto);
                    isOk = true;
                    f.delete();
                    FileUtils.deleteDirectory(file);
                }
            } catch (Exception e) {
                isOk = false;
                logger.error("uploadSignContract 上传签完章的合同报错", e);
            } finally { 
                if (utils != null) {
                    try {
                        utils.disconnect();
                    } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            return isOk;
        }
    
        //获取晋商sftp参数
        private static SFTPUtils getSftp() {
            Properties prop = new Properties();
            ClassPathResource cp = new ClassPathResource("sftp.properties");
            try {
                prop.load(cp.getInputStream());
            } catch (IOException e) {
                e.printStackTrace();
            }
            String host = prop.getProperty("jinshang.host").trim();
            int port = Integer.parseInt(prop.getProperty("jinshang.port").trim());
            String username = prop.getProperty("jinshang.username").trim();
            String password = prop.getProperty("jinshang.password").trim();
            return new SFTPUtils(host, port, username, password);
            }
    
    /**   
     *  删除文件夹   
     *  @param  filePathAndName  String  文件夹路径及名称  如c:/fqf   
     *  @param  fileContent  String   
     *  @return  boolean   
     */    
    private void delFolder(String dellocal) {
          try  {    
               delAllFile(dellocal);  //删除完里面所有内容    
               String  filePath  =  dellocal;    
               filePath  =  filePath.toString();    
               java.io.File  myFilePath  =  new  java.io.File(filePath);    
               myFilePath.delete();  //删除空文件夹    
           }    
           catch  (Exception  e)  {    
               System.out.println("删除文件夹操作出错");    
               e.printStackTrace();    
           }    
    }
      /**   
     *  删除文件夹里面的所有文件   
     *  @param  path  String  文件夹路径  如  c:/fqf   
     */    
    private void delAllFile(String dellocal) {
         File  file  =  new  File(dellocal);    
           if  (!file.exists())  {    
               return;    
           }    
           if  (!file.isDirectory())  {    
               return;    
           }    
           String[]  tempList  =  file.list();    
           File  temp  =  null;    
           for  (int  i  =  0;  i  <  tempList.length;  i++)  {    
               if  (dellocal.endsWith(File.separator))  {    
                   temp  =  new  File(dellocal  +  tempList[i]);    
               }    
               else  {    
                   temp  =  new  File(dellocal  +  File.separator  +  tempList[i]);    
               }    
               if  (temp.isFile())  {    
                   temp.delete();    
               }    
               if  (temp.isDirectory())  {    
                   delAllFile(dellocal+"/"+  tempList[i]);//先删除文件夹里面的文件    
                   delFolder(dellocal+"/"+  tempList[i]);//再删除空文件夹    
               }    
           }    
    
    }
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • 随着科技的发展,手机像素越来越好。图片越清晰,体积也就越大。当移动端上传大图时就会发生卡顿,请求超时的情况。当图片过大时,图片预览也会非常慢,所以需要在图片上传时对图片进行压缩。 ...
  • 使用java解压缩文件,并获取压缩文件中的文件名称,使用多线程,提高效率
  • //生成压缩文件前先搜索客户地点下的所有药检文件 for (int i = 0; i < newList.size(); i++) { String new_store = (String) newList.get(i); System.out.println("第" + i &#...
  • throw new RuntimeException("文件上传失败"); } return OOS_URL_READ+BUCKET_NAME+fileName; } /** * 获取文件名 * @param muFile 文件 * @param isRetain 是否保留源文件名 * @return 返回文件名,以...
  • 如果你想知道如何用java代码解压压缩文件,以及解压后的文件如何处理,请看看吧!
  • java代码上传文件时加水印: 内有jar包的说明文件 图片加水印:TestWaterPrint.java WORD文档加水印:AddWatermarkUtil.java PDF加水印:TestWaterPrint.java Excel加水印:ExcelWaterRemarkUtils.java
  • * 上传压缩文件 */ @RequestMapping("/uploadPushContent") public String uploadPushContent(MultipartFile multipartFile, HttpServletRequest request) { try { // 1.上传附件到项目根目录 String path = ...
  • 了解了压缩原理之后,要解压文件就是压缩文件的逆过程;拿昨天的例子来说,如果我们收到这样一串二进制1 1 01 1 1 01 00(昨天漏掉了一个问题,这里是9个0 1,每8个一个字节,那么剩下的那个0需要补7个0,构成...
  • 最近后端管理项目中需要用到用户一些证件图片进行表单文件上传 如果每个人的证件照片都非常大,对服务器资源将是一种浪费, 因为用户量也不是很大,所以也没对接第三方的OSS或者七牛云存储对象,就写个简单的图像...
  • package com.internetware.apistore.util; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.*; import java.util.HashSet; import java.util.Set; public class FileUtils { priv...
  • httpClient 发送压缩文件

    千次阅读 2016-10-17 21:25:42
    4j .Logger ; import org .springframework .http .client .HttpComponentsClientHttpRequestFactory ; import java .io .File ; import java .io .FileInputStream ; import java .io .IOException ; ...
  • linux内核源码压缩格式: 内核版本 压缩格式 https://mirrors.edge.kernel.org/pub/linux/kernel/v3.x/ bzip2, gzip, xz https://mirrors.edge.kernel.org/pub/linux/kernel/v4.x/ gzip, ...
  • 本文实例为大家分享了Vue2.0实现调用摄像头进行拍照功能的具体代码,以及图片上传功能引用exif.js,供大家参考,具体内容如下 ... ...效果目标:实现等比例压缩上传 上代码 HTML &lt;!DOC...
  • 总结一下大文件分片上传和断点续传的问题。因为文件过大(比如1G以上),必须要考虑上传过程网络中断的情况。http的网络请求中本身就已经具备了分片上传功能,当传输的文件比较大时,http协议自动会将文件切片(分块...
  • JPEG图片文件 批量压缩工具 我们通常用相机拍的照片,像素很高时,高达几M,发给客户和朋友非常占用邮箱空间,发送也会很慢。 于是使用该JPEG图片文件 批量压缩工具,操作方便,可以把普通图片压缩成1024*768,然后...
  • 在进行文件传输时,为了提高传输速度,一般选择将多个文件按照一定的格式进行压缩然后进行传输,这一章我们主要学习不同格式的压缩压缩后不同系统中如何进行文件的传输1.文件归档:将多个文件变成一个归档文件...
  • 压缩多个文件

    2019-05-13 10:56:53
    多个文件名称用字符串数组存储传入。 String [] fileNames = {"aa.txt... * 压缩文件 * * @param sourceFilePath 资源主路径 * @param outFileName 输出文件名称 * @param allFileNames 文件名称 * @ret...
  • 压缩文件夹或者文件返回zip压缩包

    千次阅读 2019-04-24 17:12:43
    关于多文件下载,往往需要压缩成一个zip压缩包返回前端进行下载,下面提供一些公共方法,希望能有帮助。 package com.example.upload; import lombok.extern.slf4j.Slf4j; import org.apache.commons.compress....
  • 文件打包压缩与远程传输

    千次阅读 2017-08-18 19:20:15
    文件的传输以及文件的整理过程中我们经常会用到压缩。 1.文件压缩 gzip , bzip2 ,zip , xz 打包压缩tar zcvf newfilename.tar.gz oldfilename ...... 2.文件远程传输 scp,rsync,sftp
  • 基于Huffman树的文件压缩原理及C语言实现(二)

    千次阅读 多人点赞 2015-11-24 19:41:25
    在上文基于Huffman树的文件压缩原理及C语言实现(一)中已经介绍并实现了如何建立Huffman树,得到Huffman编码,这篇我们将会接着说。如何通过Huffman树,实现文件压缩。实现思路任何文件都可以看作是由字节组成的...
  • Java读取上传文件,并保存到服务器,并在服务器端进行解压缩: package com.msunsoft.common.upload.service; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java....
  • tar 命令通过 SSH 访问服务器,难免会要用到压缩,解压缩,打包,解包等,这时候tar命令就是必不可少的一个功能强大的工具。Linux 中最流行的tar是麻雀虽小,五脏俱全,功能强大。使用tar命令,我们可以为 Linux 的...
  • //指定压缩文件存放路径 String zipFileName = "src/main/resources/zipFiles/"+zipName+".zip"; File zipFile = new File(zipFileName); //构建输出流 FileOutputStream fout = new FileOutputStream(zipFile)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,373
精华内容 10,149
关键字:

压缩文件上传j