java下载文件夹

朴灿烈づ我的快乐病毒、 2022-11-29 11:24 283阅读 0赞

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

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;
        }
        
    }