Java当中实现分片上传

迈不过友情╰ 2023-10-15 16:02 57阅读 0赞

## Java当中实现分片上传 ##

#### 文章目录 ####

*  Java当中实现分片上传
 *   *  一：背景
     *  二：解决方案
     *   *  1、整体方案
         *  2、代码实例
         *  3、说明
         *  4、FileUtil中的方法

### 一：背景 ###

Web端实现大文件上传下载的需求，要求将文件上传到对象存储当中，大文件上传有以下痛点：

1.  文件上传超时：原因是前端请求框架限制最大请求时长，后端设置了接口访问的超时时间，或者是 nginx（或其它代理/网关） 限制了最大请求时长。
2.  文件大小超限：原因在于后端对单个请求大小做了限制，一般 nginx 和 server 都会做这个限制。
3.  上传时间过久
4.  由于各种网络原因上传失败，且失败之后需要从头开始。

### 二：解决方案 ###

#### 1、整体方案 ####

1.前端根据代码中设置好的分片大小将上传的文件切成若干个小文件，分多次请求依次上传，后端再将文件碎片拼接为一个完整的文件，然后再去进行上传

2.如果需要某个碎片上传失败，也不会影响其它文件碎片，只需要重新上传失败的部分就可以了，则需要设计一个表去维护上传的切片相关的一些信息

#### 2、代码实例 ####

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class ShardingFileDTO {
        //文件名称(包含文件后缀)
        private String fileName;
        //文件总大小 MB
        private String size;
        //文件总分片数
        private int shardTotal;
        //分片文件索引下标
        private int shardIndex;
        //文件后缀，视频后缀为mp4,图片则为jpg等
        private String suffix;
        //唯一标识
        private String onlyCode;
    }

![image-20230904093947026][]

package com.xxy.demotest.controller.ShardingFile;
    
    import cn.hutool.core.util.IdUtil;
    import com.alibaba.fastjson.JSON;
    import com.xxy.demotest.controller.ShardingFile.model.ShardingFileDTO;
    import com.xxy.demotest.haikang.aliyun.ALiYun;
    import com.xxy.demotest.result.baseresult.BaseResponse;
    import com.xxy.demotest.utils.WorkUtil.FileUtil;
    import lombok.RequiredArgsConstructor;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.collections.CollectionUtils;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.multipart.MultipartFile;
    
    import java.io.*;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /**
     * @beLongProjecet: demo-test
     * @beLongPackage: com.xxy.demotest.controller.ShardingFile
     * @author: xxx
     * @createTime: 2023/09/01 15:16
     * @description: 分片文件上传
     * @version: v1.0
     */
    @RestController
    @RequestMapping("sharding")
    @RequiredArgsConstructor
    @Slf4j
    public class ShardingFileController {
    
        public static final String shardPath="D:\\test\\sharding\\";
        public static final String savePath="D:\\test\\save\\";
    
        private static void excuteFile(ShardingFileDTO dto, MultipartFile multipartFile) throws IOException {
            log.info("文件分片上传请求开始,请求参数: {}", JSON.toJSONString(dto));
            //获取本地文件夹地址
            String fileFolderPath = savePath + dto.getOnlyCode();
            log.info("本地文件夹地址,fileFolder的值为:{}", fileFolderPath);
            //如果目标文件夹不存在，则直接创建一个
            FileUtil.createFolder(fileFolderPath);
    
            //本地文件全路径
            String fileFullPath =fileFolderPath + File.separator+ dto.getFileName()+"_"+ dto.getShardIndex()+"."+ dto.getSuffix();
            log.info("本地文件全路径,fileFullPath的值为:{}", fileFullPath);
            //将分片文件保存到指定路径
            multipartFile.transferTo(new File(fileFullPath));
            //更新到文件上传表中
            //判断当前分片索引是否等于分片总数，如果等于分片总数则执行文件合并
            if (dto.getShardIndex()==dto.getShardTotal()) {
                //文件合并
                log.info("文件分片合并开始");
                File dirFile = new File(fileFolderPath);
                if (!dirFile.exists()) {
                    throw new RuntimeException("文件不存在");
                }
                //分片上传的文件已经位于同一个文件夹下，方便寻找和遍历（当文件数大于十的时候记得排序用冒泡排序确保顺序是正确的）
                List<String> filePaths = FileUtil.listFiles(fileFolderPath);
                if (CollectionUtils.isNotEmpty(filePaths)) {
                    //将此里面文件按照索引进行排序
                    log.info("filePaths的值为:{}", filePaths);
                    // 使用自定义的Comparator来对文件路径进行排序
                    Collections.sort(filePaths, new FilePathComparator());
                    //进行合并,顺序按照索引进行合并
                    String mergedFilePath =fileFolderPath+File.separator+dto.getFileName();
                    log.info("生成新的文件的路径,mergedFilePath的值为:{}", mergedFilePath);
                    mergeFiles(filePaths, mergedFilePath);
                    //合并完成将新文件上传到对象存储中
                    String upload = ALiYun.upload(FileUtil.fileToMultipartFile(new File(mergedFilePath)));
                    log.info("文件最终访问地址,upload的值为:{}", upload);
                    //可以异步
                    //删除所有临时切片文件
                    deleteFolderAndSubfolders(fileFolderPath);
                    //删除所有切片
                    deleteFolderAndSubfolders(shardPath+dto.getOnlyCode());
                }
    
            }
        }
    
    
        public static void main(String[] args) {
    
            String fastUUID = IdUtil.fastSimpleUUID();
            //String sourceFilePath = "C:\\Users\\wonder\\Desktop\\ai测试图片\\切片文件上传\\metacosmic_conference.zip"; // 源文件路径
            String sourceFilePath = "C:\\Users\\wonder\\Desktop\\ai测试图片\\人像.png"; // 源文件路径
            String outputDirectory = shardPath + fastUUID;
            FileUtil.createFolder(outputDirectory);
    
            //封装dto参数
            ShardingFileDTO shardingFileDTO = new ShardingFileDTO();
            shardingFileDTO.setFileName(new File(sourceFilePath).getName());
            shardingFileDTO.setSize("10MB");
    
            shardingFileDTO.setSuffix(getFileExtension(sourceFilePath));
            shardingFileDTO.setOnlyCode(fastUUID);
            long sliceSize = 5 * 1024 * 1024; // 切片大小，这里设置为5MB
            try {
                File sourceFile = new File(sourceFilePath);
                String fileName = sourceFile.getName();
                int lastDotIndex = fileName.lastIndexOf('.');
                String suffix = fileName.substring(lastDotIndex + 1);
    
                long fileSize = sourceFile.length(); // 获取文件大小
                int sliceNumber = (int) Math.ceil((double) fileSize / sliceSize); // 计算切片数量
                log.info("共切割成 " + sliceNumber + " 个文件切片");
                shardingFileDTO.setShardTotal(sliceNumber);
                FileInputStream fis = new FileInputStream(sourceFile);
    
                byte[] buffer = new byte[(int) sliceSize];
                int bytesRead;
                List<String> sliceFilePaths = new ArrayList<>();
    
                for (int i = 0; i < sliceNumber; i++) {
                    int num = i + 1;
                    shardingFileDTO.setShardIndex(num);
    
                    String sliceFileName = "slice_" + num;
                    String sliceFilePath = outputDirectory + File.separator + sliceFileName+"."+suffix;
                    // 创建切片文件并写入数据
                    FileOutputStream fos = new FileOutputStream(sliceFilePath);
                    bytesRead = fis.read(buffer, 0, (int) sliceSize);
                    fos.write(buffer, 0, bytesRead);
                    fos.close();
                    sliceFilePaths.add(sliceFilePath);
    
                    File file = new File(sliceFilePath);
                    excuteFile(shardingFileDTO,FileUtil.fileToMultipartFile(file));
    
                }
                fis.close();
    
    
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 合并成新的文件
         * @param filePaths
         * @param mergedFilePath
         */
        public static void mergeFiles(List<String> filePaths, String mergedFilePath) {
            try (FileOutputStream fos = new FileOutputStream(mergedFilePath);
                 BufferedOutputStream bos = new BufferedOutputStream(fos)) {
                for (String filePath : filePaths) {
                    try (FileInputStream fis = new FileInputStream(filePath);
                         BufferedInputStream bis = new BufferedInputStream(fis)) {
                        byte[] buffer = new byte[1024];
                        int bytesRead;
                        while ((bytesRead = bis.read(buffer)) != -1) {
                            bos.write(buffer, 0, bytesRead);
                        }
                    }
                }
                log.info("文件合并完成");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        /**
         * 获取文件扩展名
         * @param fileName
         * @return
         */
        public static String getFileExtension(String fileName) {
            int lastDotIndex = fileName.lastIndexOf('.');
            if (lastDotIndex > 0) {
                return fileName.substring(lastDotIndex + 1);
            }
            return ""; // 如果文件名中没有点，返回空字符串
        }
    
        /**
         * 删除文件夹下所有的文件
         * @param folderPath
         */
        public static void deleteFilesInFolder(String folderPath) {
            File folder = new File(folderPath);
    
            // 检查文件夹是否存在
            if (!folder.exists() || !folder.isDirectory()) {
                System.out.println("指定的路径不是一个有效的文件夹.");
                return;
            }
    
            File[] files = folder.listFiles();
    
            if (files != null) {
                for (File file : files) {
                    if (file.isFile()) {
                        // 删除文件
                        if (file.delete()) {
                            System.out.println("已删除文件: " + file.getName());
                        } else {
                            System.out.println("无法删除文件: " + file.getName());
                        }
                    }
                }
            }
        }
    
        /**
         * 删除文件夹
         * @param folderPath
         */
        public static void deleteFolder(String folderPath) {
            File folder = new File(folderPath);
    
            // 删除文件夹
            if (folder.exists() && folder.isDirectory()) {
                if (folder.delete()) {
                    System.out.println("已删除文件夹: " + folderPath);
                } else {
                    System.out.println("无法删除文件夹: " + folderPath);
                }
            }
        }
    
        /**
         * 删除文件夹中所有文件和子文件夹
         * @param folderPath
         */
        public static void deleteFolderAndSubfolders(String folderPath) {
            File folder = new File(folderPath);
    
            // 检查文件夹是否存在
            if (!folder.exists()) {
                System.out.println("文件夹不存在.");
                return;
            }
    
            if (folder.isDirectory()) {
                File[] files = folder.listFiles();
    
                if (files != null) {
                    for (File file : files) {
                        if (file.isDirectory()) {
                            // 递归删除子文件夹及其内容
                            deleteFolderAndSubfolders(file.getAbsolutePath());
                        } else {
                            // 删除文件
                            if (file.delete()) {
                                System.out.println("已删除文件: " + file.getName());
                            } else {
                                System.out.println("无法删除文件: " + file.getName());
                            }
                        }
                    }
                }
            }
    
            // 删除文件夹本身
            if (folder.delete()) {
                System.out.println("已删除文件夹: " + folderPath);
            } else {
                System.out.println("无法删除文件夹: " + folderPath);
            }
        }
    
    }
    class FilePathComparator implements Comparator<String> {
        private static final Pattern NUMBER_PATTERN = Pattern.compile("\\d+");
    
        @Override
        public int compare(String filePath1, String filePath2) {
            int number1 = extractNumber(filePath1);
            int number2 = extractNumber(filePath2);
            return Integer.compare(number1, number2);
        }
    
        private int extractNumber(String filePath) {
            Matcher matcher = NUMBER_PATTERN.matcher(filePath);
            if (matcher.find()) {
                return Integer.parseInt(matcher.group());
            }
            return 0; // 如果找不到数字，则返回0或其他适当的默认值
        }
    }

#### 3、说明 ####

后端如果一个个调用请求有点麻烦，所以用了一个main方法做下说明，执行的流程为：

**程序切片–>保存切片（前端上传）–>上传最后一个切片的时候执行文件合并（后端根据条件索引合并）–>合并完成–>执行上传对象存储–>删除切片文件–>接口响应链接**

注意：

正常的接口请求当中需要对excuteFile稍微做下改造，省略掉切片的环节即可；

#### 4、FileUtil中的方法 ####

/**
         * 创建文件夹
         *
         * @param path
         */
        public static void createFolder(String path) {
            File folder = new File(path);
            if (!folder.exists()) {
                folder.mkdirs();
            }
        }
        
        
         /**
         * 获取当前文件夹下面的文件列表
         *
         * @param folderPath
         * @return
         */
        public static List<String> listFiles(String folderPath) {
            List<String> objects = new ArrayList<>();
            File folder = new File(folderPath);
            File[] files = folder.listFiles();
            if (files != null) {
                for (File file : files) {
                    if (file.isFile()) {
                        objects.add(file.getAbsolutePath());
                    } else if (file.isDirectory()) {
                        listFiles(file.getAbsolutePath());
                    }
                }
            }
            return objects;
        }
        
          /**
         * File转换为MultipartFile
         * @param file
         * @return
         */
        public static MultipartFile fileToMultipartFile(File file) {
            FileItem item = new DiskFileItemFactory().createItem("file"
                    , MediaType.MULTIPART_FORM_DATA_VALUE
                    , true
                    , file.getName());
            try (InputStream input = new FileInputStream(file);
                 OutputStream os = item.getOutputStream()) {
                // 流转移
                IOUtils.copy(input, os);
            } catch (Exception e) {
                throw new IllegalArgumentException("Invalid file: " + e, e);
            }
    
            return new CommonsMultipartFile(item);
        }

参考：[Java实现文件分片上传][Java]

[image-20230904093947026]: https://img-blog.csdnimg.cn/img_convert/92b29e3be91496dff70faab2cfa5f511.png
[Java]: https://blog.csdn.net/qq_43842093/article/details/129233462?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522169355077816800182145376%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=169355077816800182145376&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~baidu_landing_v2~default-1-129233462-null-null.142%5Ev93%5Ekoosearch_v1&utm_term=java%E4%B8%AD%E5%AE%9E%E7%8E%B0%E5%88%86%E7%89%87%E4%B8%8A%E4%BC%A0&spm=1018.2226.3001.4187