java下载文件夹

下载指定文件夹下的所有文件

public class DownloadUtils {
    /**
     * 下载文件
     * @param response
     * @throws FileNotFoundException
     * @throws UnsupportedEncodingException
     */

//    @GetMapping("/download")
    public static void downloadLocal(String filePath,HttpServletResponse response) throws IOException {
//        String filePath = SysConfigCache.getString("file_url_z")+Path;
        File file = new File(filePath);
        if(!file.exists()){
//            response.writeHead(200,{'Content-Type':'text/html'});//注意这里的html，如果为plain则不会显示html，会输出.html文件中的字符串
//            response.write(body);
//            response.end();
            response.setContentType("text/html;charset=utf-8");
            response.setCharacterEncoding("utf-8");
            response.getWriter().println("<div>文件路径不存在</div>");
//            response.getWriter().println("<script>" +
//                    "alert('文件路径不存在');" +
                    "location.reload()" +
//                    "</script>");
            response.getWriter().close();
            return;
//            throw new RuntimeException("文件路径不存在");
        }
        if(file.isDirectory()){
            zipDownloadRelativePath(response,filePath);
        }else{
            downloadFile(response,filePath);
        }
    }

    /**
     * 下载文件
     * @param response
     * @param filePath
     * @throws FileNotFoundException
     * @throws UnsupportedEncodingException
     */
    public static void downloadFile(HttpServletResponse response, String filePath) throws FileNotFoundException, UnsupportedEncodingException {
        // 下载本地文件
//        String fileName = "Operator.doc".toString(); // 文件的默认保存名
        // 读到流中
//        InputStream inStream = new FileInputStream(SysConfigCache.getString("file_url_z")+filePath);// 文件的存放路径
        InputStream inStream = new FileInputStream(filePath);// 文件的存放路径
        String fileName = filePath.substring(filePath.lastIndexOf("\\")+1);
        // 设置输出的格式
        response.reset();
        response.setContentType("bin");
        response.addHeader("Content-Disposition", "attachment; filename=\"" + new String(fileName.getBytes(),"iso-8859-1") + "\"");
        // 循环取出流中的数据
        byte[] b = new byte[100];
        int len;
        try {
            while ((len = inStream.read(b)) > 0)
                response.getOutputStream().write(b, 0, len);
            inStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 下载文件夹
     * @param response
     * @param filePath
     */
    public static void zipDownloadRelativePath(HttpServletResponse response, String filePath) throws UnsupportedEncodingException {
        String msg ="";//下载提示信息
//        String root = request.getSession().getServletContext().getRealPath("/convert");//文件路径
//        String root = "D:\\file\\武功秘籍";//文件路径
//        String root = "D:\\Downloads\\20200819190451\\九阴真经.pdf";//文件路径
//        String root = SysConfigCache.get("file_url_z")+filePath;
        String root = filePath;
        String fileName = filePath.substring(filePath.lastIndexOf("\\")+1)+".zip";
        Vector<File> fileVector = new Vector<File>();//定义容器装载文件
        File file = new File(root);
        File [] subFile = file.listFiles();
        //判断文件性质并取文件
        for(int i = 0; i<subFile.length; i++){
            if(!subFile[i].isDirectory()){//不是文件夹并且不为空
                fileVector.add(subFile[i]);//装载文件
            }else{//是文件夹,再次递归遍历文件夹里面的文件
                File [] files = subFile[i].listFiles();
                Vector v = FileUtil.getPathAllFiles(subFile[i],new Vector<File>());
                fileVector.addAll(v);//把迭代的文件装到容器中
            }
        }
        //设置文件下载名称
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
//        String fileName = dateFormat.format(new Date())+".zip";
        response.setHeader("Content-disposition", "attachment;filename=\"" + new String(fileName.getBytes(),"iso-8859-1") + "\"");//如果有中文需要转码
        //定义相关流
        //用于浏览器下载响应
        OutputStream out = null;
        //用于读压缩好的文件
        BufferedInputStream bis = null;//用缓存性能会好一些
        //用于压缩文件
        ZipOutputStream zos = null;
        //创建一个空的zip文件
//        String zipBasePath = request.getSession().getServletContext().getRealPath("/fileZip");
        String zipBasePath = SysConfigCache.getString("file_url_z")+"zipFile";
        String zipFilePath = zipBasePath+File.separator+fileName;
        File zipFile = new File(zipFilePath);
        try {
            if(!zipFile.exists()){//不存在创建一个新的
                zipFile.createNewFile();
            }
            out = response.getOutputStream();
            //创建文件输出流
            zos = new ZipOutputStream(new FileOutputStream(zipFile));
            //循环文件，一个一个按顺序压缩
            for(int i = 0;i< fileVector.size();i++){
                System.out.println(fileVector.get(i).getName()+"大小为："+fileVector.get(i).length());
                FileUtil.zipFileFun(fileVector.get(i),root,zos);
            }
            //压缩完成以后必须要在此处执行关闭 否则下载文件会有问题
            if(zos != null){
                zos.closeEntry();
                zos.close();
            }
            byte[] bt = new byte[10*1024];
            int size = 0;
            bis = new BufferedInputStream(new FileInputStream(zipFilePath),10*1024);
            while((size=bis.read(bt,0,10*1024)) != -1){//没有读完
                out.write(bt,0,size);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }finally {//关闭相关流
            try {
                //避免出异常时无法关闭
                if(zos != null){
                    zos.closeEntry();
                    zos.close();
                }

                if(bis != null){
                    bis.close();
                }

                if(out != null){
                    out.close();
                }
                if(zipFile.exists()){
                    zipFile.delete();//删除
                }
            } catch (Exception e2) {
                System.out.println("流关闭出错！");
            }

        }
    }
 }

辅助工具类

package com.hhwy.fileview.utils;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Vector;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;




public class FileUtil {
    /**
     * 把某个文件路径下面的文件包含文件夹压缩到一个文件下
     * @param file
     * @param rootPath 相对地址
     * @param zipoutputStream
     */
    public static void zipFileFun(File file,String rootPath,ZipOutputStream zipoutputStream){
        if(file.exists()){//文件存在才合法
            if(file.isFile()){
                //定义相关操作流
                FileInputStream fis = null;
                BufferedInputStream bis = null;
                try {
                    //设置文件夹
                    String relativeFilePath = file.getPath().replace(rootPath+File.separator, "");
                    //创建输入流读取文件
                    fis = new FileInputStream(file);
                    bis = new BufferedInputStream(fis,10*1024);
                    //将文件装入zip中，开始打包
                    ZipEntry zipEntry;
                    if(!relativeFilePath.contains("\\")){
                        zipEntry = new ZipEntry(file.getName());//此处值不能重复，要唯一，否则同名文件会报错
                    }else{
                        zipEntry = new ZipEntry(relativeFilePath);//此处值不能重复，要唯一，否则同名文件会报错
                    }
                    zipoutputStream.putNextEntry(zipEntry);
                    //开始写文件
                    byte[] b = new byte[10*1024];
                    int size = 0;
                    while((size=bis.read(b,0,10*1024)) != -1){//没有读完
                        zipoutputStream.write(b,0,size);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    try {
                        //读完以后关闭相关流操作
                        if(bis != null){
                            bis.close();
                        }
                        if(fis != null){
                            fis.close();
                        }
                    } catch (Exception e2) {
                        System.out.println("流关闭错误！");
                    }
                }
            }
//            else{//如果是文件夹
//                try {
//                    File [] files = file.listFiles();//获取文件夹下的所有文件
//                    for(File f : files){
//                        zipFileFun(f,rootPath, zipoutputStream);
//                    }
//                } catch (Exception e) {
//                    e.printStackTrace();
//                }
//                
//            }
        }
    }
    
    /*
     * 获取某个文件夹下的所有文件
     */
    public static Vector<File> getPathAllFiles(File file,Vector<File> vector){
        if(file.isFile()){//如果是文件，直接装载
            System.out.println("在迭代函数中文件"+file.getName()+"大小为："+file.length());
            vector.add(file);
        }else{//文件夹
            File[] files = file.listFiles();
            for(File f : files){//递归
                if(f.isDirectory()){
                    getPathAllFiles(f,vector);
                }else{
                    System.out.println("在迭代函数中文件"+f.getName()+"大小为："+f.length());
                    vector.add(f);
                }
            }
        }
        return vector;
    }
    
    /**
     * 压缩文件到指定文件夹
     * @param sourceFilePath 源地址
     * @param destinFilePath 目的地址
     */
    public static String zipFiles(String sourceFilePath,String destinFilePath){
        File sourceFile = new File(sourceFilePath);
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        FileOutputStream fos = null;
        ZipOutputStream zos = null;
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
        String fileName = dateFormat.format(new Date())+".zip";
        String zipFilePath = destinFilePath+File.separator+fileName;
        if (sourceFile.exists() == false) {
            System.out.println("待压缩的文件目录：" + sourceFilePath + "不存在.");
        } else {
            try {
                File zipFile = new File(zipFilePath);
                if (zipFile.exists()) {
                    System.out.println(zipFilePath + "目录下存在名字为:" + fileName + ".zip" + "打包文件.");
                } else {
                    File[] sourceFiles = sourceFile.listFiles();
                    if (null == sourceFiles || sourceFiles.length < 1) {
                        System.out.println("待压缩的文件目录：" + sourceFilePath + "里面不存在文件，无需压缩.");
                    } else {
                        //读取sourceFile下的所有文件
                        Vector<File> vector = FileUtil.getPathAllFiles(sourceFile, new Vector<File>()); 
                        fos = new FileOutputStream(zipFile);
                        zos = new ZipOutputStream(new BufferedOutputStream(fos));
                        byte[] bufs = new byte[1024 * 10];
                        
                        for (int i = 0; i < vector.size(); i++) {
                            // 创建ZIP实体，并添加进压缩包
                            ZipEntry zipEntry = new ZipEntry(vector.get(i).getName());//文件不可重名，否则会报错
                            zos.putNextEntry(zipEntry);
                            // 读取待压缩的文件并写进压缩包里
                            fis = new FileInputStream(vector.get(i));
                            bis = new BufferedInputStream(fis, 1024 * 10);
                            int read = 0;
                            while ((read = bis.read(bufs, 0, 1024 * 10)) != -1) {
                                zos.write(bufs, 0, read);
                            }
                        }
                    }
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            } catch (IOException e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            } finally {
                // 关闭流
                try {
                    if (null != bis)
                        bis.close();
                    if (null != zos)
                        zos.closeEntry();
                        zos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
        }
        return fileName;
    }
    
}