🍀🍀🍀🍀分布式文件系统-minio：

第一章：分布式文件系统介绍与minio介绍与使用（附minio java client 使用）
第二章：minio&前后端分离上传视频/上传大文件——前后端分离断点续传&minio分片上传实现

文章目录

1.断点续传
2.分块与合并测试
- 2.1 分块测试
- - 2.1.1 流程分析
  - 2.1.2 代码实现
- 2.2 合并测试
- - 2.2.1 流程分析
  - 2.2.2 代码实现
3.前后端分离上传视频流程分析
4.实战开发 - 思路分析
5.实战开发 - 准备工作
- 5.1 数据库设计
- 5.2 核心 pom.xml
- 5.3 application.yaml核心配置
- 5.4 MinioConfig.java配置类
- 5.5 MinioClientUtils工具类
- 5.6 FileTypeUtils工具类
- 5.7 FileFormatUtils工具类
- 5.8 CipherUtils加密解密工具类
- 5.9 MediaFile.java
6.实战开发 - 业务代码
- 6.1 检查文件是否已存在
- - 6.1.1 MediaFileController
  - 6.1.2 MediaFileService
  - 6.1.3 MediaFileServiceImpl
- 6.2 检查分块文件是否已存在
- - 6.2.1 MediaFileController
  - 6.2.2 MediaFileService
  - 6.2.3 MediaFileServiceImpl
- 6.3 上传分块文件
- - 6.3.1 MediaFileController
  - 6.3.2 MediaFileService
  - 6.3.3 MediaFileServiceImpl
- 6.4 合并前下载分块文件(多线程下载)
- 6.5 合并分块文件并上传
- - 6.5.1 MediaFileController
  - 6.5.2 MediaFileService
  - 6.5.3 MediaFileServiceImpl
7.补充-面试题
- 7.1 MinIO是什么？
- 7.2 为什么用MinIO
- 7.3 怎么样构建这个独立文件服务?
- 7.4 断点续传是怎么做的?
- 7.5 分块文件清理问题

1.断点续传

断点续传指的是在下载或上传时，将下载或上传任务（一个文件或一个压缩包）人为的划分为几个部分，每一个部分采用一个线程进行上传或下载，如果碰到网络故障，可以从已经上传或下载的部分开始继续上传下载未完成的部分，而没有必要从头开始上传下载，断点续传可以提高节省操作时间，提高用户体验性。
通常视频文件都比较大，所以对于媒资系统上传文件的需求要满足大文件的上传要求。http协议本身对上传文件大小没有限制，但是客户的网络环境质量、电脑硬件环境等参差不齐，如果一个大文件快上传完了网断了没有上传完成，需要客户重新上传，用户体验非常差，所以对于大文件上传的要求最基本的是断点续传。

断点续传流程如下图：

流程如下：

前端上传前先把文件分成块。
一块一块的上传，上传中断后重新上传，已上传的分块则不用再上传。
各分块上传完成最后在服务端合并文件。

2.分块与合并测试

为了更好的理解文件分块上传的原理，下边用java代码测试文件的分块与合并。

2.1 分块测试

2.1.1 流程分析

文件分块的流程如下：

获取源文件长度
根据设定的分块文件的大小计算出块数
从源文件读数据依次向每一个块文件写数据。

2.1.2 代码实现

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 分块文件测试
 *
 * @author 狐狸半面添
 * @create 2023-02-07 17:14
 */
public class BigFileChunkDemo {
    public static void main(String[] args) throws IOException {
        // 1.指定要进行分块的源文件
        File sourceFile = new File("D:\\SystemDefault\\video\\不为谁而作的歌.mp4");

        // 2.指定分块文件存储路径
        File chunkFolderPath = new File("D:\\SystemDefault\\video\\chunk\\");
        // chunk文件夹不存在则创建
        if (!chunkFolderPath.exists()) {
            chunkFolderPath.mkdirs();
        }

        // 3.分块的大小 - 10MB
        int chunkSize = 1024 * 1024 * 10;

        // 4.根据分块大小得到源文件的分块数量(向上转型)
        long chunkNum = (long) Math.ceil(sourceFile.length() * 1.0 / chunkSize);

        /*
            分块思路：使用流对象读取源文件，向分块文件写数据，达到分块大小不再写
         */

        // 5.使用流对象 rafRead 读取源文件
        RandomAccessFile rafRead = new RandomAccessFile(sourceFile, "r");
        // 6.设置每次读取的缓冲区大小
        byte[] b = new byte[1024];

        RandomAccessFile rafWrite;

        // 7.开始分块
        for (long i = 0; i < chunkNum; i++) {
            // 7.1 指定分块文件
            File file = new File("D:\\SystemDefault\\video\\chunk\\" + i);
            // 7.2 如果分块文件存在，则删除
            if (file.exists()) {
                file.delete();
            }
            // 7.3 创建一个空的分块文件
            boolean newFile = file.createNewFile();
            if (newFile) {
                // 7.4 向分块文件写数据流对象
                rafWrite = new RandomAccessFile(file, "rw");
                int len = -1;
                // 7.5 读取源文件，每次读取的大小为设置的缓冲区的大小
                while ((len = rafRead.read(b)) != -1) {
                    // 7.6 将缓冲区的数据写入到分块文件中
                    rafWrite.write(b, 0, len);
                    // 7.7 达到分块大小不再写了，继续下一次循环，将后面的数据写入新的分块文件中
                    if (file.length() >= chunkSize) {
                        break;
                    }
                }
                // 7.8 关闭该分块文件流，释放资源
                rafWrite.close();

            }
        }
        // 8.分块完成，关闭源文件流，释放资源
        rafRead.close();
        System.out.println("分块文件完成");
    }
}

2.2 合并测试

2.2.1 流程分析

找到要合并的文件并按文件合并的先后进行排序。
创建合并文件。
依次从合并的文件中读取数据向合并文件写入数。

2.2.2 代码实现

<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.13</version>
</dependency>

import org.apache.commons.codec.digest.DigestUtils;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Arrays;
import java.util.List;

/**
 * 合并文件测试
 *
 * @author 狐狸半面添
 * @create 2023-02-07 17:37
 */
public class BigFileMergeDemo {
    public static void main(String[] args) throws IOException {
        // 1.指定源文件 - 目的是后面比较合并后的文件与源文件是否相同
        File sourceFile = new File("D:\\SystemDefault\\video\\不为谁而作的歌.mp4");

        // 2.指定分块文件存储路径
        File chunkFolderPath = new File("D:\\SystemDefault\\video\\chunk\\");

        // 3.指定并创建合并后的文件
        File mergeFile = new File("D:\\SystemDefault\\video\\不为谁而作的歌(合并).mp4");
        boolean success = mergeFile.createNewFile();
        if (!success) {
            System.out.println("error: 文件创建失败");
            return;
        }

        /*
            思路：使用流对象读取分块文件，按顺序将分块文件依次向合并文件写数据
         */

        // 4.获取分块文件列表,按文件名升序排序
        // 4.1 获取分块文件列表
        File[] chunkFiles = chunkFolderPath.listFiles();
        if (chunkFiles == null) {
            System.out.println("error: 分块文件列表为空");
            return;
        }
        // 4.2 由数组变为list集合
        List<File> chunkFileList = Arrays.asList(chunkFiles);
        // 4.3 按文件名升序排序
        chunkFileList.sort((o1, o2) -> Integer.parseInt(o1.getName()) - Integer.parseInt(o2.getName()));

        // 5.创建合并文件的流对象
        RandomAccessFile rafWrite = new RandomAccessFile(mergeFile, "rw");
        // 6.设置每次读取的缓冲区大小
        byte[] b = new byte[1024];
        // 7.逐一读取分块文件，将数据写入到合并文件中
        for (File file : chunkFileList) {
            // 7.1 获取读取分块文件的流对象
            RandomAccessFile rafRead = new RandomAccessFile(file, "r");
            int len = -1;
            // 7.2 读取当前分块文件，每次读取的大小为设置的缓冲区的大小，直到将当前分块文件读取完毕
            while ((len = rafRead.read(b)) != -1) {
                // 7.3 将缓冲区数据写入到合并文件中
                rafWrite.write(b, 0, len);
            }
            // 7.4 关闭分块文件流对象，释放资源
            rafRead.close();
        }

        // 8.关闭流对象，释放资源
        rafWrite.close();


        // 9.校验合并后的文件是否正确
        FileInputStream sourceFileStream = new FileInputStream(sourceFile);
        FileInputStream mergeFileStream = new FileInputStream(mergeFile);
        String sourceMd5Hex = DigestUtils.md5Hex(sourceFileStream);
        String mergeMd5Hex = DigestUtils.md5Hex(mergeFileStream);
        if (sourceMd5Hex.equals(mergeMd5Hex)) {
            System.out.println("合并成功");
        }
    }
}

3.前后端分离上传视频流程分析

前端上传文件前请求媒资接口层检查文件是否存在，如果已经存在则不再上传。
如果文件在系统不存在则前端开始上传，首先对视频文件进行分块。
前端分块进行上传，上传前首先检查分块是否上传，如已上传则不再上传，如果未上传则开始上传分块。
前端请求媒资管理接口层请求上传分块。
接口层请求服务层上传分块。
服务端将分块信息上传到MinIO。
前端将分块上传完毕请求接口层合并分块。
接口层请求服务层合并分块。
服务层根据文件信息找到MinIO中的分块文件，下载到本地临时目录，将所有分块下载完毕后开始合并。
合并完成将合并后的文件上传到MinIO。

4.实战开发 - 思路分析

前端准备上传一个视频文件，需要先发送请求——检查文件是否已存在，携带参数为文件的Md5十六进制值。
后端根据 md5十六进制值去数据库查询该文件是否存在。
- 如果存在，则将文件信息加密返回，前端拿到加密信息再发送其它请求保存到数据库如课程资源表中。流程结束。
- 如果不存在，就提醒前端不存在该文件，前端接下来就需要进行分块上传处理。
前端发现不存在该文件，就将文件进行分块，每上传一个分块文件前，都需要发送请求——检查当前分块文件是否存在，携带参数为文件的Md5十六进制值以及当前分块索引（第几块，从0开始）。
后端就根据参数去 minio 中查找是否存在该分块文件。
- 如果存在了，就告诉前端不需要上传该分块文件了。
- 如果不存在，就告诉前端需要发送请求上传分块文件。
前端发现不存在该分块文件，就发送请求——上传分块文件，携带参数为文件的分块文件，Md5十六进制值以及当前分块索引（第几块，从0开始）。
后端根据参数将分块文件保存在 minio 中。
所有分块文件上传完毕，前端发送请求——合并分块文件与上传合并后的文件，携带参数为文件的Md5十六进制值，文件名，文件标签，文件块总数。
后端就根据参数进行合并与上传处理：
1. 从 minio 下载所有原文件的分块文件。
2. 将分块文件进行合并处理。
3. 计算合并后文件的md5值，如果和前端参数中的md5值一致，则说明正确合并。否则上传失败，流程结束。
4. 再将合并后的文件断点续传到 minio。
5. 将文件信息保存至数据库中。
6. 最后将文件信息加密返回，前端拿到加密信息再发送其它请求保存到数据库如课程资源表中。流程结束。

5.实战开发 - 准备工作

5.1 数据库设计

CREATE TABLE service_media_file(
    `id` BIGINT UNSIGNED PRIMARY KEY COMMENT '主键id（雪花算法）',
    `file_name` VARCHAR(255) NOT NULL COMMENT '文件名称',
    `file_type` CHAR(2) NOT NULL COMMENT '文件类型：文本，图片，音频，视频，其它',
    `file_format` VARCHAR(128) NOT NULL COMMENT '文件格式', 
    `tag` VARCHAR(32) NOT NULL COMMENT '标签',
    `bucket` VARCHAR(32) NOT NULL COMMENT '存储桶',
    `file_path` VARCHAR(512) NOT NULL COMMENT '文件存储路径',
    `file_md5` CHAR(32) NOT NULL UNIQUE COMMENT '文件的md5值',
    `file_byte_size` BIGINT UNSIGNED NOT NULL COMMENT '文件的字节大小',
    `file_format_size` VARCHAR(24) NOT NULL COMMENT '文件的格式大小', 
    `user_id` BIGINT NOT NULL COMMENT '上传人id',
    `create_time` DATETIME NOT NULL COMMENT '创建时间（上传时间）',
    `update_time` DATETIME NOT NULL COMMENT '修改时间'
)ENGINE = INNODB  CHARACTER SET = utf8mb4 COMMENT '第三方服务-媒资文件表';

5.2 核心 pom.xml

<!--根据扩展名取mimetype-->
<dependency>
    <groupId>com.j256.simplemagic</groupId>
    <artifactId>simplemagic</artifactId>
    <version>1.17</version>
</dependency>
<!--对象存储服务-->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.2.1</version>
</dependency>
<dependency>
    <groupId>me.tongfei</groupId>
    <artifactId>progressbar</artifactId>
    <version>0.5.3</version>
</dependency>
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.8.1</version>
</dependency>
<!--生成文件对象的md5十六进制值-->
<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.13</version>
</dependency>
<!--用于文件类型判断-->
<dependency>
    <groupId>org.apache.tika</groupId>
    <artifactId>tika-core</artifactId>
    <version>2.4.0</version>
</dependency>

5.3 application.yaml核心配置

spring:
  servlet:
    multipart:
      max-file-size: 3MB
      max-request-size: 5MB
minio:
  # 指定连接的ip和端口
  endpoint: http://192.168.65.129:9000
  # 指定 访问秘钥（也称用户id）
  accessKey: minioadmin
  # 指定 私有秘钥（也称密码）
  secretKey: minioadmin

5.4 MinioConfig.java配置类

package com.zhulang.waveedu.service.config;

import io.minio.MinioClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author 狐狸半面添
 * @create 2023-02-08 16:26
 */
@Configuration
public class MinioConfig {

    /**
     * 连接的ip和端口
     */
    @Value("${minio.endpoint}")
    private String endpoint;
    /**
     * 访问秘钥（也称用户id）
     */
    @Value("${minio.accessKey}")
    private String accessKey;
    /**
     * 私有秘钥（也称密码）
     */
    @Value("${minio.secretKey}")
    private String secretKey;

    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder()
                .endpoint(endpoint)
                .credentials(accessKey, secretKey)
                .build();
    }
}

5.5 MinioClientUtils工具类

package com.zhulang.waveedu.common.util;

import com.j256.simplemagic.ContentInfo;
import com.j256.simplemagic.ContentInfoUtil;
import io.minio.GetObjectArgs;
import io.minio.MinioClient;
import io.minio.PutObjectArgs;
import io.minio.UploadObjectArgs;
import org.apache.tomcat.util.http.fileupload.IOUtils;
import org.springframework.http.MediaType;

import java.io.*;

/**
 * 操作minio的工具类
 *
 * @author 狐狸半面添
 * @create 2023-02-08 22:08
 */
public class MinioClientUtils {
    private final MinioClient minioClient;

    public MinioClientUtils(MinioClient minioClient) {
        this.minioClient = minioClient;
    }

    /**
     * 获取minio文件的输入流对象
     *
     * @param bucket   桶
     * @param filePath 文件路径
     * @return 输入流
     * @throws Exception 异常
     */
    public InputStream getObject(String bucket, String filePath) throws Exception {
        return minioClient.getObject(GetObjectArgs.builder().bucket(bucket).object(filePath).build());
    }

    /**
     * 将分块文件上传到分布式文件系统
     *
     * @param bytes    文件的字节数组
     * @param bucket   桶
     * @param filePath 存储在桶中的文件路径
     */
    public void uploadChunkFile(byte[] bytes, String bucket, String filePath) throws Exception {
        // 1.指定资源的媒体类型为未知二进制流，以分片形式上传至minio
        try (
                ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes)
        ) {
            minioClient.putObject(
                    PutObjectArgs.builder()
                            .bucket(bucket)
                            .object(filePath)
                            // InputStream stream, long objectSize 对象大小, long partSize 分片大小(-1表示5M,最大不要超过5T，最多10000)
                            .stream(byteArrayInputStream, byteArrayInputStream.available(), -1)
                            .contentType(MediaType.APPLICATION_OCTET_STREAM_VALUE)
                            .build()
            );
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 将文件上传到分布式文件系统
     *
     * @param bytes    文件的字节数组
     * @param bucket   桶
     * @param filePath 存储在桶中的文件路径
     */
    public void uploadFile(byte[] bytes, String bucket, String filePath) throws Exception {
        // 1.指定资源的媒体类型，默认未知二进制流
        String contentType = MediaType.APPLICATION_OCTET_STREAM_VALUE;

        // 2.判断是否有后缀，有后缀则根据后缀推算出文件类型，否则使用默认的未知二进制流
        if (filePath.contains(".")) {
            // 取objectName中的扩展名
            String extension = filePath.substring(filePath.lastIndexOf("."));
            ContentInfo extensionMatch = ContentInfoUtil.findExtensionMatch(extension);
            if (extensionMatch != null) {
                contentType = extensionMatch.getMimeType();
            }
        }

        // 3.以分片形式上传至minio
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);

        PutObjectArgs putObjectArgs = PutObjectArgs.builder()
                .bucket(bucket)
                .object(filePath)
                // InputStream stream, long objectSize 对象大小, long partSize 分片大小(-1表示5M,最大不要超过5T，最多10000)
                .stream(byteArrayInputStream, byteArrayInputStream.available(), -1)
                .contentType(contentType)
                .build();
        // 上传
        minioClient.putObject(putObjectArgs);
    }


    /**
     * 根据文件路径将文件上传到文件系统
     *
     * @param naiveFilePath 本地文件路径
     * @param bucket        桶
     * @param minioFilePath 保存到minio的文件路径位置
     * @throws Exception 异常
     */
    public void uploadChunkFile(String naiveFilePath, String bucket, String minioFilePath) throws Exception {
        UploadObjectArgs uploadObjectArgs = UploadObjectArgs.builder()
                .bucket(bucket)
                .object(minioFilePath)
                .filename(naiveFilePath)
                .build();
        minioClient.uploadObject(uploadObjectArgs);
    }

    /**
     * 下载文件保存至本地临时文件中
     *
     * @param tempFilePrefix 临时文件的前缀
     * @param tempFileSuffix 临时文件的后缀
     * @param bucket         桶
     * @param filePath       文件路径
     * @return 携带数据的临时文件
     * @throws Exception 异常信息
     */
    public File downloadFile(String tempFilePrefix, String tempFileSuffix, String bucket, String filePath) throws Exception {
        // 1.创建空文件，临时保存下载下来的分块文件数据
        File tempFile = File.createTempFile(tempFilePrefix, tempFileSuffix);
        try (
                // 2.获取目标文件的输入流对象
                InputStream inputStream = getObject(bucket, filePath);
                // 3.获取临时空文件的输出流对象
                FileOutputStream outputStream = new FileOutputStream(tempFile);
        ) {
            // 4.进行数据拷贝
            IOUtils.copy(inputStream, outputStream);
            // 5.返回保存了数据的临时文件
            return tempFile;
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        }
    }

//    public File downloadFile(String tempFilePrefix, String tempFileSuffix, String bucket, String filePath) throws Exception {
//        // 1.创建空文件，临时保存下载下来的分块文件数据
//        File tempFile = File.createTempFile(tempFilePrefix, tempFileSuffix);
//        try {
//            Long start = System.currentTimeMillis();
//            minioClient.downloadObject(
//                    DownloadObjectArgs.builder()
//                            // 指定 bucket 存储桶
//                            .bucket(bucket)
//                            // 指定 哪个文件
//                            .object(filePath)
//                            // 指定存放位置与名称
//                            .filename(tempFile.getPath())
//                            .build());
//            Long end = System.currentTimeMillis();
//            System.out.println("下载分块时间："+(end-start)+"ms");
//            // 5.返回保存了数据的临时文件
//            return tempFile;
//        } catch (Exception e) {
//            throw new RuntimeException(e.getMessage());
//        }
//    }
}

5.6 FileTypeUtils工具类

package com.zhulang.waveedu.common.util;

import org.apache.tika.metadata.HttpHeaders;
import org.apache.tika.metadata.Metadata;
import org.apache.tika.metadata.TikaCoreProperties;
import org.apache.tika.mime.MediaType;
import org.apache.tika.parser.AutoDetectParser;
import org.apache.tika.parser.ParseContext;
import org.apache.tika.parser.Parser;
import org.xml.sax.helpers.DefaultHandler;

import java.io.File;
import java.io.InputStream;
import java.nio.file.Files;
import java.util.HashMap;
import java.util.Map;

/**
 * 文件类型工具类
 *
 * @author 狐狸半面添
 * @create 2023-02-09 0:13
 */
public class FileTypeUtils {
    private static final Map<String, String> contentType = new HashMap<>();

    /**
     * 获取文件的 mime 类型
     *
     * @param file 文件
     * @return mime类型
     */
    public static String getMimeType(File file) {
        AutoDetectParser parser = new AutoDetectParser();
        parser.setParsers(new HashMap<MediaType, Parser>());
        Metadata metadata = new Metadata();
        metadata.add(TikaCoreProperties.RESOURCE_NAME_KEY, file.getName());
        try (InputStream stream = Files.newInputStream(file.toPath())) {
            parser.parse(stream, new DefaultHandler(), metadata, new ParseContext());
        } catch (Exception e) {
            throw new RuntimeException();
        }
        return metadata.get(HttpHeaders.CONTENT_TYPE);
    }

    /**
     * 根据 mimetype 获取文件的简单类型
     *
     * @param mimeType mime类型
     * @return 简单类型：文本，图片，音频，视频，其它
     */
    public static String getSimpleType(String mimeType) {
        String simpleType = mimeType.split("/")[0];
        switch (simpleType) {
            case "text":
                return "文本";
            case "image":
                return "图片";
            case "audio":
                return "音频";
            case "video":
                return "视频";
            case "application":
                return "其它";
            default:
                throw new RuntimeException("mimeType格式错误");
        }
    }

    // 测试
    public static void main(String[] args) {
        File file = new File("D:\\location语法规则.docx");
        String mimeType = getMimeType(file);
        System.out.println(mimeType);
        System.out.println(getSimpleType(mimeType));
    }

5.7 FileFormatUtils工具类

package com.zhulang.waveedu.common.util;

import java.text.DecimalFormat;

/**
 * 文件格式工具
 *
 * @author 狐狸半面添
 * @create 2023-02-09 19:43
 */
public class FileFormatUtils {
    /**
     * 将字节单位的文件大小转为格式化的文件大小表示
     *
     * @param fileLength 文件字节大小
     * @return 格式化文件大小表示
     */
    public static String formatFileSize(long fileLength) {
        DecimalFormat df = new DecimalFormat("#.00");
        String fileSizeString = "";
        String wrongSize = "0B";
        if (fileLength == 0) {
            return wrongSize;
        }
        if (fileLength < 1024) {
            fileSizeString = df.format((double) fileLength) + " B";
        } else if (fileLength < 1048576) {
            fileSizeString = df.format((double) fileLength / 1024) + " KB";
        } else if (fileLength < 1073741824) {
            fileSizeString = df.format((double) fileLength / 1048576) + " MB";
        } else {
            fileSizeString = df.format((double) fileLength / 1073741824) + " GB";
        }
        return fileSizeString;
    }
}

5.8 CipherUtils加密解密工具类

package com.zhulang.waveedu.common.util;

import com.alibaba.fastjson.JSON;
import org.apache.ibatis.logging.stdout.StdOutImpl;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

/**
 * AES加密解密工具
 *
 * @author 狐狸半面添
 * @create 2023-01-18 20:34
 */
public class CipherUtils {

    private static final String SECRET_KEY = "tangyulang5201314";
    private static final String AES = "AES";
    private static final String CHARSET_NAME = "UTF-8";

    /**
     * 生成密钥 key
     *
     * @param password 加密密码
     * @return
     * @throws Exception
     */
    private static SecretKeySpec generateKey(String password) throws Exception {
        // 1.构造密钥生成器，指定为AES算法,不区分大小写
        KeyGenerator keyGenerator = KeyGenerator.getInstance(AES);
        // 2. 因为AES要求密钥的长度为128，我们需要固定的密码，因此随机源的种子需要设置为我们的密码数组
        // 生成一个128位的随机源, 根据传入的字节数组
        /*
         * 这种方式 windows 下正常, Linux 环境下会解密失败
         * keyGenerator.init(128, new SecureRandom(password.getBytes()));
         */
        // 兼容 Linux
        SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
        random.setSeed(password.getBytes());
        keyGenerator.init(128, random);
        // 3.产生原始对称密钥
        SecretKey original_key = keyGenerator.generateKey();
        // 4. 根据字节数组生成AES密钥
        return new SecretKeySpec(original_key.getEncoded(), AES);
    }

    /**
     * 加密
     *
     * @param content  加密的内容
     * @param password 加密密码
     * @return
     */
    private static String aESEncode(String content, String password) {
        try {
            // 根据指定算法AES自成密码器
            Cipher cipher = Cipher.getInstance(AES);
            // 基于加密模式和密钥初始化Cipher
            cipher.init(Cipher.ENCRYPT_MODE, generateKey(password));
            // 单部分加密结束, 重置Cipher, 获取加密内容的字节数组(这里要设置为UTF-8)防止解密为乱码
            byte[] bytes = cipher.doFinal(content.getBytes(CHARSET_NAME));
            // 将加密后的字节数组转为字符串返回
            return Base64.getUrlEncoder().encodeToString(bytes);
        } catch (Exception e) {
            // 如果有错就返回 null
            return null;
        }
    }

    /**
     * 解密
     *
     * @param content  解密内容
     * @param password 解密密码
     * @return
     */
    private static String AESDecode(String content, String password) {
        try {
            // 将加密并编码后的内容解码成字节数组
            byte[] bytes = Base64.getUrlDecoder().decode(content);
            // 这里指定了算法为AES
            Cipher cipher = Cipher.getInstance(AES);
            // 基于解密模式和密钥初始化Cipher
            cipher.init(Cipher.DECRYPT_MODE, generateKey(password));
            // 单部分加密结束，重置Cipher
            byte[] result = cipher.doFinal(bytes);
            // 将解密后的字节数组转成 UTF-8 编码的字符串返回
            return new String(result, CHARSET_NAME);
        } catch (Exception e) {
            // 如果有错就返回 null
            return null;
        }


    }

    /**
     * 加密
     *
     * @param content 加密内容
     * @return 加密结果
     */
    public static String encrypt(String content) {
        return aESEncode(content, SECRET_KEY);
    }

    /**
     * 解密
     *
     * @param content 解密内容
     * @return 解密结果
     */
    public static String decrypt(String content) {
        try {
            return AESDecode(content, SECRET_KEY);
        } catch (Exception e) {
            return null;
        }
    }
}

5.9 MediaFile.java

package com.zhulang.waveedu.service.po;

import com.baomidou.mybatisplus.annotation.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.time.LocalDateTime;

/**
 * <p>
 * 第三方服务-媒资文件表
 * </p>
 *
 * @author 狐狸半面添
 * @since 2023-02-08
 */
@TableName("service_media_file")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class MediaFile implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键id（雪花算法）
     */
    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;

    /**
     * 文件名称
     */
    private String fileName;

    /**
     * 文件类型：文本，图片，音频，视频，其它
     */
    private String fileType;

    /**
     * 文件格式
     */
    private String fileFormat;

    /**
     * 标签
     */
    private String tag;

    /**
     * 存储桶
     */
    private String bucket;

    /**
     * 文件存储路径
     */
    private String filePath;

    /**
     * 文件的md5值
     */
    private String fileMd5;

    /**
     * 文件字节大小
     */
    private Long fileByteSize;
    /**
     * 文件格式化大小
     */
    private String fileFormatSize;

    /**
     * 上传人id
     */
    private Long userId;

    /**
     * 创建时间（上传时间）
     */
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;

    /**
     * 修改时间
     */
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;

}

6.实战开发 - 业务代码

6.1 检查文件是否已存在

6.1.1 MediaFileController

package com.zhulang.waveedu.service.controller;


import com.alibaba.fastjson.JSONObject;
import com.zhulang.waveedu.common.entity.Result;
import com.zhulang.waveedu.service.service.MediaFileService;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.stereotype.Controller;

import javax.annotation.Resource;

/**
 * <p>
 * 第三方服务-媒资文件表 前端控制器
 * </p>
 *
 * @author 狐狸半面添
 * @since 2023-02-08
 */
@Controller
@RequestMapping("/media-file")
public class MediaFileController {
    @Resource
    private MediaFileService mediaFileService;


    /**
     * 文件上传前检查文件是否存在
     *
     * @param object 需要上传的文件的md5值
     * @return 是否存在, false-不存在 true-存在
     */
    @PostMapping("/upload/checkFile")
    public Result checkFile(@RequestBody JSONObject object) {
        return mediaFileService.checkFile(object.getString("fileMd5"));
    }
}

6.1.2 MediaFileService

package com.zhulang.waveedu.service.service;

import com.zhulang.waveedu.common.entity.Result;
import com.zhulang.waveedu.service.po.MediaFile;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * <p>
 * 第三方服务-媒资文件表 服务类
 * </p>
 *
 * @author 狐狸半面添
 * @since 2023-02-08
 */
public interface MediaFileService extends IService<MediaFile> {

    /**
     * 文件上传前检查文件是否存在
     *
     * @param fileMd5 需要上传的文件的md5值
     * @return 是否存在,false-不存在 true-存在
     */
    Result checkFile(String fileMd5);
}

6.1.3 MediaFileServiceImpl

package com.zhulang.waveedu.service.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zhulang.waveedu.common.constant.HttpStatus;
import com.zhulang.waveedu.common.entity.Result;
import com.zhulang.waveedu.common.util.RegexUtils;
import com.zhulang.waveedu.service.po.MediaFile;
import com.zhulang.waveedu.service.dao.MediaFileMapper;
import com.zhulang.waveedu.service.service.MediaFileService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import io.minio.GetObjectArgs;
import io.minio.MinioClient;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.InputStream;

/**
 * <p>
 * 第三方服务-媒资文件表 服务实现类
 * </p>
 *
 * @author 狐狸半面添
 * @since 2023-02-08
 */
@Service
public class MediaFileServiceImpl extends ServiceImpl<MediaFileMapper, MediaFile> implements MediaFileService {
    @Resource
    private MediaFileMapper mediaFileMapper;
    @Resource
    private MinioClientUtils minioClientUtils;

    @Override
    public Result checkFile(String fileMd5) {
        HashMap<String, Object> resultMap = new HashMap<>();

        // 1.校验 fileMd5 合法性
        if (RegexUtils.isMd5HexInvalid(fileMd5)) {
            return Result.error(HttpStatus.HTTP_BAD_REQUEST.getCode(), "文件md5格式错误");
        }

        // 2.在文件表存在，并且在文件系统存在，此文件才存在
        // 2.1 判断是否在文件表中存在
        LambdaQueryWrapper<MediaFile> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(MediaFile::getFileMd5, fileMd5);
        MediaFile mediaFile = mediaFileMapper.selectOne(wrapper);
        if (mediaFile == null) {
            resultMap.put("exist", false);
            return Result.ok(resultMap);
        }
        // 2.2 判断是否在文件系统存在
        try {
            InputStream inputStream = minioClientUtils.getObject(mediaFile.getBucket(), mediaFile.getFilePath());
            if (inputStream == null) {
                // 文件不存在
                resultMap.put("exist", false);
                return Result.ok(resultMap);
            }
        } catch (Exception e) {
            // 文件不存在
            resultMap.put("exist", false);
            return Result.ok(resultMap);
        }
        // 3.走到这里说明文件已存在，返回true
        resultMap.put("exist", true);
        // 4.封装文件信息
        resultMap.put("info", encodeFileInfo(mediaFile));
        // 5.返回结果
        return Result.ok(resultMap);
    }

    /**
     * 将 部分信息进行封装加密
     *
     * @param mediaFile 媒资对象
     * @return 加密结果
     */
    private String encodeFileInfo(MediaFile mediaFile) {
        HashMap<String, Object> fileMap = new HashMap<>(5);
        fileMap.put("fileType", mediaFile.getFileType());
        fileMap.put("filePath", mediaFile.getBucket() + "/" + mediaFile.getFilePath());
        fileMap.put("fileFormat", mediaFile.getFileFormat());
        fileMap.put("fileByteSize", mediaFile.getFileByteSize());
        fileMap.put("fileFormatSize", mediaFile.getFileFormatSize());
        return CipherUtils.encrypt(JSON.toJSONString(fileMap));
    }
}

6.2 检查分块文件是否已存在

6.2.1 MediaFileController

    /**
     * 分块文件上传前检测分块文件是否已存在
     *
     * @param chunkFileVO 分块文件的源文件md5和该文件索引
     * @return 是否存在, false-不存在 true-存在
     * @throws Exception
     */
    @PostMapping("/upload/checkChunk")
    public Result checkChunk(@Validated @RequestBody ChunkFileVO chunkFileVO) throws Exception {
        return mediaFileService.checkChunk(chunkFileVO.getFileMd5(),chunkFileVO.getChunkIndex());
    }

6.2.2 MediaFileService

    /**
     * 分块文件上传前检测分块文件是否已存在
     *
     * @param fileMd5 分块文件的源文件md5
     * @param chunkIndex 分块文件索引
     * @return 是否存在, false-不存在 true-存在
     */
    Result checkChunk(String fileMd5, Integer chunkIndex);

6.2.3 MediaFileServiceImpl

    @Resource
    private MinioClientUtils minioClientUtils;
    @Value("${minio.bucket}")
    private String bucket;

    @Override
    public Result checkChunk(String fileMd5, Integer chunkIndex) {
        // 1.得到分块文件所在目录
        String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
        // 2.分块文件的路径
        String chunkFilePath = chunkFileFolderPath + chunkIndex;

        // 3.查看是否在文件系统存在（注意关闭流）
        try (
                InputStream inputStream = minioClientUtils.getObject(bucket, chunkFilePath)
        ) {

            if (inputStream == null) {
                //文件不存在
                return Result.ok(false);
            }
        } catch (Exception e) {
            //文件不存在
            return Result.ok(false);
        }

        // 4.走到这里说明文件已存在，返回true
        return Result.ok(true);
    }

    /**
     * 得到分块文件的目录
     *
     * @param fileMd5 文件的md5值
     * @return 分块文件所在目录
     */
    private String getChunkFileFolderPath(String fileMd5) {
        return fileMd5.substring(0, 1) + "/" + fileMd5.substring(1, 2) + "/" + fileMd5 + "/" + "chunk" + "/";
    }

6.3 上传分块文件

6.3.1 MediaFileController

    /**
     * 上传分块文件
     *
     * @param file       分块文件
     * @param fileMd5    原文件md5值
     * @param chunkIndex 分块文件索引
     * @return 上传情况
     */
    @PostMapping("/upload/uploadChunk")
    public Result uploadChunk(@RequestParam("file") MultipartFile file,
                              @RequestParam("fileMd5") @Pattern(regexp = RegexUtils.RegexPatterns.MD5_HEX_REGEX, message = "文件md5格式错误") String fileMd5,
                              @RequestParam("chunkIndex") @Min(value = 0, message = "索引必须大于等于0") Integer chunkIndex) throws Exception {
        return mediaFileService.uploadChunk(fileMd5, chunkIndex, file.getBytes());
    }

6.3.2 MediaFileService

    /**
     * 上传分块文件
     *
     * @param fileMd5    原文件md5值
     * @param chunkIndex 分块文件索引
     * @param bytes      分块文件的字节数组形式
     * @return 上传情况
     */
    Result uploadChunk(String fileMd5, Integer chunkIndex, byte[] bytes);

6.3.3 MediaFileServiceImpl

    @Resource
    private MinioClientUtils minioClientUtils;
    @Value("${minio.bucket}")
    private String bucket;
	
	@Override
    public Result uploadChunk(String fileMd5, Integer chunkIndex, byte[] bytes) {
        // 1.得到分块文件所在目录
        String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
        // 2.分块文件的路径
        String chunkFilePath = chunkFileFolderPath + chunkIndex;

        try {
            // 3.将分块上传到文件系统
            minioClientUtils.uploadChunkFile(bytes, bucket, chunkFilePath);
            // 4.上传成功
            return Result.ok();
        } catch (Exception e) {
            // 上传失败
            return Result.error();
        }
    }

    /**
     * 得到分块文件的目录
     *
     * @param fileMd5 文件的md5值
     * @return 分块文件所在目录
     */
    private String getChunkFileFolderPath(String fileMd5) {
        return fileMd5.charAt(0) + "/" + fileMd5.charAt(1) + "/" + fileMd5 + "/" + "chunk" + "/";
    }

6.4 合并前下载分块文件(多线程下载)

合并分块前要检查分块文件是否全部上传完成，如果完成则将已经上传的分块文件从minio下载下来，然后再进行合并。

    /**
     * 创建10个线程数量的线程池
     */
    private final ExecutorService threadPool = Executors.newFixedThreadPool(10);

    /**
     * 下载所有的块文件
     *
     * @param fileMd5    源文件的md5值
     * @param chunkTotal 块总数
     * @return 所有块文件
     */
    private File[] downloadChunkFilesFromMinio(String fileMd5, int chunkTotal) throws Exception {
        // 1.得到分块文件所在目录
        String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
        // 2.分块文件数组
        File[] chunkFiles = new File[chunkTotal];
        // 3.设置计数器
        CountDownLatch countDownLatch = new CountDownLatch(chunkTotal);
        // 4.开始逐个下载
        for (int i = 0; i < chunkTotal; i++) {
            int index = i;
            threadPool.execute(() -> {
                // 4.1 得到分块文件的路径
                String chunkFilePath = chunkFileFolderPath + index;
                // 4.2 下载分块文件
                try {
                    chunkFiles[index] = minioClientUtils.downloadFile("chunk", null, bucket, chunkFilePath);
                } catch (Exception e) {
                    // 计数器减1
                    countDownLatch.countDown();
                    throw new RuntimeException(e);
                }
                // 计数器减1
                countDownLatch.countDown();
            });
        }

        /*
            阻塞到任务执行完成,当countDownLatch计数器归零，这里的阻塞解除等待,
            给一个充裕的超时时间,防止无限等待，到达超时时间还没有处理完成则结束任务
         */
        countDownLatch.await(30, TimeUnit.MINUTES);

        // 5.返回所有块文件
        return chunkFiles;
    }

6.5 合并分块文件并上传

6.5.1 MediaFileController

    /**
     * 合并分块文件
     *
     * @param fileMd5    文件的md5十六进制值
     * @param fileName   文件名
     * @param tag        文件标签
     * @param chunkTotal 文件块总数
     * @return 合并与上传情况
     */
    @PostMapping("/upload/uploadMergeChunks")
    public Result uploadMergeChunks(@RequestParam("fileMd5") @Pattern(regexp = RegexUtils.RegexPatterns.MD5_HEX_REGEX, message = "文件md5格式错误") String fileMd5,
                                    @RequestParam("fileName") @Pattern(regexp = RegexUtils.RegexPatterns.FILE_NAME_REGEX, message = "文件名最多255个字符") String fileName,
                                    @RequestParam("tag") @Pattern(regexp = RegexUtils.RegexPatterns.FILE_TAG_REGEX, message = "文件标签最多32个字符") String tag,
                                    @RequestParam("chunkTotal") @Min(value = 1, message = "块总数必须大于等于1") Integer chunkTotal) {

        return mediaFileService.uploadMergeChunks(fileMd5, fileName, tag, chunkTotal);
    }

6.5.2 MediaFileService

    /**
     * 合并分块文件
     *
     * @param fileMd5    文件的md5十六进制值
     * @param fileName   文件名
     * @param tag        文件标签
     * @param chunkTotal 文件块总数
     * @return 合并与上传情况
     */
    Result uploadMergeChunks(String fileMd5, String fileName, String tag, Integer chunkTotal);

6.5.3 MediaFileServiceImpl

    /**
     * 将 部分信息进行封装加密
     *
     * @param mediaFile 媒资对象
     * @return 加密结果
     */
    private String encodeFileInfo(MediaFile mediaFile) {
        HashMap<String, Object> fileMap = new HashMap<>(5);
        fileMap.put("fileType", mediaFile.getFileType());
        fileMap.put("filePath", mediaFile.getBucket() + "/" + mediaFile.getFilePath());
        fileMap.put("fileFormat", mediaFile.getFileFormat());
        fileMap.put("fileByteSize", mediaFile.getFileByteSize());
        fileMap.put("fileFormatSize", mediaFile.getFileFormatSize());
        return CipherUtils.encrypt(JSON.toJSONString(fileMap));
    }


	@Override
    public Result uploadMergeChunks(String fileMd5, String fileName, String tag, Integer chunkTotal) {
        try {
            // 1.下载分块
            File[] chunkFiles = downloadChunkFilesFromMinio(fileMd5, chunkTotal);

            // 2.根据文件名得到合并后文件的扩展名
            int index = fileName.lastIndexOf(".");
            String extension = index != -1 ? fileName.substring(index) : "";
            File tempMergeFile = null;
            try {
                try {
                    // 3.创建一个临时文件作为合并文件
                    tempMergeFile = File.createTempFile("merge", extension);
                } catch (IOException e) {
                    return Result.error(HttpStatus.HTTP_INTERNAL_ERROR.getCode(), "创建临时合并文件出错");
                }

                // 4.创建合并文件的流对象
                try (RandomAccessFile rafWrite = new RandomAccessFile(tempMergeFile, "rw")) {
                    byte[] b = new byte[1024];
                    for (File file : chunkFiles) {
                        // 5.读取分块文件的流对象
                        try (RandomAccessFile rafRead = new RandomAccessFile(file, "r");) {
                            int len = -1;
                            while ((len = rafRead.read(b)) != -1) {
                                // 6.向合并文件写数据
                                rafWrite.write(b, 0, len);
                            }
                        }

                    }
                } catch (IOException e) {
                    return Result.error(HttpStatus.HTTP_INTERNAL_ERROR.getCode(), "合并文件过程出错");
                }


                // 7.校验合并后的文件是否正确
                try (
                        // 7.1 获取合并后文件的流对象
                        FileInputStream mergeFileStream = new FileInputStream(tempMergeFile);
                ) {

                    // 7.2 获取合并文件的md5十六进制值
                    String mergeMd5Hex = DigestUtils.md5Hex(mergeFileStream);
                    // 7.3 校验
                    if (!fileMd5.equals(mergeMd5Hex)) {
                        return Result.error(HttpStatus.HTTP_BAD_REQUEST.getCode(), "合并文件校验不通过");
                    }
                } catch (IOException e) {
                    return Result.error(HttpStatus.HTTP_INTERNAL_ERROR.getCode(), "合并文件校验出错");
                }

                // 8.得到 mimetype
                String mimeType = FileTypeUtils.getMimeType(tempMergeFile);

                // 9.拿到合并文件在minio的存储路径
                String mergeFilePath = getFilePathByMd5(fileMd5, extension);
                // 10.将合并后的文件上传到文件系统
                minioClientUtils.uploadFile(tempMergeFile.getAbsolutePath(), bucket, mergeFilePath);

                // 11.设置需要入库的文件信息
                MediaFile mediaFile = new MediaFile();
                // 11.1 文件名
                mediaFile.setFileName(WaveStrUtils.removeBlank(fileName));
                // 11.2 文件类型
                mediaFile.setFileType(FileTypeUtils.getSimpleType(mimeType));
                // 11.3 文件格式
                mediaFile.setFileFormat(mimeType);
                // 11.4 文件标签
                mediaFile.setTag(WaveStrUtils.removeBlank(tag));
                // 11.5 存储桶
                mediaFile.setBucket(bucket);
                // 11.6 存储路径
                mediaFile.setFilePath(mergeFilePath);
                // 11.7 设置md5值
                mediaFile.setFileMd5(fileMd5);
                // 11.8 设置合并文件大小（单位：字节）
                mediaFile.setFileByteSize(tempMergeFile.length());
                // 11.9 设置文件格式大小
                mediaFile.setFileFormatSize(FileFormatUtils.formatFileSize(mediaFile.getFileByteSize()));
                // 11.10 设置上传者
                mediaFile.setUserId(UserHolderUtils.getUserId());
                // 12.保存至数据库
                this.save(mediaFile);

                // 15.返回成功
                return Result.ok(encodeFileInfo(mediaFile));
            } finally {
                // 13.删除临时分块文件
                for (File chunkFile : chunkFiles) {
                    if (chunkFile.exists()) {
                        chunkFile.delete();
                    }
                }
                // 14.删除合并的临时文件
                if (tempMergeFile != null) {
                    tempMergeFile.delete();
                }

            }
        } catch (Exception e) {
            return Result.error(HttpStatus.HTTP_INTERNAL_ERROR.getCode(), e.getMessage());
        }
    }


    /**
     * 得到合并文件的路径
     *
     * @param fileMd5 文件的md5十六进制值
     * @param fileExt 文件的扩展名
     * @return 合并文件路径
     */
    private String getFilePathByMd5(String fileMd5, String fileExt) {
        return fileMd5.substring(0, 1) + "/" + fileMd5.substring(1, 2) + "/" + fileMd5 + "/" + fileMd5 + fileExt;
    }

7.补充-面试题

7.1 MinIO是什么？

MinIO一个轻量级的分布式文件系统，由多个个MinIO节点连接组成，可根据文件规模进行扩展,适用于海量文件的存储与访问。

7.2 为什么用MinIO

MinIO开源，使用简单，功能强大。
MinIO使用纠删码算法，只要不超过一半的节点坏掉整个文件系统就可以使用。
如果将坏的节点重新启动，自动恢复没有上传成功的文件。

7.3 怎么样构建这个独立文件服务?

我们项目中有很多要上传文件的地方，比如上传图片、上传文档、上传视频等，所以我们要构建一个独立的文件服务负责上传、下载等功能，负责对文件进行统一管理。
创建单独的文件服务，提供以下接口:

上传接口
下载接口
我的图库接口
我的文件库接口
删除文件接口

文件的存储和下载使用MinIO实现。

MinIO是一个分布式的文件系统，性能高，扩展强。

使用Nginx+MinIO组成一个文件服务器。通过访问Nginx,由nginx代理将请求转发到MinIO去浏览、下载文件。

7.4 断点续传是怎么做的?

我们是基于分块上传的模式实现断点续传的需求，当文件上传一部分断网后前边已经上传过的不再上传。

前端对文件分块。
前端使用多线程一块-块上传，上传前给服务端发一个消息校验该分块是否上传，如果已上传则不再上传。
等所有分块上传完毕,服务端合并所有分块，校验文件的完整性。因为分块全部上传到了服务器，服务器将所在分块按顺序进行合并，就是写每个分块文件内容按顺序依次写入一个文件中。（使用字节流去读写文件）
前端给服务传了一个md5值，服务端合并文件后计算合并后文件的md5是否和前端传的一样，如果一样则说文件完整，如果不一样说明可能由于网络丢包导致文件不完整，这时上传失败需要重新上传。