devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：Monodyee | 2024-02-18 22:20:53

赞

踩

java minio

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

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

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

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

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

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

后端控制台的输出日志

minio文件服务上面的结果

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

二、文件上传minio核心代码 

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

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

1、minio配置信息核心代码

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

  1. package com.jdh.fileUpload.config;
  2.  
  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;
  16.  
  17. import javax.annotation.Resource;
  18. import java.io.*;
  19. import java.util.Objects;
  20. import java.util.UUID;
  21.  
  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 {
  33.  
  34.     private MinioClient minioClient;
  35.  
  36.     @Resource
  37.     private MinioProperties minioProperties;
  38.  
  39. //    @Autowired
  40. //    private MyMinioClient myMinioClient;
  41.  
  42.  
  43.     /**
  44.      * 获取一个连接minio服务端的客户端
  45.      *
  46.      * @return MinioClient
  47.      */
  48.     @Bean
  49.     public MinioClient getMinioClient() {
  50.  
  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.     }
  66.  
  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.         }
  85.  
  86.     }
  87.  
  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.         }
  98.  
  99.         return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
  100.     }
  101.  
  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.         }
  112.  
  113.         try {
  114.             // 判断文件是否存在
  115.             return (minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build()) &&
  116.                     minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build()) != null);
  117.  
  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.     }
  125.  
  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.     }
  156.  
  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) {
  166.  
  167.         if (Objects.isNull(file) || Objects.isNull(bucketName)) {
  168.             throw new RuntimeException("文件或者桶名参数不全！");
  169.         }
  170.  
  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.     }
  188.  
  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) {
  199.  
  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.             }
  214.  
  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);
  239.  
  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();
  247.  
  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.             }
  260.  
  261.             inputStream.close();
  262.             return etag != null;
  263.         } catch (Exception e) {
  264.             log.info("合并 {} - {} 文件失败！", folderName, objectName, e);
  265.             return false;
  266.         }
  267.     }
  268.  
  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.     }
  274.  
  275. }

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

  1. package com.jdh.fileUpload.service.fileUpload;
  2.  
  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;
  15.  
  16. import javax.annotation.Resource;
  17.  
  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 {
  28.  
  29.     @Autowired
  30.     private MinioUtil minioUtil;
  31.  
  32.     @Resource
  33.     private RedissonClient redissonClient;
  34.  
  35.     @Autowired
  36.     private RedisTemplate<String, Object> redisTemplate;
  37.  
  38.     @Override
  39.     public Result<Boolean> fileUploadMinio(MultipartFile file) {
  40.         String objectName = Uuid.generateUniqueId(8) + "_" + file.getOriginalFilename();
  41.  
  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.     }
  51.  
  52.     @Override
  53.     public Result<Boolean> filePartUploadMinio(MultipartFile file, String partFile) {
  54.  
  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);
  63.  
  64.             if (partState) {
  65.  
  66.                 Long result = redisTemplate.opsForValue().increment("partCount:" + partFileIndexVo.getFileUid());
  67.  
  68.                 if (result.equals(partFileIndexVo.getPartTotalNum().longValue())) {
  69.  
  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.     }
  89.  
  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);
  17.  
  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))
  55.                 
  56.                 this.$upFile(url,fileParam,null,resp => {
  57.                     let res = resp.data;
  58.                     //判断最后一个分片文件传完之后，后台检验文件上传情况
  59.                     if (res.code == 200){
  60.  
  61.                         if(!res.data){
  62.                             var info = '当前分片上传Minio失败!uid:' + partFileUid + ';当前分片:' + j + ';返回分片:' + res.msg
  63.                             console.log(info)
  64.                         }
  65.  
  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的话，需要再配置文件修改配置文件，如下：

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

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

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

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/110931
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号