使用 Spring Boot + MinIO 实现文件的分片上传、秒传、续传功能开发

bysjlwdx2024-09-08 8:04

使用 Spring Boot + MinIO 实现文件的分片上传、秒传、续传功能开发

在当今的互联网应用中，文件上传是一个常见的功能需求。然而，传统的文件上传方式在面对大文件或不稳定的网络环境时，可能会出现性能瓶颈和上传失败的问题。为了解决这些问题，分片上传、秒传和续传技术应运而生。本文将详细介绍如何使用 Spring Boot 结合 MinIO 来实现这些高级的文件上传功能。

技术选型

  1. Spring Boot：一个快速开发框架，简化了 Spring 应用的搭建和配置。

  2. MinIO：一个高性能的对象存储服务器，支持 S3 协议。

分片上传、秒传和续传原理说明

分片上传：

  • 原理：将大文件分割成多个较小的片段（称为分片），然后分别上传这些分片。这样可以避免一次性传输大文件导致的超时、网络不稳定等问题。每个分片可以独立上传，并且在服务器端可以根据一定的规则重新组合成完整的文件。

  • 优点：提高上传的成功率和稳定性，尤其在网络状况不佳的情况下。可以并行上传多个分片，提高上传速度。

秒传：

  • 原理：在上传文件之前，先计算文件的唯一标识，通常是通过计算文件的哈希值（如 MD5）。服务器端会检查是否已经存在具有相同哈希值的文件。如果存在，则直接认为文件已上传成功，无需再次传输实际的文件内容。

  • 优点：节省上传时间和带宽，对于重复的文件无需再次上传。

续传：

  • 原理：在上传过程中断后，记录已经上传的分片信息。当下次继续上传时，客户端告知服务器已经上传的部分，服务器根据这些信息从上次中断的位置继续接收分片，而不是重新开始上传。

  • 优点：在网络不稳定或其他原因导致上传中断时，无需从头开始上传，提高上传效率。

项目创建及依赖配置（pom.xml）

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>file-upload-with-minio</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>File Upload with MinIO</name>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.4.4</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

配置文件（application.yml）

minio:
  endpoint: http://localhost:9000
  accessKey: accessKey
  secretKey: secretKey
  bucketName: your-bucket-name

MinIO 服务类

package com.example.service;

import io.minio.MinioClient;
import io.minio.Result;
import io.minio.errors.*;
import io.minio.messages.Item;

import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;

public class MinIOService {

    private final MinioClient minioClient;
    private final String bucketName;

    public MinIOService(String endpoint, String accessKey, String secretKey, String bucketName) {
        this.minioClient = MinioClient.builder()
              .endpoint(endpoint)
              .credentials(accessKey, secretKey)
              .build();
        this.bucketName = bucketName;
    }

    // 检查桶是否存在，如果不存在则创建
    public void ensureBucketExists() throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException {
        boolean found = minioClient.bucketExists(bucketName);
        if (!found) {
            minioClient.makeBucket(bucketName);
        }
    }

    // 分片上传
    public void uploadChunk(String objectName, int chunkNumber, InputStream inputStream) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException {
        minioClient.putObject(bucketName, objectName + "_chunk_" + chunkNumber, inputStream, inputStream.available(), "application/octet-stream");
    }

    // 合并分片
    public void mergeChunks(String objectName, int totalChunks) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException {
       try (OutputStream outputStream = new ByteArrayOutputStream()) {
            for (int i = 1; i <= totalChunks; i++) {
                InputStream chunkInputStream = minioClient.getObject(bucketName, objectName + "_chunk_" + i);
                byte[] buffer = new byte[1024];
                int bytesRead;
                while ((bytesRead = chunkInputStream.read(buffer))!= -1) {
                    outputStream.write(buffer, 0, bytesRead);
                }
                chunkInputStream.close();
            }
            minioClient.putObject(bucketName, objectName, new ByteArrayInputStream(((ByteArrayOutputStream) outputStream).toByteArray()), ((ByteArrayOutputStream) outputStream).size(), "application/octet-stream");
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("合并分片失败", e);
        }
    }

   // 秒传判断
    public boolean isInstantUpload(String objectName, long fileSize, String md5Hash) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException {
        try {
            // 检查文件是否已存在
            boolean exists = minioClient.statObject(bucketName, objectName).isPresent();
            if (exists) {
                // 获取已存在文件的大小和 MD5 哈希值
                StatObjectResponse statResponse = minioClient.statObject(bucketName, objectName);
                long existingFileSize = statResponse.size();
                String existingMd5Hash = statResponse.etag();

                // 比较大小和 MD5 哈希值
                if (existingFileSize == fileSize && existingMd5Hash.equals(md5Hash)) {
                    return true;
                }
            }
            return false;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    // 续传判断
    public boolean isResumeUpload(String objectName, int uploadedChunks) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException {
        try {
            // 获取已上传的分片数量
            ListObjectsArgs listArgs = ListObjectsArgs.builder()
              .bucket(bucketName)
              .prefix(objectName + "_chunk_")
              .build();
            Iterable<Result<Item>> results = minioClient.listObjects(listArgs);
            int existingChunks = 0;
            for (Result<Item> result : results) {
                String name = result.get().objectName();
                if (name.matches(objectName + "_chunk_\\d+")) {
                    existingChunks++;
                }
            }

            // 比较已上传的分片数量
            return existingChunks == uploadedChunks;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
	}
}

控制器类

package com.example.controller;

import com.example.service.MinIOService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

@RestController
public class FileUploadController {

    @Autowired
    private MinIOService minIOService;

    @PostMapping("/uploadChunk")
    public String uploadChunk(@RequestParam("fileName") String fileName,
                              @RequestParam("chunkNumber") int chunkNumber,
                              @RequestParam("file") MultipartFile file) {
        try {
            minIOService.uploadChunk(fileName, chunkNumber, file.getInputStream());
            return "Chunk uploaded successfully";
        } catch (Exception e) {
            e.printStackTrace();
            return "Upload failed";
        }
    }

    @PostMapping("/mergeChunks")
    public String mergeChunks(@RequestParam("fileName") String fileName,
                              @RequestParam("totalChunks") int totalChunks) {
        try {
            minIOService.mergeChunks(fileName, totalChunks);
            return "Chunks merged successfully";
        } catch (Exception e) {
            e.printStackTrace();
            return "Merge failed";
        }
    }

    @PostMapping("/checkInstantUpload")
    public boolean checkInstantUpload(@RequestParam("fileName") String fileName,
                                      @RequestParam("fileSize") long fileSize,
                                      @RequestParam("md5Hash") String md5Hash) {
        try {
            return minIOService.isInstantUpload(fileName, fileSize, md5Hash);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    @PostMapping("/checkResumeUpload")
    public boolean checkResumeUpload(@RequestParam("fileName") String fileName,
                                     @RequestParam("uploadedChunks") int uploadedChunks) {
        try {
            return minIOService.isResumeUpload(fileName, uploadedChunks);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

前端页面（HTML + JavaScript）

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>文件上传</title>
</head>

<body>
    <input type="file" id="fileInput">
    <button onclick="startUpload()">开始上传</button>

    <script>
        function startUpload() {
            // 获取文件
            let file = document.getElementById('fileInput').files[0];

            // 计算文件 MD5
            let reader = new FileReader();
            reader.readAsArrayBuffer(file);
            reader.onload = function (e) {
                let arrayBuffer = e.target.result;
                let sparkMD5 = new SparkMD5.ArrayBuffer();
                sparkMD5.append(arrayBuffer);
                let md5Hash = sparkMD5.end();

                // 分片大小
                let chunkSize = 1024 * 1024; // 1MB

                // 总片数
                let totalChunks = Math.ceil(file.size / chunkSize);

                // 分片上传逻辑
                for (let i = 0; i < totalChunks; i++) {
                    let start = i * chunkSize;
                    let end = Math.min((i + 1) * chunkSize, file.size);
                    let chunk = file.slice(start, end);

                    let formData = new FormData();
                    formData.append('fileName', file.name);
                    formData.append('chunkNumber', i + 1);
                    formData.append('file', chunk);

                    fetch('/uploadChunk', {
                        method: 'POST',
                        body: formData
                    })
                       .then(response => response.text())
                       .then(result => console.log(result))
                       .catch(error => console.error(error));
                }
            };
        }
    </script>
</body>

</html>

总结

通过以上的代码实现，我们成功地利用 Spring Boot 和 MinIO 搭建了一个支持分片上传、秒传和续传的文件上传系统。分片上传能够有效地解决大文件上传的问题，提高上传的稳定性和效率；秒传通过文件的唯一标识（如 MD5 哈希值）来判断文件是否已存在，避免重复上传；续传则能够在上传中断后继续从上次的位置进行上传。

在实际应用中，还需要根据具体的需求对代码进行优化和完善，例如处理并发上传、错误处理、文件的权限管理等。希望本文能够为大家在实现类似的文件上传功能时提供有价值的参考和帮助。

相关推荐
麻花20133 分钟前
WPF里面的C1FlexGrid表格控件添加RadioButton单选
java·服务器·前端
哎呦喂-ll25 分钟前
Linux进阶：常用操作
linux·运维·服务器
m0_6446973327 分钟前
DNS域名解析服务器
linux·运维·服务器
码到成功>_<1 小时前
Spring Boot实现License生成和校验
数据库·spring boot·后端
Ztiddler2 小时前
【npm设置代理-解决npm网络连接error network失败问题】
前端·后端·npm·node.js·vue
货拉拉技术2 小时前
多元消息融合分发平台
javascript·后端·架构
醒过来摸鱼2 小时前
【Golang】协程
开发语言·后端·golang
IT枫斗者2 小时前
如何解决Java EasyExcel 导出报内存溢出
java·服务器·开发语言·网络·分布式·物联网
谷大羽2 小时前
Kafka Stream实战教程
spring boot·后端·中间件·kafka·stream
2401_857636392 小时前
实验室管理平台：Spring Boot技术构建
java·spring boot·后端
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06RAG 实践- Ollama+RagFlow 部署本地知识库0704 - matlab m_map地学绘图工具基础函数 - 设置网格08Unity中PICO实现 隔空取物 和 接触抓取物体09Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO10【目标跟踪】相机运动补偿