当前位置:   article > 正文

【Java】Ruoyi-Vue-Plus 整合 文件分片上传至 minio、阿里云、七牛云等OSS-【后端篇】

【Java】Ruoyi-Vue-Plus 整合 文件分片上传至 minio、阿里云、七牛云等OSS-【后端篇】

开发环境

  • Ruoyi-Vue-Plus 5.1.2(Spring Boot 3.1.7)
  • MySQL 8.0.32
  • minio
  • open JDK 17

common-oss 模块添加相关封装类

entity

ChunkFileInfoBO

package org.dromara.common.oss.chunkfile.entity;

import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * 分片文件信息
 *
 * @since 2024/2/6 10:24
 */
@Data
@NoArgsConstructor
public class ChunkFileInfoBO implements Serializable {

    /**
     * 文件内容 唯一标识 md5 (文件分片、总文件整体)
     */
    @NotEmpty(message = "文件内容唯一标识 不能为空")
    private String identifier;

    /**
     * 文件名称
     */
    @NotEmpty(message = "文件名称 不能为空")
    private String filename;

    /**
     * 分块大小 根据 totalSize 和这个值可以计算出总共的块数。
     */
    private Long chunkSize;
    /**
     * 文件总大小
     */
    private Long totalSize;
    /**
     * 总块数
     */
    @NotNull(message = "文件分片总块数 不能为空")
    private Integer totalChunks;
    /**
     * 分块编号 从1开始,注意不是从 0 开始的
     */
    @NotNull(message = "当前文件分片编号 不能为空")
    private Integer chunkNumber;
    /**
     * 当前分块大小
     */
    @NotNull(message = "当前文件分片大小 不能为空")
    private Long currentChunkSize;

    /**
     * 文件前端上传请求唯一标识
     */
    @NotEmpty(message = "文件上传请求唯一标识 不能为空")
    private String requestId;

    /**
     * 文件后端上传请求唯一标识
     */
    private String uploadId;

    /**
     * 文件类型后缀
     */
    private String suffix;

    /**
     * 文件原始名称
     */
    private String newFilename;
    /**
     * 相对路径
     */
    private String relativePath;


}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82

FileMergeBO

package org.dromara.common.oss.chunkfile.entity;

import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * 分片合并上传参数
 *
 * @since 2024/2/6 14:24
 */
@Data
@NoArgsConstructor
public class FileMergeBO implements Serializable {
    /**
     * 文件名称
     */
    @NotEmpty(message = "文件名称 不能为空")
    private String filename;
    /**
     * 文件内容唯一标识
     */
    @NotEmpty(message = "文件内容唯一标识 不能为空")
    private String identifier;
    /**
     * 文件前端上传请求唯一标识
     */
    @NotEmpty(message = "文件上传请求唯一标识 不能为空")
    private String requestId;
    /**
     * 总块数
     */
    @NotNull(message = "文件分片总块数 不能为空")
    private Integer totalChunks;

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

FileUploadResult

package org.dromara.common.oss.chunkfile.entity;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Set;

/**
 * 分片文件上传返回结果
 *
 * @since 2024/2/6 10:25
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class FileUploadResult {

    /**
     * 是否跳过上传 (已经上传过的,跳过)
     */
    private Boolean skipUpload;
    /**
     *
     */
    private Set<String> uploaded;
    /**
     * 是否需要合并
     */
    private Boolean needMerge;

    /**
     * 当前文件分片编号
     */
    private Integer currentChunkNum;

    /**
     * 文件内容 唯一标识 md5 (文件分片、总文件整体)
     */
    private String identifier;
    /**
     * 文件名称
     */
    private String fileName;
    /**
     * 文件前端上传请求唯一标识
     */
    private String requestId;
    /**
     * sys_oss 主键标识
     */
    private Long ossFileId;
    /**
     * 文件上传后的url地址
     */
    private String url;

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61

SysOssRedisDTO

package org.dromara.common.oss.chunkfile.entity;

import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * redis缓存存储对象
 *
 * @since 2024/2/6 14:08
 */
@Data
@NoArgsConstructor
public class SysOssRedisDTO implements Serializable {

    /**
     * 文件后端上传请求唯一标识
     */
    private String uploadId;

    /**
     * 文件上传后的url地址
     */
    private String url;
    /**
     * 文件名称
     */
    private String filePathName;

    /**
     * 文件内容 唯一标识 md5 (文件分片、总文件整体)
     */
    private String identifier;
    /**
     * 服务商
     */
    private String ossService;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

enum

FileUploadStatus

package org.dromara.common.oss.chunkfile.enumd;

import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * 文件分片 上传状态枚举
 *
 * @since 2024/2/6 11:05
 */
@Getter
@AllArgsConstructor
public enum FileUploadStatus {

    /**
     * 上传中
     */
    UPLOADING("0", "上传进行中"),
    /**
     * 上传完成
     */
    UPLOADED("1", "上传完成");

    /**
     * 状态码
     */
    private final String code;


    /**
     * 状态描述
     */
    private final String desc;

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

常量

常量类 OssConstant 中添加文件分片上传缓存常量

    /**
     * 分片文件 块前缀
     */
    String CHUNK_FILE_PART_PREFIX = GlobalConstants.GLOBAL_REDIS_KEY + "chunk_file_part:";
    /**
     * 分片文件 信息前缀
     */
    String CHUNK_FILE_INFO_PREFIX = GlobalConstants.GLOBAL_REDIS_KEY + "chunk_file_info:";
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

OssClient 类改造

改造 OssClient 类,添加文件分片上传合并到oss的相关方法。

package org.dromara.common.oss.core;

public class OssClient {
// ------ 扩展方法 ---------
    public String getPath(String suffix) {
        return getPath(properties.getPrefix(), suffix);
    }

    /**
     * 获取分片上传的统一id
     *
     * @param path 完整文件路径
     */
    public String getChunkUploadUnionId(String path, String contentType) {
        String uploadId = null;
        try {
            InitiateMultipartUploadRequest initRequest = new InitiateMultipartUploadRequest(properties.getBucketName(), path);
            if (StringUtils.isNotBlank(contentType)) {
                ObjectMetadata metadata = new ObjectMetadata();
                metadata.setContentType(contentType);
                initRequest.setObjectMetadata(metadata);
            }
            initRequest.setCannedACL(getAccessPolicy().getAcl());
            InitiateMultipartUploadResult initResult = client.initiateMultipartUpload(initRequest);
            uploadId = initResult.getUploadId();
        } catch (Exception e) {
            throw new OssException("上传文件失败,请检查配置信息:[" + e.getMessage() + "]");
        }
        System.out.println("uploadId-----:" + uploadId);
        return uploadId;
    }


    /**
     * 分片上传
     *
     * @param inputStream
     * @param path        完整文件路径
     * @param uploadId
     * @param partSize
     * @param partNum
     * @return
     */
    public PartETag chunkUpload(InputStream inputStream, String path,
                                String uploadId, Long partSize, int partNum) {
        if (!(inputStream instanceof ByteArrayInputStream)) {
            inputStream = new ByteArrayInputStream(IoUtil.readBytes(inputStream));
        }
        PartETag partETag = null;
        try {
            UploadPartRequest uploadPartRequest = new UploadPartRequest()
                .withBucketName(properties.getBucketName())
                .withKey(path)
                .withUploadId(uploadId)
                .withPartNumber(partNum)
                .withInputStream(inputStream)
                .withPartSize(partSize);
            UploadPartResult uploadPartResult = client.uploadPart(uploadPartRequest);
            partETag = uploadPartResult.getPartETag();
        } catch (Exception e) {
            throw new OssException("上传文件失败,请检查配置信息:[" + e.getMessage() + "]");
        }
        return partETag;
    }

    /**
     * 分片上传完成
     *
     * @param path 完整文件路径
     */
    public UploadResult chunkUploadComplete(String path, String uploadId, List<PartETag> partETags) {
        try {
            CompleteMultipartUploadRequest completeMultipartUploadRequest =
                new CompleteMultipartUploadRequest(properties.getBucketName(), path, uploadId, partETags);
            CompleteMultipartUploadResult completeMultipartUploadResult = client.completeMultipartUpload(completeMultipartUploadRequest);
            System.out.println(completeMultipartUploadResult.getETag());
        } catch (Exception e) {
            throw new OssException("上传文件失败,请检查配置信息:[" + e.getMessage() + "]");
        }
        return UploadResult.builder().url(getUrl() + "/" + path).filename(path).build();
    }

    /**
     * @param path
     * @param uploadId
     * @return
     */
    public List<PartSummary> getUploadedParts(String path, String uploadId) {
        ListPartsRequest listPartsRequest = new ListPartsRequest(properties.getBucketName(), path, uploadId);
        PartListing partListing = client.listParts(listPartsRequest);
        return partListing.getParts();
    }

    /**
     * 检查 文件是否已经存在
     *
     * @param path 文件名
     * @return t/f
     */
    public Boolean checkFileExist(String path) {
        return client.doesObjectExist(properties.getBucketName(), path);
    }


}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105

RedisUtils 类扩展

RedisUtils 类添加两个方法

    public static <V> V setCacheMapValueIfAbsent(final String key, final String mayKey, V mapValue) {
        RMap<String, V> rMap = CLIENT.getMap(key);
        rMap.putIfAbsent(mayKey, mapValue);
        return mapValue;
    }

    public static <V> V setCacheMapValueIfExist(final String key, final String mayKey, V mapValue) {
        RMap<String, V> rMap = CLIENT.getMap(key);
        rMap.putIfExists(mayKey, mapValue);
        return mapValue;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

OSS 服务层 接口层封装

system模块

SysOss 以及对应数据库表扩展字段

package org.dromara.system.domain;

import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.tenant.core.TenantEntity;

/**
 * OSS对象存储对象
 *
 * @author Lion Li
 */
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("sys_oss")
public class SysOss extends TenantEntity {

    /**
     * 对象存储主键
     */
    @TableId(value = "oss_id")
    private Long ossId;

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

    /**
     * 原名
     */
    private String originalName;

    /**
     * 文件后缀名
     */
    private String fileSuffix;

    /**
     * URL地址
     */
    private String url;

    /**
     * 服务商
     */
    private String service;

    // =================== 文件分片扩展字段 ===================
    /**
     * 文件内容 唯一标识 md5 (文件分片、总文件整体)
     */
    private String identifier;
    /**
     * 文件前端上传请求唯一标识
     */
    private String requestId;
    /**
     * 文件上传状态
     *
     * @see org.dromara.common.oss.chunkfile.enumd.FileUploadStatus
     */
    private String uploadStatus;
    /**
     * 文件后端上传请求唯一标识
     */
    private String uploadId;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70

SysOssVo 类扩展字段

package org.dromara.system.domain.vo;

import org.dromara.common.translation.annotation.Translation;
import org.dromara.common.translation.constant.TransConstant;
import org.dromara.system.domain.SysOss;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;

import java.io.Serial;
import java.io.Serializable;
import java.util.Date;

/**
 * OSS对象存储视图对象 sys_oss
 *
 * @author Lion Li
 */
@Data
@AutoMapper(target = SysOss.class)
public class SysOssVo implements Serializable {

    @Serial
    private static final long serialVersionUID = 1L;

    /**
     * 对象存储主键
     */
    private Long ossId;

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

    /**
     * 原名
     */
    private String originalName;

    /**
     * 文件后缀名
     */
    private String fileSuffix;

    /**
     * URL地址
     */
    private String url;

    /**
     * 创建时间
     */
    private Date createTime;

    /**
     * 上传人
     */
    private Long createBy;

    /**
     * 上传人名称
     */
    @Translation(type = TransConstant.USER_ID_TO_NAME, mapper = "createBy")
    private String createByName;

    /**
     * 服务商
     */
    private String service;
    /**
     * 文件前端上传请求唯一标识
     */
    private String requestId;

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76

Service层

ISysOssService


    // ============================== 分片上传 ============================

    /**
     * 分片文件上传OSS对象存储,秒传检验
     *
     * @param chunkFileInfoBO 分片文件信息
     * @return 分片文件上传返回结果
     */
    FileUploadResult getChunkUpload(ChunkFileInfoBO chunkFileInfoBO);

    /**
     * 分片文件上传 OSS对象存储
     *
     * @param file            分片文件
     * @param chunkFileInfoBO 分片文件信息
     * @return 上传结果
     */
    FileUploadResult chunkUpload(MultipartFile file, ChunkFileInfoBO chunkFileInfoBO);

    /**
     * 文件分片上传完成 合并
     *
     * @param fileMergeBO 分片合并上传参数
     * @return vo
     */
    SysOssVo chunkUploadMerge(FileMergeBO fileMergeBO);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

SysOssServiceImpl


    // ============================== 分片上传 ============================

    /**
     * 分片文件上传OSS对象存储,秒传检验
     *
     * @param chunkFileInfoBO 分片文件信息
     * @return 分片文件上传返回结果
     */
    @Override
    public FileUploadResult getChunkUpload(ChunkFileInfoBO chunkFileInfoBO) {
        OssClient storage = OssFactory.instance();
        SysOss ossFromDb = baseMapper.selectOne(new LambdaQueryWrapper<SysOss>()
            .eq(SysOss::getIdentifier, chunkFileInfoBO.getIdentifier())
            .eq(SysOss::getService, storage.getConfigKey())
            .last("limit 1"));
        // 保存 文件上传日志
        SysOss newOssFile = saveFileUploadLog(ossFromDb, storage, chunkFileInfoBO.getFilename(),
            chunkFileInfoBO.getRequestId(), chunkFileInfoBO.getIdentifier(),
            chunkFileInfoBO.getTotalChunks() > 1);
        FileUploadResult fileUploadResult = getObjectFromSysOss(newOssFile);
        //如果文件上传完成,则秒传结束
        if (FileUploadStatus.UPLOADED.getCode().equals(newOssFile.getUploadStatus())) {
            fileUploadResult.setSkipUpload(true);
            fileUploadResult.setNeedMerge(false);
            return fileUploadResult;
        } else {
            String filePartKey = OssConstant.CHUNK_FILE_PART_PREFIX + chunkFileInfoBO.getIdentifier();
            // 如果文件上传信息不存在,则缓存文件共性信息
            putInCache(newOssFile, chunkFileInfoBO.getTotalChunks());
            //如果需要分片
            if (chunkFileInfoBO.getTotalChunks() > 1) {
                //获取已上传的分片信息 Map<partNumber, eTag>
                Map<String, String> partNumMap = null;
                try {
                    partNumMap = getUploadedPartNums(newOssFile.getFileName(), newOssFile.getUploadId());
                } catch (Exception e) {
                    //如果文件已存在,则直接更新为完成
                    if (storage.checkFileExist(newOssFile.getFileName())) {
                        baseMapper.update(null, new LambdaUpdateWrapper<SysOss>()
                            .set(SysOss::getUploadStatus, FileUploadStatus.UPLOADED)
                            .eq(SysOss::getIdentifier, newOssFile.getIdentifier())
                            .eq(SysOss::getUploadStatus, FileUploadStatus.UPLOADING)
                            .eq(SysOss::getService, newOssFile.getService()));
                        fileUploadResult.setSkipUpload(true);
                        fileUploadResult.setNeedMerge(false);
                        return fileUploadResult;
                    }
                    throw new ServiceException(e.getMessage());
                }

                RedisUtils.setCacheMap(filePartKey, partNumMap);
                fileUploadResult.setUploaded(partNumMap.keySet());
            }

            fileUploadResult.setSkipUpload(false);
            fileUploadResult.setNeedMerge(chunkFileInfoBO.getTotalChunks() > 1);

            return fileUploadResult;
        }
    }

    /**
     * 根据新增到 sys_oss 中的实例 拼接分片上传返回结果
     *
     * @param sysOss 数据库对象实例
     * @return Result
     */
    private FileUploadResult getObjectFromSysOss(SysOss sysOss) {
        FileUploadResult fileUploadResult = new FileUploadResult();
        fileUploadResult.setFileName(sysOss.getOriginalName());
        fileUploadResult.setIdentifier(sysOss.getIdentifier());
        fileUploadResult.setRequestId(sysOss.getRequestId());
        fileUploadResult.setOssFileId(sysOss.getOssId());
        fileUploadResult.setUrl(sysOss.getUrl());
        return fileUploadResult;
    }

    /**
     * @param newOssFile
     * @param totalChunks
     */
    private void putInCache(SysOss newOssFile, int totalChunks) {
        String fileInfoKey = OssConstant.CHUNK_FILE_INFO_PREFIX + newOssFile.getIdentifier();
        SysOssRedisDTO ossRedisDTO = new SysOssRedisDTO();
        ossRedisDTO.setUploadId(newOssFile.getUploadId());
        ossRedisDTO.setUrl(newOssFile.getUrl());
        ossRedisDTO.setFilePathName(newOssFile.getFileName());
        ossRedisDTO.setIdentifier(newOssFile.getIdentifier());
        ossRedisDTO.setOssService(newOssFile.getService());
        RedisUtils.setObjectIfAbsent(fileInfoKey, ossRedisDTO, Duration.ofMinutes(totalChunks * 2L));
    }

    /**
     * 保存文件上传日志 文件信息保存到sys_oss中
     *
     * @param ossFromDb        根据md5标识从数据库查询的信息,可能为null
     * @param storage          AWS S3实例
     * @param originalFileName 原始文件名
     * @param requestId        文件前端上传请求唯一标识
     * @param identifier       文件内容唯一标识 md5
     * @param ifChunkUpload    是否分片上传 (总块数>1 的时候分片上传)
     * @return
     */
    private SysOss saveFileUploadLog(SysOss ossFromDb, OssClient storage,
                                     String originalFileName, String requestId,
                                     String identifier, boolean ifChunkUpload) {

        String suffix = StringUtils.substring(originalFileName, originalFileName.lastIndexOf("."), originalFileName.length());
        //获取随机文件路径
        String ossFilePath = storage.getPath(suffix);
        SysOss newEntity = new SysOss();
        newEntity.setRequestId(requestId);
        //文件的全路径名
        newEntity.setFileName(ossFilePath);
        newEntity.setOriginalName(originalFileName);
        newEntity.setIdentifier(identifier);
        newEntity.setFileSuffix(suffix);
        newEntity.setUploadStatus(FileUploadStatus.UPLOADING.getCode());
        // oss为null,说明是没有上传过的文件
        if (ObjectUtils.isEmpty(ossFromDb)) {
            if (ifChunkUpload) {
                // 获取分片上传的统一id,即uploadId
                String uploadId = storage.getChunkUploadUnionId(ossFilePath, "");
                newEntity.setUploadId(uploadId);
            }
            newEntity.setService(storage.getConfigKey());
            newEntity.setUrl(storage.getUrl() + "/" + ossFilePath);
        } else {// oss不为null,说明是之前上传过的文件
            newEntity.setService(ossFromDb.getService());
            newEntity.setUrl(ossFromDb.getUrl());
            newEntity.setUploadId(ossFromDb.getUploadId());
            if (FileUploadStatus.UPLOADED.getCode().equals(ossFromDb.getUploadStatus())) {
                newEntity.setUploadStatus(FileUploadStatus.UPLOADED.getCode());
            }
            //如果已存在同样的文件,则文件云存储名称也一致
            newEntity.setFileName(ossFromDb.getFileName());
        }

        baseMapper.insert(newEntity);
        return newEntity;
    }

    /**
     * 获取已上传的分片序号
     *
     * @param path     文件名
     * @param uploadId 分片上传统一id
     * @return Map<partNumber, eTag>
     **/
    private Map<String, String> getUploadedPartNums(String path, String uploadId) {
        OssClient storage = OssFactory.instance();
        List<PartSummary> partSummaryList = storage.getUploadedParts(path, uploadId);
        return partSummaryList.stream().collect(Collectors.toMap(ele -> String.valueOf(ele.getPartNumber()), PartSummary::getETag));
    }

    /**
     * 分片文件上传 OSS对象存储
     *
     * @param file            分片文件
     * @param chunkFileInfoBO 分片文件信息
     * @return 上传结果
     */
    @Override
    public FileUploadResult chunkUpload(MultipartFile file, ChunkFileInfoBO chunkFileInfoBO) {
        FileUploadResult fileUploadResult = getObjectFromChunkFileInfo(chunkFileInfoBO);
        OssClient storage = OssFactory.instance();
        String fileInfoKey = OssConstant.CHUNK_FILE_INFO_PREFIX + chunkFileInfoBO.getIdentifier();
        SysOssRedisDTO ossRedisDTO = RedisUtils.getCacheObject(fileInfoKey);
        if (ObjectUtils.isEmpty(ossRedisDTO)) {
            throw new ServiceException("未查询到要上传的文件信息");
        }
        fileUploadResult.setUrl(ossRedisDTO.getUrl());

        // 文件的唯一标识
        String filePartKey = OssConstant.CHUNK_FILE_PART_PREFIX + chunkFileInfoBO.getIdentifier();

        // 文件分片编号
        Integer partNum = chunkFileInfoBO.getChunkNumber();
        String value = RedisUtils.setCacheMapValueIfAbsent(filePartKey, String.valueOf(partNum), "");
        //PartETag partETag=null;
        if (StringUtils.isEmpty(value)) {
            //分片总数<=1,直接pull上传
            if (chunkFileInfoBO.getTotalChunks() <= 1) {
                try {
                    storage.upload(file.getBytes(), ossRedisDTO.getFilePathName(), file.getContentType());
                } catch (Exception e) {
                    throw new ServiceException(e.getMessage());
                }
                baseMapper.update(null, new LambdaUpdateWrapper<SysOss>()
                    .set(SysOss::getUploadStatus, FileUploadStatus.UPLOADED.getCode())
                    .eq(SysOss::getIdentifier, chunkFileInfoBO.getIdentifier())
                    .eq(SysOss::getService, ossRedisDTO.getOssService()));
                RedisUtils.deleteObject(filePartKey);
                return fileUploadResult;
            }
            //否则分片上传
            // 文件分片大小
            Long partSize = chunkFileInfoBO.getCurrentChunkSize();
            try {
                PartETag partETag = storage.chunkUpload(file.getInputStream(), ossRedisDTO.getFilePathName(), ossRedisDTO.getUploadId(), partSize, partNum);
                RedisUtils.setCacheMapValueIfExist(filePartKey, String.valueOf(partETag.getPartNumber()), partETag.getETag());
            } catch (IOException e) {
                throw new ServiceException(e.getMessage());
            }
        } else {
            fileUploadResult.setSkipUpload(true);
            //partETag=new PartETag(partNum,value);
        }
        return fileUploadResult;
    }

    private FileUploadResult getObjectFromChunkFileInfo(ChunkFileInfoBO chunkFileInfoBO) {
        FileUploadResult fileUploadResult = new FileUploadResult();
        fileUploadResult.setSkipUpload(false);
        fileUploadResult.setCurrentChunkNum(chunkFileInfoBO.getChunkNumber());
        fileUploadResult.setFileName(chunkFileInfoBO.getFilename());
        fileUploadResult.setIdentifier(chunkFileInfoBO.getIdentifier());
        fileUploadResult.setRequestId(chunkFileInfoBO.getRequestId());
        fileUploadResult.setNeedMerge(chunkFileInfoBO.getTotalChunks() > 1);
        return fileUploadResult;
    }

    /**
     * 文件分片上传完成 合并
     *
     * @param fileMergeBO 分片合并上传参数
     * @return vo
     */
    @Override
    public SysOssVo chunkUploadMerge(FileMergeBO fileMergeBO) {
        String identifier = fileMergeBO.getIdentifier();
        OssClient storage = OssFactory.instance();
        String fileInfoKey = OssConstant.CHUNK_FILE_INFO_PREFIX + identifier;
        if (!RedisUtils.isExistsObject(fileInfoKey)) {
            throw new ServiceException("未找到该文件上传标识:" + identifier + "对应的文件上传信息");
        }
        SysOssRedisDTO ossRedisDTO = RedisUtils.getCacheObject(fileInfoKey);

        String filePartKey = OssConstant.CHUNK_FILE_PART_PREFIX + identifier;
        if (!RedisUtils.isExistsObject(filePartKey)) {
            throw new ServiceException("未找到该文件上传标识:" + identifier + "上传成功的分片信息");
        }
        //获取已上传的所有分片信息
        List<PartETag> partETagList = getUploadedPartETagList(filePartKey, fileMergeBO.getTotalChunks(), identifier);
        try {
            storage.chunkUploadComplete(ossRedisDTO.getFilePathName(), ossRedisDTO.getUploadId(), partETagList);
        } catch (Exception e) {
            SysOss oss = baseMapper.selectOne(new LambdaQueryWrapper<SysOss>().eq(SysOss::getRequestId, fileMergeBO.getRequestId()));
            if (FileUploadStatus.UPLOADED.equals(oss.getUploadStatus())) {
                // 更新文件信息
                return this.updateResultEntity(ossRedisDTO, storage, fileMergeBO.getFilename(), fileMergeBO.getRequestId(), filePartKey);
            }
            throw new ServiceException("[文件合并失败]:" + e.getMessage());
        }
        return this.updateResultEntity(ossRedisDTO, storage, fileMergeBO.getFilename(), fileMergeBO.getRequestId(), filePartKey);

    }

    private SysOssVo updateResultEntity(SysOssRedisDTO ossRedisDTO, OssClient storage,
                                        String originalName, String requestId, String filePartKey) {
        SysOss oss = new SysOss();
        oss.setUploadStatus(FileUploadStatus.UPLOADED.getCode());
        baseMapper.update(oss, new LambdaUpdateWrapper<SysOss>()
            .eq(SysOss::getIdentifier, ossRedisDTO.getIdentifier())
            .eq(SysOss::getUploadStatus, FileUploadStatus.UPLOADING.getCode())
            .eq(SysOss::getService, storage.getConfigKey()));
        RedisUtils.expire(filePartKey, Duration.ofMinutes(10));
        SysOssVo sysOssVo = new SysOssVo();
        //sysOssVo.setOssId(ossFileId);
        sysOssVo.setRequestId(requestId);
        sysOssVo.setService(ossRedisDTO.getOssService());
        sysOssVo.setOriginalName(originalName);
        sysOssVo.setUrl(ossRedisDTO.getUrl());
        return this.matchingUrl(sysOssVo);
    }

    /**
     * 获取已上传的分片信息
     *
     * @param filePartKey
     * @param totalChunks
     * @param identifier
     * @return java.util.List<com.amazonaws.services.s3.model.PartETag>
     * @author 11298
     * @date 20:29 2023/8/22
     **/
    private List<PartETag> getUploadedPartETagList(String filePartKey, int totalChunks, String identifier) {
        Map<String, String> partETagMap = RedisUtils.getCacheMap(filePartKey);
        if (partETagMap.size() != totalChunks) {
            throw new ServiceException("该文件标识:" + identifier + "对应的分片数据未完全上传成功");
        }
        Set<String> set = new HashSet<>();
        partETagMap.forEach((key, value) -> {
            if ("".equals(value)) {
                set.add(key);
            }
        });
        if (set.size() > 0) {
            throw new ServiceException("文件上传失败,第" + set + "分片未上传成功");
        }

        List<PartETag> partETagList = new ArrayList<>();
        partETagMap.entrySet().forEach(ele -> {
            partETagList.add(new PartETag(Integer.parseInt(ele.getKey()), ele.getValue()));
        });
        return partETagList;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308

Controller

SysOssController


    // ============================== 分片上传 ============================

    /**
     * 分片文件上传OSS对象存储,秒传检验
     *
     * @param chunkFileInfoBO 分片文件信息
     * @return 检验结果
     */
    @SaCheckPermission("system:oss:upload")
    //@Log(title = "OSS对象存储", businessType = BusinessType.INSERT)
    @GetMapping(value = "/chunkUpload")
    public R<FileUploadResult> chunkUpload(ChunkFileInfoBO chunkFileInfoBO) {
        if (ObjectUtil.isNull(chunkFileInfoBO)) {
            return R.fail("分片查询条件不能为空");
        }
        FileUploadResult fileUploadResult = ossService.getChunkUpload(chunkFileInfoBO);
        return R.ok(fileUploadResult);
    }


    /**
     * 分片文件上传 OSS对象存储
     *
     * @param file            分片文件
     * @param chunkFileInfoBO 分片文件信息
     * @return R 上传结果
     */
    @SaCheckPermission("system:oss:upload")
    //@Log(title = "OSS对象存储", businessType = BusinessType.INSERT)
    @PostMapping(value = "/chunkUpload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public R<FileUploadResult> chunkUpload(@RequestPart("file") MultipartFile file, ChunkFileInfoBO chunkFileInfoBO) {
        if (ObjectUtil.isNull(file)) {
            return R.fail("上传文件不能为空");
        }
        FileUploadResult fileUploadResult = ossService.chunkUpload(file, chunkFileInfoBO);
        return R.ok(fileUploadResult);
    }

    /**
     * 分片文件上传 OSS对象存储完成 合并
     *
     * @param fileMergeBO 文件分片上传完成对象
     */
    @SaCheckPermission("system:oss:upload")
    @Log(title = "OSS对象存储(分片文件)", businessType = BusinessType.INSERT)
    @PostMapping(value = "/chunkUploadMerge")
    public R<Map<String, String>> chunkUploadMerge(@Validated @RequestBody FileMergeBO fileMergeBO) {

        SysOssVo oss = ossService.chunkUploadMerge(fileMergeBO);
        Map<String, String> map = new HashMap<>(2);
        map.put("url", oss.getUrl());
        map.put("fileName", fileMergeBO.getFilename());
        map.put("requestId", fileMergeBO.getRequestId());
        map.put("identifier", fileMergeBO.getIdentifier());
        return R.ok(map);
    }
```
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
本文内容由网友自发贡献,转载请注明出处:【wpsshop博客】
推荐阅读
相关标签
  

闽ICP备14008679号