java文件上传Minio——文件、文件分片上传

短命女 2023-10-13 17:48 208阅读 0赞

本文主要介绍了文件上传——单\多文件分片上传；当然还有文件的md5值秒传、文件断点续传等内容，本文结合minio文件服务和redis做计数来实现的场景（下方地址是单机情况，即上传至本地demo）。有什么问题可以在留言哦！并在文章末尾附上demo源码下载！

大文件分片上传博文地址：大文件分片上传

大文件(md5分片)上传博文地址：大文件(md5分片)上传

大文件断点续传博文地址：大文件断点续传

一、创建前后端项目及演示

创建前后端项目，采用springboot项目结构，前端采用的vue框架搭建(前端完全是边用边百度，这里就不附前面项目结构，就一个页面)

c1ee31c1670a4844b703c44b93beafc7.png72553c20f59f4621bb4b2ddfbb700ba0.png后端控制台的输出日志4ccd1af8ccb0424d9f2748094198548f.png

minio文件服务上面的结果

关于minio的配置与基本使用：(37条消息) minio的基本使用——java_java使用minio_寒夜憨憨的博客-CSDN博客

f3c78f468b9e456a83e998f66e916be1.png

二、文件上传minio核心代码

其中包括了单文件上传minio和多文件分片上传minio;至于文件分片上传采用的是：先保存分片文件——>然后合并分片文件——>再删除分片文件;其实minio有自带的文件分片上传策略。

文件上传至minio，如果单纯的保存文件的话，其实可以直接采用前端去对接minio，然后当上传成功之后，返回上传至minio文件的相关信息给后端进行数据存储处理即可；这样上传文件就不要经过后端服务器了，减少数据处理环节。

1、minio配置信息核心代码

在代码的注释都详细说明了每一步是做什么的，如果不懂的可以详细看看每一步的注释，当然也可以留言！

  1. package com.jdh.fileUpload.config;
  3. import io.minio.*;
  4. import io.minio.errors.*;
  5. import io.minio.messages.Item;
  6. import lombok.*;
  7. import lombok.extern.slf4j.Slf4j;
  8. import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.http.MediaType;
  12. import org.springframework.mock.web.MockMultipartFile;
  13. import org.springframework.util.StringUtils;
  14. import org.springframework.web.multipart.MultipartFile;
  15. import io.minio.MinioClient;
  17. import javax.annotation.Resource;
  18. import java.io.*;
  19. import java.util.Objects;
  20. import java.util.UUID;
  22. /**
  23.  * @ClassName: minioConfig
  24.  * @Author: jdh
  25.  * @CreateTime: 2022-03-12
  26.  * @Description:
  27.  */
  28. @Slf4j
  29. @Data
  30. @Configuration
  31. @ConditionalOnProperty(prefix = "autoconfigure", value = "isMinio", matchIfMissing = false)
  32. public class MinioUtil {
  34.     private MinioClient minioClient;
  36.     @Resource
  37.     private MinioProperties minioProperties;
  39. //    @Autowired
  40. //    private MyMinioClient myMinioClient;
  43.     /**
  44.      * 获取一个连接minio服务端的客户端
  45.      *
  46.      * @return MinioClient
  47.      */
  48.     @Bean
  49.     public MinioClient getMinioClient() {
  51.         try {
  52.             String url = "http:" + minioProperties.getIp() + ":" + minioProperties.getPort();
  53.             MinioClient minioClient = MinioClient.builder()
  54.                     .endpoint(url)    //两种都可以,这种全路径的其实就是下面分开配置一样的
  55. //                        .endpoint(minioProperties.getIp(),minioProperties.getPort(),minioProperties.getSecure())
  56.                     .credentials(minioProperties.getAccessKey(), minioProperties.getSecretKey())
  57.                     .build();
  58.             this.minioClient = minioClient;
  59.             return minioClient;
  60.         } catch (Exception e) {
  61.             e.printStackTrace();
  62.             log.info("创建minio客户端失败！", e);
  63.             return null;
  64.         }
  65.     }
  67.     /**
  68.      * 创建桶
  69.      *
  70.      * @param bucketName 桶名称
  71.      */
  72.     public Boolean createBucket(String bucketName) throws Exception {
  73.         if (!StringUtils.hasLength(bucketName)) {
  74.             throw new RuntimeException("创建桶的时候，桶名不能为空！");
  75.         }
  76.         try {
  77.             minioClient.makeBucket(MakeBucketArgs.builder()
  78.                     .bucket(bucketName)
  79.                     .build());
  80.             return true;
  81.         } catch (Exception e) {
  82.             log.info("创建桶失败！", e);
  83.             return false;
  84.         }
  86.     }
  88.     /**
  89.      * 检查桶是否存在
  90.      *
  91.      * @param bucketName 桶名称
  92.      * @return boolean true-存在 false-不存在
  93.      */
  94.     public boolean checkBucketExist(String bucketName) throws Exception {
  95.         if (!StringUtils.hasLength(bucketName)) {
  96.             throw new RuntimeException("检测桶的时候，桶名不能为空！");
  97.         }
  99.         return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
  100.     }
  102.     /**
  103.      * 检测某个桶内是否存在某个文件
  104.      *
  105.      * @param objectName 文件名称
  106.      * @param bucketName 桶名称
  107.      */
  108.     public boolean getBucketFileExist(String objectName, String bucketName) throws Exception {
  109.         if (!StringUtils.hasLength(objectName) || !StringUtils.hasLength(bucketName)) {
  110.             throw new RuntimeException("检测文件的时候，文件名和桶名不能为空！");
  111.         }
  113.         try {
  114.             // 判断文件是否存在
  115.             return (minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build()) &&
  116.                     minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build()) != null);
  118.         } catch (ErrorResponseException e) {
  119.             log.info("文件不存在 ! Object does not exist");
  120.             return false;
  121.         } catch (Exception e) {
  122.             throw new Exception(e);
  123.         }
  124.     }
  126.     /**
  127.      * 删除文件夹
  128.      *
  129.      * @param bucketName 桶名
  130.      * @param objectName 文件夹名
  131.      * @param isDeep     是否递归删除
  132.      * @return
  133.      */
  134.     public Boolean deleteBucketFolder(String bucketName, String objectName, Boolean isDeep) {
  135.         if (!StringUtils.hasLength(bucketName) || !StringUtils.hasLength(objectName)) {
  136.             throw new RuntimeException("删除文件夹的时候，桶名或文件名不能为空！");
  137.         }
  138.         try {
  139.             ListObjectsArgs args = ListObjectsArgs.builder().bucket(bucketName).prefix(objectName + "/").recursive(isDeep).build();
  140.             Iterable<Result<Item>> listObjects = minioClient.listObjects(args);
  141.             listObjects.forEach(objectResult -> {
  142.                 try {
  143.                     Item item = objectResult.get();
  144.                     System.out.println(item.objectName());
  145.                     minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(item.objectName()).build());
  146.                 } catch (Exception e) {
  147.                     log.info("删除文件夹中的文件异常", e);
  148.                 }
  149.             });
  150.             return true;
  151.         } catch (Exception e) {
  152.             log.info("删除文件夹失败");
  153.             return false;
  154.         }
  155.     }
  157.     /**
  158.      * 文件上传文件
  159.      *
  160.      * @param file       文件
  161.      * @param bucketName 桶名
  162.      * @param objectName 文件名,如果有文件夹则格式为 "文件夹名/文件名"
  163.      * @return
  164.      */
  165.     public Boolean uploadFile(MultipartFile file, String bucketName, String objectName) {
  167.         if (Objects.isNull(file) || Objects.isNull(bucketName)) {
  168.             throw new RuntimeException("文件或者桶名参数不全！");
  169.         }
  171.         try {
  172.             //资源的媒体类型
  173.             String contentType = MediaType.APPLICATION_OCTET_STREAM_VALUE;//默认未知二进制流
  174.             InputStream inputStream = file.getInputStream();
  175.             PutObjectArgs args = PutObjectArgs.builder()
  176.                     .bucket(bucketName).object(objectName)
  177.                     .stream(inputStream, file.getSize(), -1)
  178.                     .contentType(file.getContentType())
  179.                     .build();
  180.             ObjectWriteResponse response = minioClient.putObject(args);
  181.             inputStream.close();
  182.             return response.etag() != null;
  183.         } catch (Exception e) {
  184.             log.info("单文件上传失败！", e);
  185.             return false;
  186.         }
  187.     }
  189.     /**
  190.      * 分片合并
  191.      *
  192.      * @param bucketName
  193.      * @param folderName
  194.      * @param objectName
  195.      * @param partNum
  196.      * @return
  197.      */
  198.     public Boolean uploadFileComplete(String bucketName, String folderName, String objectName, Integer partNum) {
  200.         try {
  201.             //获取临时文件下的所有文件信息
  202.             Iterable<Result<Item>> listObjects = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName).prefix(folderName + "/").build());
  204.             //计算minio中分片个数
  205.             Integer num = 0;
  206.             for (Result<Item> result : listObjects) {
  207.                 num++;
  208.             }
  209.             //在依次校验实际分片数和预计分片数是否一致
  210.             if (!num.equals(partNum)) {
  211.                 log.info("文件 {} 分片合并的时候，检测到实际分片数 {} 和预计分片数 {} 不一致", folderName, num, partNum);
  212.                 return false;
  213.             }
  215.             InputStream inputStream = null;
  216.             log.info("开始合并文件 {} 分片合并，实际分片数 {} 和预计分片数 {}", folderName, num, partNum);
  217.             for (int i = 0; i < num; i++) {
  218.                 String tempName = folderName + "/" + objectName.substring(0, objectName.lastIndexOf(".")) + "_" + i + ".temp";
  219.                 try {
  220.                     //获取分片文件流
  221.                     InputStream response = minioClient.getObject(
  222.                             GetObjectArgs.builder().bucket(bucketName).object(tempName).build());
  223.                     //流合并
  224.                     if (inputStream == null) {
  225.                         inputStream = response;
  226.                     } else {
  227.                         inputStream = new SequenceInputStream(inputStream, response);
  228.                     }
  229.                 } catch (Exception e) {
  230.                     log.info("读取分片文件失败！", e);
  231.                 }
  232.             }
  233.             if (inputStream == null) {
  234.                 log.info("合并流数据为空！");
  235.                 return false;
  236.             }
  237.             //转换为文件格式
  238.             MockMultipartFile file = new MockMultipartFile(objectName, inputStream);
  240.             //将合并的文件流写入到minio中
  241.             PutObjectArgs args = PutObjectArgs.builder()
  242.                     .bucket(bucketName).object(objectName)
  243.                     .stream(file.getInputStream(), file.getSize(), -1)
  244. //                    .contentType(file.getContentType())//这里可以不知道类型
  245.                     .build();
  246.             String etag = minioClient.putObject(args).etag();
  248.             // 删除临时文件
  249.             if (etag != null) {
  250.                 listObjects.forEach(objectResult -> {
  251.                     try {
  252.                         Item item = objectResult.get();
  253.                         minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(item.objectName()).build());
  254.                     } catch (Exception e) {
  255.                         log.info("删除文件夹中的文件异常", e);
  256.                     }
  257.                 });
  258.                 log.info("{}:临时文件夹文件已删除！", folderName);
  259.             }
  261.             inputStream.close();
  262.             return etag != null;
  263.         } catch (Exception e) {
  264.             log.info("合并 {} - {} 文件失败！", folderName, objectName, e);
  265.             return false;
  266.         }
  267.     }
  269.     public static String generateUniqueId(int length) {
  270.         UUID uuid = UUID.randomUUID();
  271.         String hash = uuid.toString().replaceAll("-", "");
  272.         return hash.substring(0, Math.min(length, hash.length()));
  273.     }
  275. }

2、文件上传minio的实现核心代码

  1. package com.jdh.fileUpload.service.fileUpload;
  3. import com.alibaba.fastjson2.JSONObject;
  4. import com.jdh.fileUpload.config.MinioUtil;
  5. import com.jdh.fileUpload.utils.Result;
  6. import com.jdh.fileUpload.utils.Uuid;
  7. import com.jdh.fileUpload.vo.PartFileIndexVo;
  8. import lombok.extern.slf4j.Slf4j;
  9. import org.redisson.api.RedissonClient;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
  12. import org.springframework.data.redis.core.RedisTemplate;
  13. import org.springframework.stereotype.Service;
  14. import org.springframework.web.multipart.MultipartFile;
  16. import javax.annotation.Resource;
  18. /**
  19.  * @ClassName: FileUploadMinioServiceImpl
  20.  * @Author: jdh
  21.  * @CreateTime: 2022-03-15
  22.  * @Description:
  23.  */
  24. @Slf4j
  25. @Service
  26. @ConditionalOnProperty(prefix = "autoconfigure", value = "isMinio", matchIfMissing = false)
  27. public class FileUploadMinioServiceImpl implements FileUploadMinioService {
  29.     @Autowired
  30.     private MinioUtil minioUtil;
  32.     @Resource
  33.     private RedissonClient redissonClient;
  35.     @Autowired
  36.     private RedisTemplate<String, Object> redisTemplate;
  38.     @Override
  39.     public Result<Boolean> fileUploadMinio(MultipartFile file) {
  40.         String objectName = Uuid.generateUniqueId(8) + "_" + file.getOriginalFilename();
  42.         try {
  43.             Boolean aBoolean = minioUtil.uploadFile(file, "minio-file", objectName);
  44.             log.info("文件上传是否完成：{}", aBoolean);
  45.             return Result.success(aBoolean, "文件上传完成！");
  46.         } catch (Exception e) {
  47.             log.info("文件上传异常！", e);
  48.             return Result.error(false, "文件上传异常！");
  49.         }
  50.     }
  52.     @Override
  53.     public Result<Boolean> filePartUploadMinio(MultipartFile file, String partFile) {
  55. //        String objectName = Uuid.generateUniqueId(8) + "_" + file.getOriginalFilename();
  56.         try {
  57.             PartFileIndexVo partFileIndexVo = JSONObject.parseObject(partFile, PartFileIndexVo.class);
  58.             String objectName = "temp/" + partFileIndexVo.getFileUid() + "/"
  59.                     + partFileIndexVo.getFileName().substring(0, partFileIndexVo.getFileName().lastIndexOf(".")) + "_"
  60.                     + partFileIndexVo.getPartIndex() + ".temp";
  61.             //上传文件分片
  62.             Boolean partState = minioUtil.uploadFile(file, "minio-file", objectName);
  64.             if (partState) {
  66.                 Long result = redisTemplate.opsForValue().increment("partCount:" + partFileIndexVo.getFileUid());
  68.                 if (result.equals(partFileIndexVo.getPartTotalNum().longValue())) {
  70.                     log.info("{}:开始合并分片请求...", partFileIndexVo.getFileName());
  71.                     //开始合并分片
  72.                     Boolean complete = minioUtil.uploadFileComplete("minio-file", "temp/" + partFileIndexVo.getFileUid(),
  73.                             partFileIndexVo.getFileName(), partFileIndexVo.getPartTotalNum());
  74.                     //移除文件分片上传情况，这个也应该在redis中
  75.                     Boolean delete = false;
  76.                     if (complete) {
  77.                         delete = redisTemplate.delete("partCount:" + partFileIndexVo.getFileUid());
  78.                         log.info("{}:分片文件合并完成！", partFileIndexVo.getFileName());
  79.                     }
  80.                     return Result.success(complete && delete, partFileIndexVo.getFileUid());
  81.                 }
  82.             }
  83.             return Result.success(partState, partFileIndexVo.getPartIndex().toString());
  84.         } catch (Exception e) {
  85.             log.info("文件上传异常！", e);
  86.             return Result.error("文件上传异常！");
  87.         }
  88.     }
  90. }

3、关于相关前端核心代码

页面代码

  1. <!-- 单文件上传Minio -->
  2.             <div class="singleFileUploadMinio">
  3.                 <el-upload  ref="upload" name="files" action="#"
  4.                     :on-change="selectSingleFileMinio" :on-remove="removeSingleFileMinio" :file-list="singleFileMinio.fileList" :auto-upload="false">
  5.                     <el-button slot="trigger" size="small" type="primary">选取文件</el-button>
  6.                     <el-button style="margin-left: 10px;" size="small" type="success" @click="singleFileUploadMinio">点击进行单文件分片上传Minio</el-button>
  7.                     <div slot="tip" class="el-upload__tip">主要用于测试单文件上传Minio</div>
  8.                 </el-upload>
  9.             </div>
  10.              <!-- 多文件分片上传Minio -->
  11.              <div class="multipleFilePartUploadMinio">
  12.                 <el-upload ref="upload" name="files" action="#"
  13.                     :on-change="selectMultiplePartFileMinio" :on-remove="removeMultiplePartFileMinio" :file-list="multipleFilePartMinio.fileList" :auto-upload="false">
  14.                     <el-button slot="trigger" size="small" type="primary">选取文件</el-button>
  15.                     <el-button style="margin-left: 10px;" size="small" type="success" @click="multipleFilePartUploadMinio">点击进行多文件分片上传Minio</el-button>
  16.                     <div slot="tip" class="el-upload__tip">主要用于测试多文件分片上传Minio</div>
  17.                 </el-upload>
  18.             </div>

数据定义组件代码

  1. data() {
  2.         return {
  3.             urlPrefix: 'http://localhost:8082',
  4.             headers: {
  5.                 'Content-Type': 'multipart/form-data'
  6.             },
  7.             singleFileMinio: {
  8.                 file: '',
  9.                 fileList: []
  10.             },
  11.             multipleFilePartMinio: {
  12.                 fileList: [],
  13.                 fileData: []
  14.             },
  15.         };
  16.     },

各方法代码

  1. methods: {
  2.     // 下面是单文件上传Minio的一些方法
  3.     selectSingleFileMinio(file, fileList){
  4.         this.singleFileMinio.file = file
  5.         this.singleFileMinio.fileList = []
  6.         this.singleFileMinio.fileList.push(file)
  7.         console.log("单文件上传Minio->选中的文件：",this.singleFileMinio.file)
  8.     },
  9.     removeSingleFileMinio(file, fileList){
  10.         this.singleFileMinio.file = ''
  11.         console.log("单文件上传Minio->移除选中的文件：",this.singleFileMinio.file)
  12.     },
  13.     singleFileUploadMinio(){
  14.         let url = this.urlPrefix + "/minio/singleFileUploadMinio";
  15.         var fileParam = new FormData();
  16.         fileParam.append("file",this.singleFileMinio.file.raw);
  18.         this.$upFile(url,fileParam,null,resp => {
  19.             let res = resp.data;
  20.             if (res.data){
  21.                 this.$message.success(res.msg)
  22.             }else{
  23.                 this.$message.error(res.msg)
  24.             }
  25.         })
  26.     },
  27.     // 下面多文件分片上传Minio的一些方法
  28.     selectMultiplePartFileMinio(file, fileList){
  29.         this.multipleFilePartMinio.fileList.push(file)
  30.         console.log("多文件分片上传->选中的文件：",this.multipleFilePartMinio.fileList)
  31.     },
  32.     removeMultiplePartFileMinio(file, fileList){
  33.         this.multipleFilePartMinio.fileList = this.multipleFilePartMinio.fileList.filter(item => item.uid != file.uid);
  34.         console.log("多文件分片上传->移除选中的文件：",this.multipleFilePartMinio.fileList)
  35.     },
  36.     multipleFilePartUploadMinio(){
  37.         let fileUploadCount = 0;
  38.         let url = this.urlPrefix + "/minio/partFileUploadMinio";
  39.         let partSize = 8; //MB
  40.         let partFileUid = [];
  41.         for(let i = 0; i < this.multipleFilePartMinio.fileList.length; i++ ){
  42.             let partNum = Math.ceil(this.multipleFilePartMinio.fileList[i].size / 1024 / 1024 / partSize)
  43.             let partFileIndex = {
  44.                 fileName: this.multipleFilePartMinio.fileList[i].name,
  45.                 fileUid: this.multipleFilePartMinio.fileList[i].uid,
  46.                 partTotalNum: partNum,
  47.                 partIndex: ''
  48.             }
  49.             partFileUid.push(this.multipleFilePartMinio.fileList[i].uid + '')
  50.             for(let j = 0; j < partNum; j++ ){
  51.                 partFileIndex.partIndex = j
  52.                 var fileParam = new FormData();
  53.                 fileParam.append('file', this.multipleFilePartMinio.fileList[i].raw.slice(j * 1024 * 1024 * partSize, (j + 1) * 1024 * 1024 * partSize))
  54.                 fileParam.append('partFileIndex', JSON.stringify(partFileIndex))
  56.                 this.$upFile(url,fileParam,null,resp => {
  57.                     let res = resp.data;
  58.                     //判断最后一个分片文件传完之后，后台检验文件上传情况
  59.                     if (res.code == 200){
  61.                         if(!res.data){
  62.                             var info = '当前分片上传Minio失败!uid:' + partFileUid + ';当前分片:' + j + ';返回分片:' + res.msg
  63.                             console.log(info)
  64.                         }
  66.                         let isUid = partFileUid.includes(res.msg)
  67.                         if(isUid){
  68.                             fileUploadCount ++;
  69.                             if(fileUploadCount == this.multipleFilePartMinio.fileList.length){
  70.                                 console.log('多文件分片上传Minio完成')
  71.                                 this.$message.success('多文件分片上传Minio完成')
  72.                             }
  73.                         }
  74.                     }else{
  75.                         var info = '多文件分片上传Minio失败!当前分片:' + j + ';当前uid:' + partFileUid
  76.                         console.log(info)
  77.                         this.$message.error(res.msg)
  78.                     }
  79.                 })
  80.             }
  81.         }
  82.     }
  83.   },

三、源码下载和结尾

源码默认只有上传本地的各种demo方案，如果需要打开上传至minio的话，需要再配置文件修改配置文件，如下：

521e04982ce14b9fbe6419cdc416f012.png

gitee后端链接：java_fileUpload_demo: 关于文件上传的一些基本介绍（如文件上传、分片上传、md5值秒传、断点续传等）

gitee前端链接：https://gitee.com/java_utils_demo/vue2_demo.git

其实思路很简单也很明确，就是一个大文件分成n个小文件进行小文件依次单独上传，后端检测到所有分片上传完成之后，即对这些分片进行合并，并删除对应临时分片文件。

再次说明下，如果需要上传至minio，那么需要先配置好minio和redis并启动这两个服务，然后再启动demo项目。

发表评论

表情：
评论列表 （有 0 条评论，208人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java实现文件分片上传

    起因：最近在工作中接到了一个大文件上传下载的需求，要求将文件上传到share盘中，下载的时候根据前端传的不同条件对单个或多个文件进行打包并设置目录下载。 一开始我想着就还是用

    缺乏、安全感缺乏、安全感/ 0 赞/ 87 阅读