webuploader 实现文件断点续传

Dear 丶 2022-06-03 07:54 378阅读 0赞

先去下载webuploader

只需要将下面4个文件添加到工程里面就可以了

![这里写图片描述][SouthEast]

@Controller
    @RequestMapping(value = "${adminPath}/recorder/data")
    public class UploadAndDownloadController extends BaseController { 
    
        private static final String FILE_UPLOAD = "upload";
    
        private static final Logger logger = LoggerFactory.getLogger(UploadAndDownloadController.class);
    
        @RequiresPermissions("recorder:data:upload")
        @RequestMapping(value = "uploadList")
        public String uploadList(HttpServletRequest request, HttpServletResponse response, Model model) {
            return "modules/evrms/uploadAndDownload/fileUpload";
        }
    
        @RequiresPermissions("recorder:data:download")
        @RequestMapping(value = "downloadList")
        public String downloadList(HttpServletRequest request, HttpServletResponse response, Model model) {
            String fileName = request.getRealPath("/") + "/upload/";
            File destFile = new File(fileName);
            if (!destFile.exists()) {
                model.addAttribute("fileNameList", new ArrayList<>());
                return "modules/evrms/uploadAndDownload/fileDownload";
            }
            File[] files = ObjectUtils.listOnlyFiles(destFile);
            List<File> fileList = new ArrayList<>(Arrays.asList(files));
            // 将文件按最后修改时间倒序排
            Collections.sort(fileList, new Comparator<File>() {
    
                @Override
                public int compare(File o1, File o2) {
                    if (o1.lastModified() < o2.lastModified()) {
                        return -1;
                    }
                    return 1;
                }
            });
            List<String> fileNameList = new ArrayList<>();
            for (File file : fileList) {
                fileNameList.add(file.getName());
            }
            model.addAttribute("fileNameList", fileNameList);
            return "modules/evrms/uploadAndDownload/fileDownload";
        }
    
        @RequiresPermissions("recorder:data:upload")
        @RequestMapping(value = "mergeOrCheckChunks")
        @ResponseBody
        public String mergeOrCheckChunks(HttpServletRequest request, HttpServletResponse response, Model model) {
            String param = request.getParameter("param");
            String fileName = request.getParameter("fileName");
    
            String savePath = request.getRealPath("/");
            // 文件上传的临时文件保存在项目的temp文件夹下
            savePath = new File(savePath) + "/upload/";
            String json = Constants.EMPTY;
            if (param.equals("mergeChunks")) {
                // 合并文件
                try {
                    // 读取目录里的所有文件
                    File f = new File(savePath + "/" + CacheUtils.get(FILE_UPLOAD, "fileName_" + fileName));
                    // 排除目录,只要文件
                    File[] fileArray = ObjectUtils.listOnlyFiles(f);
    
                    // 转成集合，便于排序
                    List<File> fileList = new ArrayList<File>(Arrays.asList(fileArray));
    
                    Collections.sort(fileList, new Comparator<File>() {
    
                        @Override
                        public int compare(File o1, File o2) {
                            if (Integer.parseInt(o1.getName()) < Integer.parseInt(o2.getName())) {
                                return -1;
                            }
                            return 1;
                        }
                    });
    
                    // 截取文件名的后缀名
                    int pointIndex = fileName.lastIndexOf(".");
                    // 后缀名
                    String suffix = fileName.substring(pointIndex);
                    // 合并后的文件
                    File outputFile = new File(savePath + "/" + fileName);
                    // 创建文件
                    try {
                        outputFile.createNewFile();
                    } catch (IOException e) {
                        logger.error("IO Exception：", e);
                    }
                    FileChannel outChannel = new FileOutputStream(outputFile).getChannel();
                    // 合并
                    FileChannel inChannel;
                    for (File file : fileList) {
                        inChannel = new FileInputStream(file).getChannel();
                        try {
                            inChannel.transferTo(0, inChannel.size(), outChannel);
                        } catch (IOException e) {
                            logger.error("IO Exception：", e);
                        }
                        try {
                            inChannel.close();
                        } catch (IOException e) {
                            logger.error("IO Exception：", e);
                        }
                        // 删除分片
                        file.delete();
                    }
                    try {
                        outChannel.close();
                    } catch (IOException e) {
                        logger.error("IO Exception：", e);
                    }
    
                    // 清除文件夹
                    File tempFile = new File(savePath + "/" + CacheUtils.get(FILE_UPLOAD, "fileName_" + fileName));
                    if (tempFile.isDirectory() && tempFile.exists()) {
                        tempFile.delete();
                    }
    
                    Map<String, String> resultMap = new HashMap<>();
                    // 将文件的最后上传时间和生成的文件名返回
                    resultMap.put("lastUploadTime",
                            ObjectUtils.toString(CacheUtils.get(FILE_UPLOAD, "lastUploadTime_" + fileName)));
                    resultMap.put("pathFileName", CacheUtils.get(FILE_UPLOAD, "fileName_" + fileName) + suffix);
    
                    // 合并成功后删除缓存中的进度信息
                    CacheUtils.remove(FILE_UPLOAD, "jindutiao_" + fileName);
                    // 合并成功后删除缓存中的最后上传时间，只存没上传完成的
                    CacheUtils.remove(FILE_UPLOAD, "lastUploadTime_" + fileName);
                    // 合并成功后删除文件名称与该文件上传时生成的存储分片的临时文件夹的名称在缓存中的信息
                    CacheUtils.remove(FILE_UPLOAD, "fileName_" + fileName);
    
                    json = JsonMapper.getInstance().toJson(resultMap);
    
                } catch (Exception e) {
                    logger.error("file merge failure:", e);
                }
            } else if (param.equals("checkChunk")) {
                // 检查当前分块是否上传成功
                String fileMd5 = request.getParameter("fileMd5");
                String chunk = request.getParameter("chunk");
                String chunkSize = request.getParameter("chunkSize");
                String jindutiao = request.getParameter("jindutiao");// 文件上传的实时进度
    
                try {
                    // 将当前进度存入缓存
                    CacheUtils.put(FILE_UPLOAD, "jindutiao_" + fileName, jindutiao);
    
                    // 将系统当前时间转换为字符串
                    String lastUploadTime = ObjectUtils.dateToString(new Date(), "yyyy-MM-dd HH:mm:ss");
                    // 将最后上传时间以字符串形式存入缓存
                    CacheUtils.put(FILE_UPLOAD, "lastUploadTime_" + fileName, lastUploadTime);
    
                    String tempFileName = ObjectUtils.toString(System.currentTimeMillis());
                    if (ObjectUtils.isNull(CacheUtils.get(FILE_UPLOAD, "fileName_" + fileName))) {
                        // 将文件名与该文件上传时生成的存储分片的临时文件夹的名称存入缓存
                        // 文件上传时生成的存储分片的临时文件夹的名称由MD5和时间戳组成
                        CacheUtils.put(FILE_UPLOAD, "fileName_" + fileName, fileMd5 + tempFileName);
                    }
    
                    File checkFile = new File(
                            savePath + "/" + CacheUtils.get(FILE_UPLOAD, "fileName_" + fileName) + "/" + chunk);
    
                    // 检查文件是否存在，且大小是否一致
                    if (checkFile.exists() && checkFile.length() == Integer.parseInt(chunkSize)) {
                        // 上传过
                        json = "{\"ifExist\":1}";
                    } else {
                        // 没有上传过
                        json = "{\"ifExist\":0}";
                    }
                } catch (Exception e) {
                    logger.error("file check failure:", e);
                }
            }
            return json;
        }
    
        @RequiresPermissions("recorder:data:upload")
        @RequestMapping(value = "fileSave")
        // 保存上传分片
        public void fileSave(HttpServletRequest request, HttpServletResponse response) {
            DiskFileItemFactory factory = new DiskFileItemFactory();
            ServletFileUpload sfu = new ServletFileUpload(factory);
            sfu.setHeaderEncoding("utf-8");
    
            String savePath = request.getRealPath("/");
            savePath = new File(savePath) + "/upload/";
    
            String fileMd5 = null;
            // 小于10m的文件FileItem.getFieldName()是得不到chunk的，所以此处不能是空字符串，否则创建文件时会出错
            String chunk = null;
            String fileName = null;
            try {
                List<FileItem> items = sfu.parseRequest(request);
    
                for (FileItem item : items) {
                    // 上传文件的真实名称
                    fileName = item.getName();
                    if (item.isFormField()) {
                        String fieldName = item.getFieldName();
                        if (fieldName.equals("fileMd5")) {
                            try {
                                fileMd5 = item.getString("utf-8");
                            } catch (UnsupportedEncodingException e) {
                                logger.error("encoding cast failure:", e);
                            }
                        }
                        if (fieldName.equals("chunk")) {
                            try {
                                chunk = item.getString("utf-8");
                            } catch (UnsupportedEncodingException e) {
                                logger.error("encoding cast failure:", e);
                            }
                        }
                    } else {
                        try {
                            File file = new File(savePath + "/" + CacheUtils.get(FILE_UPLOAD, "fileName_" + fileName));
                            if (!file.exists()) {
                                file.mkdir();
                            }
                            File chunkFile = new File(
                                    savePath + "/" + CacheUtils.get(FILE_UPLOAD, "fileName_" + fileName) + "/" + chunk);
                            FileUtils.copyInputStreamToFile(item.getInputStream(), chunkFile);
                        } catch (Exception e) {
                            logger.error("IO Exception：", e);
                        }
                    }
                }
            } catch (FileUploadException e) {
                logger.error("file upload failure:", e);
            }
        }
    
        @RequiresPermissions("recorder:data:upload")
        @RequestMapping(value = "selectProgressByFileName")
        @ResponseBody
        // 当有文件添加进队列时 通过文件名查看该文件是否上传过 上传进度是多少
        public String selectProgressByFileName(String fileName) {
            String jindutiao = Constants.EMPTY;
            if (ObjectUtils.isNotNull(fileName)) {
                jindutiao = ObjectUtils.toString(CacheUtils.get(FILE_UPLOAD, "jindutiao_" + fileName));
            }
            return "{jindutiao :'" + jindutiao + "'}";
        }
    
        @RequiresPermissions("recorder:data:download")
        @RequestMapping(value = "downFile")
        public String downFile(HttpServletResponse response, HttpServletRequest request,
                RedirectAttributes redirectAttributes) {
            try {
                String fileName = request.getParameter("fileName");
                File file = new File(request.getRealPath("/") + "/upload/" + fileName);
                if (!file.exists()) {
                    addMessage(redirectAttributes, "您要下载的资源已被删除！");
                    return "redirect:" + GlobalConfig.getAdminPath() + "/recorder/data/downloadList/?repage";
                }
                download(response, request, file);
            } catch (Exception e) {
                logger.error("file download failure：", e);
            }
            return null;
        }
    
        private void download(HttpServletResponse response, HttpServletRequest request, File file) {
            InputStream in = null;
            ServletOutputStream out = null;
            try {
                int fSize = Integer.parseInt(String.valueOf(file.length()));
                response.setCharacterEncoding("utf-8");
                response.setContentType("application/x-download");
                response.setHeader("Accept-Ranges", "bytes");
                response.setHeader("Content-Length", String.valueOf(fSize));
                // 防止中文乱码
                response.setHeader("Content-Disposition",
                        "attachment;fileName=" + new String(file.getName().getBytes(), "ISO-8859-1"));
                in = new FileInputStream(file);
                long pos = 0;
                if (null != request.getHeader("Range")) {
                    // 断点续传
                    response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);
                    try {
                        pos = Long.parseLong(request.getHeader("Range").replaceAll("bytes=", "").replaceAll("-", ""));
                    } catch (NumberFormatException e) {
                        pos = 0;
                    }
                }
                out = response.getOutputStream();
                String contentRange = new StringBuffer("bytes ").append(pos + "").append("-").append((fSize - 1) + "")
                        .append("/").append(fSize + "").toString();
                response.setHeader("Content-Range", contentRange);
                in.skip(pos);
                byte[] buffer = new byte[1024 * 10];
                int length = 0;
                while ((length = in.read(buffer, 0, buffer.length)) != -1) {
                    out.write(buffer, 0, length);
                }
            } catch (Exception e) {
                logger.error("file download failure：", e);
            } finally {
                try {
                    if (null != out) {
                        out.flush();
                        out.close();
                    }
                    if (null != in) {
                        in.close();
                    }
                } catch (IOException e) {
                    logger.error("IO Exception：", e);
                }
            }
        }

[SouthEast]: /images/20220603/5b6f1c37907b456898056881a20ad6d3.png