pom.xml

@@ -257,13 +257,25 @@ org.springframework.boot</groupId>-->
 			<version>2.3</version>
 		</dependency>
 		<dependency>
-			<groupId>minio</groupId>
+			<groupId>io.minio</groupId>
 			<artifactId>minio</artifactId>
-			<version>0.6.0.11</version>
-			<scope>system</scope>
-			<systemPath>
-				${project.basedir}/src/main/resources/lib/minio-6.0.11.jar
-			</systemPath>
+			<version>8.5.2</version>
+			<exclusions>
+				<exclusion>
+					<artifactId>okhttp</artifactId>
+					<groupId>com.squareup.okhttp3</groupId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+		<dependency>
+			<groupId>com.squareup.okhttp3</groupId>
+			<artifactId>okhttp</artifactId>
+			<version>4.10.0</version>
+		</dependency>
+		<dependency>
+			<groupId>org.jetbrains.kotlin</groupId>
+			<artifactId>kotlin-stdlib</artifactId>
+			<version>1.3.70</version>
 		</dependency>
 		<dependency>
 			<groupId>autoconfigure</groupId>

src/main/java/com/unis/crk/file/controller/CommonCacheOperator.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.controller;
+
+import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.map.MapUtil;
+import cn.hutool.core.util.StrUtil;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+/**
+ * 通用Redis缓存操作器
+ *
+ * @author xuyuxiang
+ * @date 2022/6/21 16:00
+ **/
+@Component
+public class CommonCacheOperator {
+
+    /** 所有缓存Key的前缀 */
+    private static final String CACHE_KEY_PREFIX = "Cache:";
+
+    @Resource
+    private RedisTemplate<String, Object> redisTemplate;
+
+    public void put(String key, Object value) {
+        redisTemplate.boundValueOps(CACHE_KEY_PREFIX + key).set(value);
+    }
+
+    public void put(String key, Object value, long timeoutSeconds) {
+        redisTemplate.boundValueOps(CACHE_KEY_PREFIX + key).set(value, timeoutSeconds, TimeUnit.SECONDS);
+    }
+
+    public Object get(String key) {
+        return redisTemplate.boundValueOps(CACHE_KEY_PREFIX + key).get();
+    }
+
+    public void remove(String... key) {
+        ArrayList<String> keys = CollectionUtil.toList(key);
+        List<String> withPrefixKeys = keys.stream().map(i -> CACHE_KEY_PREFIX + i).collect(Collectors.toList());
+        redisTemplate.delete(withPrefixKeys);
+    }
+
+    public Collection<String> getAllKeys() {
+        Set<String> keys = redisTemplate.keys(CACHE_KEY_PREFIX + "*");
+        if (keys != null) {
+            // 去掉缓存key的common prefix前缀
+            return keys.stream().map(key -> StrUtil.removePrefix(key, CACHE_KEY_PREFIX)).collect(Collectors.toSet());
+        } else {
+            return CollectionUtil.newHashSet();
+        }
+    }
+
+    public Collection<Object> getAllValues() {
+        Set<String> keys = redisTemplate.keys(CACHE_KEY_PREFIX + "*");
+        if (keys != null) {
+            return redisTemplate.opsForValue().multiGet(keys);
+        } else {
+            return CollectionUtil.newArrayList();
+        }
+    }
+
+    public Map<String, Object> getAllKeyValues() {
+        Collection<String> allKeys = this.getAllKeys();
+        HashMap<String, Object> results = MapUtil.newHashMap();
+        for (String key : allKeys) {
+            results.put(key, this.get(key));
+        }
+        return results;
+    }
+
+    public void removeBatch(String pattern) {
+        Set<String> keys = redisTemplate.keys(CACHE_KEY_PREFIX + pattern);
+        if (keys != null) {
+            redisTemplate.delete(keys);
+        }
+    }
+}

src/main/java/com/unis/crk/file/controller/DevFileController.java

@@ -0,0 +1,152 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.controller;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.unis.crk.file.entity.DevFile;
+import com.unis.crk.file.enums.DevFileEngineTypeEnum;
+import com.unis.crk.file.param.DevFileIdParam;
+import com.unis.crk.file.param.DevFileListParam;
+import com.unis.crk.file.param.DevFilePageParam;
+import com.unis.crk.file.service.DevFileService;
+import com.unis.crk.file.util.CommonResult;
+import com.unis.crk.file.util.DevConfigApi;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.http.MediaType;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletResponse;
+import javax.validation.Valid;
+import javax.validation.constraints.NotEmpty;
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * 文件控制器
+ *
+ * @author xuyuxiang
+ * @date 2022/2/23 18:26
+ **/
+@Api(tags = "文件控制器")
+@RestController
+@Validated
+public class DevFileController {
+
+    /** 默认文件引擎 */
+    private static final String SNOWY_SYS_DEFAULT_FILE_ENGINE_KEY = "SNOWY_SYS_DEFAULT_FILE_ENGINE";
+
+
+    @Resource
+    private DevFileService devFileService;
+
+
+
+
+
+
+
+    /**
+
+
+    /**
+     * MINIO文件上传，返回文件id
+     *
+     * @author xuyuxiang
+     * @date 2021/10/13 14:01
+     **/
+    @ApiOperation("上传MINIO文件返回id")
+    @PostMapping("/dev/file/uploadMinioReturnId")
+    public CommonResult<String> uploadMinioReturnId(@RequestPart("file") MultipartFile file) {
+        return CommonResult.data(devFileService.uploadReturnId(DevFileEngineTypeEnum.MINIO.getValue(), file));
+    }
+
+    /**
+     * MINIO文件上传，返回文件Url
+     *
+     * @author xuyuxiang
+     * @date 2021/10/13 14:01
+     **/
+    @ApiOperation("上传MINIO文件返回url")
+    @PostMapping("/dev/file/uploadMinioReturnUrl")
+    public CommonResult<String> uploadMinioReturnUrl(@RequestPart("file") MultipartFile file) {
+        return CommonResult.data(devFileService.uploadReturnUrl(DevFileEngineTypeEnum.MINIO.getValue(), file));
+    }
+
+
+
+    /**
+     * 获取文件分页列表
+     *
+     * @author xuyuxiang
+     * @date 2022/4/24 20:00
+     */
+    @ApiOperation("获取文件分页列表")
+    @GetMapping("/dev/file/page")
+    public CommonResult<Page<DevFile>> page(DevFilePageParam devFilePageParam) {
+        return CommonResult.data(devFileService.page(devFilePageParam));
+    }
+
+    /**
+     * 获取文件列表
+     *
+     * @author xuyuxiang
+     * @date 2022/4/24 20:00
+     */
+    @ApiOperation("获取文件列表")
+    @GetMapping("/dev/file/list")
+    public CommonResult<List<DevFile>> list(DevFileListParam devFileListParam) {
+        return CommonResult.data(devFileService.list(devFileListParam));
+    }
+
+    /**
+     * 下载文件
+     *
+     * @author xuyuxiang
+     * @date 2022/6/21 15:44
+     **/
+    @ApiOperation("下载文件")
+    @GetMapping(value = "/dev/file/download", produces = MediaType.APPLICATION_OCTET_STREAM_VALUE)
+    public void download(@Valid DevFileIdParam devFileIdParam, HttpServletResponse response) throws IOException {
+        devFileService.download(devFileIdParam, response);
+    }
+
+    /**
+     * 删除文件
+     *
+     * @author xuyuxiang
+     * @date 2022/4/24 20:00
+     */
+    @ApiOperation("删除文件")
+    @PostMapping(value = "/dev/file/delete")
+    public CommonResult<String> delete(@RequestBody @Valid @NotEmpty(message = "集合不能为空")
+                                               List<DevFileIdParam> devFileIdParamList) {
+        devFileService.delete(devFileIdParamList);
+        return CommonResult.ok();
+    }
+
+    /**
+     * 获取文件详情
+     *
+     * @author xuyuxiang
+     * @date 2022/6/21 15:44
+     **/
+    @ApiOperation("获取文件详情")
+    @GetMapping("/dev/file/detail")
+    public CommonResult<DevFile> detail(@Valid DevFileIdParam devFileIdParam) {
+        return CommonResult.data(devFileService.detail(devFileIdParam));
+    }
+}

src/main/java/com/unis/crk/file/entity/DevConfig.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.entity;
+
+import com.baomidou.mybatisplus.annotation.FieldFill;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableLogic;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.Date;
+
+/**
+ * 配置实体
+ *
+ * @author xuyuxiang
+ * @date 2022/2/23 18:27
+ **/
+@Getter
+@Setter
+@TableName("DEV_CONFIG")
+public class DevConfig  {
+
+    /** id */
+    @ApiModelProperty(value = "id", position = 1)
+    private String id;
+
+    /** 配置键 */
+    @ApiModelProperty(value = "配置键", position = 2)
+    private String configKey;
+
+    /** 配置值 */
+    @ApiModelProperty(value = "配置值", position = 3)
+    private String configValue;
+
+    /** 分类 */
+    @ApiModelProperty(value = "分类", position = 4)
+    private String category;
+
+    /** 备注 */
+    @ApiModelProperty(value = "备注", position = 5)
+    private String remark;
+
+    /** 排序码 */
+    @ApiModelProperty(value = "排序码", position = 6)
+    private Integer sortCode;
+
+    /** 扩展信息 */
+    @ApiModelProperty(value = "扩展信息", position = 7)
+    private String extJson;
+
+    /** 删除标志 */
+    @JsonIgnore
+    @ApiModelProperty(value = "删除标志", position = 999)
+    @TableField(fill = FieldFill.INSERT)
+    private String deleteFlag;
+
+    /** 创建时间 */
+    @ApiModelProperty(value = "创建时间", position = 1000)
+    @TableField(fill = FieldFill.INSERT)
+    private Date createTime;
+
+    /** 创建人 */
+    @ApiModelProperty(value = "创建人", position = 1001)
+    @TableField(fill = FieldFill.INSERT)
+    private String createUser;
+
+    /** 创建人名称 */
+    @ApiModelProperty(value = "创建人名称", position = 1002)
+    @TableField(exist = false)
+    private String createUserName;
+
+    /** 更新时间 */
+    @ApiModelProperty(value = "更新时间", position = 1003)
+    @TableField(fill = FieldFill.UPDATE)
+    private Date updateTime;
+
+    /** 更新人 */
+    @ApiModelProperty(value = "更新人", position = 1004)
+    @TableField(fill = FieldFill.UPDATE)
+    private String updateUser;
+
+    /** 更新人名称 */
+    @ApiModelProperty(value = "更新人名称", position = 1005)
+    @TableField(exist = false)
+    private String updateUserName;
+}

src/main/java/com/unis/crk/file/entity/DevFile.java

@@ -0,0 +1,109 @@
+package com.unis.crk.file.entity;
+
+import com.baomidou.mybatisplus.annotation.FieldFill;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableLogic;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.Date;
+
+/**
+ * 文件实体
+ *
+ * @author xuyuxiang
+ * @date 2022/2/23 18:27
+ **/
+@Getter
+@Setter
+@TableName("DEV_FILE")
+public class DevFile   {
+
+    /** id */
+    @ApiModelProperty(value = "id", position = 1)
+    private String id;
+
+    /** 存储引擎 */
+    @ApiModelProperty(value = "存储引擎", position = 2)
+    private String engine;
+
+    /** 存储桶 */
+    @ApiModelProperty(value = "存储桶", position = 3)
+    private String bucket;
+
+    /** 文件名称 */
+    @ApiModelProperty(value = "文件名称", position = 4)
+    private String name;
+
+    /** 文件后缀 */
+    @ApiModelProperty(value = "文件后缀", position = 5)
+    private String suffix;
+
+    /** 文件大小kb */
+    @ApiModelProperty(value = "文件大小kb", position = 6)
+    private String sizeKb;
+
+    /** 文件大小（格式化后） */
+    @ApiModelProperty(value = "文件大小（格式化后）", position = 7)
+    private String sizeInfo;
+
+    /** 文件的对象名（唯一名称） */
+    @ApiModelProperty(value = "文件的对象名（唯一名称）", position = 8)
+    private String objName;
+
+    /** 文件存储路径 */
+    @ApiModelProperty(value = "文件存储路径", position = 9)
+    private String storagePath;
+
+    /** 文件下载路径 */
+    @ApiModelProperty(value = "文件下载路径", position = 10)
+    private String downloadPath;
+
+    /** 图片缩略图 */
+    @ApiModelProperty(value = "图片缩略图", position = 11)
+    private String thumbnail;
+
+    /** 扩展信息 */
+    @ApiModelProperty(value = "扩展信息", position = 12)
+    private String extJson;
+
+
+    /** 删除标志 */
+    @JsonIgnore
+    @ApiModelProperty(value = "删除标志", position = 999)
+    @TableField(fill = FieldFill.INSERT)
+    private String deleteFlag;
+
+    /** 创建时间 */
+    @ApiModelProperty(value = "创建时间", position = 1000)
+    @TableField(fill = FieldFill.INSERT)
+    private Date createTime;
+
+    /** 创建人 */
+    @ApiModelProperty(value = "创建人", position = 1001)
+    @TableField(fill = FieldFill.INSERT)
+    private String createUser;
+
+    /** 创建人名称 */
+    @ApiModelProperty(value = "创建人名称", position = 1002)
+    @TableField(exist = false)
+    private String createUserName;
+
+    /** 更新时间 */
+    @ApiModelProperty(value = "更新时间", position = 1003)
+    @TableField(fill = FieldFill.UPDATE)
+    private Date updateTime;
+
+    /** 更新人 */
+    @ApiModelProperty(value = "更新人", position = 1004)
+    @TableField(fill = FieldFill.UPDATE)
+    private String updateUser;
+
+    /** 更新人名称 */
+    @ApiModelProperty(value = "更新人名称", position = 1005)
+    @TableField(exist = false)
+    private String updateUserName;
+}

src/main/java/com/unis/crk/file/enums/DevFileBucketAuthEnum.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.enums;
+
+/**
+ * 文件存储桶的权限策略枚举
+ *
+ * @author xuyuxiang
+ * @date 2022/1/5 23:29
+ */
+public enum DevFileBucketAuthEnum {
+
+    /**
+     * 私有的（仅有 owner 可以读写）
+     */
+    PRIVATE,
+
+    /**
+     * 公有读，私有写（ owner 可以读写， 其他客户可以读）
+     */
+    PUBLIC_READ,
+
+    /**
+     * 公共读写（即所有人都可以读写，慎用）
+     */
+    PUBLIC_READ_WRITE
+
+}

src/main/java/com/unis/crk/file/enums/DevFileEngineTypeEnum.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.enums;
+
+import lombok.Getter;
+
+/**
+ * 文件存储引擎类型枚举
+ *
+ * @author xuyuxiang
+ * @date 2022/6/16 16:14
+ **/
+@Getter
+public enum DevFileEngineTypeEnum {
+
+    /** 本地 */
+    LOCAL("LOCAL"),
+
+    /** 阿里云 */
+    ALIYUN("ALIYUN"),
+
+    /** 腾讯云 */
+    TENCENT("TENCENT"),
+
+    /** MINIO */
+    MINIO("MINIO");
+
+    private final String value;
+
+    DevFileEngineTypeEnum(String value) {
+        this.value = value;
+    }
+}

src/main/java/com/unis/crk/file/mapper/DevConfigMapper.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.unis.crk.file.entity.DevConfig;
+
+/**
+ * 配置Mapper接口
+ *
+ * @author xuyuxiang
+ * @date 2022/4/22 10:43
+ **/
+public interface DevConfigMapper extends BaseMapper<DevConfig> {
+}

src/main/java/com/unis/crk/file/mapper/DevFileMapper.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.unis.crk.file.entity.DevFile;
+
+/**
+ * 文件Mapper接口
+ *
+ * @author xuyuxiang
+ * @date 2022/2/23 18:40
+ **/
+public interface DevFileMapper extends BaseMapper<DevFile> {
+}

src/main/java/com/unis/crk/file/mapper/mapping/DevConfigMapper.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.unis.dev.modular.config.mapper.DevConfigMapper">
+
+
+</mapper>

src/main/java/com/unis/crk/file/mapper/mapping/DevFileMapper.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.unis.dev.modular.file.mapper.DevFileMapper">
+
+
+</mapper>

src/main/java/com/unis/crk/file/param/DevFileIdParam.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.param;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotBlank;
+
+/**
+ * 文件Id参数
+ *
+ * @author xuyuxiang
+ * @date 2022/7/31 10:24
+ */
+@Getter
+@Setter
+public class DevFileIdParam {
+
+    /** id */
+    @ApiModelProperty(value = "id", required = true)
+    @NotBlank(message = "id不能为空")
+    private String id;
+}

src/main/java/com/unis/crk/file/param/DevFileListParam.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.param;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 文件列表参数
+ *
+ * @author xuyuxiang
+ * @date 2022/7/31 10:24
+ */
+@Getter
+@Setter
+public class DevFileListParam {
+
+    /** 文件引擎 */
+    @ApiModelProperty(value = "文件引擎")
+    private String engine;
+
+    /** 文件名关键词 */
+    @ApiModelProperty(value = "文件名关键词")
+    private String searchKey;
+}

src/main/java/com/unis/crk/file/param/DevFilePageParam.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.param;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 文件分页列表参数
+ *
+ * @author xuyuxiang
+ * @date 2022/7/31 10:24
+ */
+@Getter
+@Setter
+public class DevFilePageParam {
+
+    /** 文件引擎 */
+    @ApiModelProperty(value = "文件引擎")
+    private String engine;
+
+    /** 文件名关键词 */
+    @ApiModelProperty(value = "文件名关键词")
+    private String searchKey;
+}

src/main/java/com/unis/crk/file/provider/DevConfigApiProvider.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.provider;
+
+import com.unis.crk.file.service.DevConfigService;
+import com.unis.crk.file.util.DevConfigApi;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+
+/**
+ * 配置API接口实现类
+ *
+ * @author xuyuxiang
+ * @date 2022/6/17 14:43
+ **/
+@Service
+public class DevConfigApiProvider implements DevConfigApi {
+
+    @Resource
+    private DevConfigService devConfigService;
+
+    @Override
+    public String getValueByKey(String key) {
+        return devConfigService.getValueByKey(key);
+    }
+}

src/main/java/com/unis/crk/file/provider/DevFileApiProvider.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.provider;
+
+import com.unis.crk.file.enums.DevFileEngineTypeEnum;
+import com.unis.crk.file.service.DevFileService;
+import com.unis.crk.file.util.DevFileApi;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.annotation.Resource;
+
+/**
+ * 文件API接口提供者
+ *
+ * @author xuyuxiang
+ * @date 2022/6/22 15:32
+ **/
+@Service
+public class DevFileApiProvider implements DevFileApi {
+
+    @Resource
+    private DevFileService devFileService;
+
+    @Override
+    public String storageFileWithReturnUrlLocal(MultipartFile file) {
+        return devFileService.uploadReturnUrl(DevFileEngineTypeEnum.LOCAL.getValue(), file);
+    }
+
+    @Override
+    public String storageFileWithReturnIdLocal(MultipartFile file) {
+        return devFileService.uploadReturnId(DevFileEngineTypeEnum.LOCAL.getValue(), file);
+    }
+
+    @Override
+    public String storageFileWithReturnUrlAliyun(MultipartFile file) {
+        return devFileService.uploadReturnUrl(DevFileEngineTypeEnum.ALIYUN.getValue(), file);
+    }
+
+    @Override
+    public String storageFileWithReturnIdAliyun(MultipartFile file) {
+        return devFileService.uploadReturnId(DevFileEngineTypeEnum.ALIYUN.getValue(), file);
+    }
+
+    @Override
+    public String storageFileWithReturnUrlTencent(MultipartFile file) {
+        return devFileService.uploadReturnUrl(DevFileEngineTypeEnum.TENCENT.getValue(), file);
+    }
+
+    @Override
+    public String storageFileWithReturnIdTencent(MultipartFile file) {
+        return devFileService.uploadReturnId(DevFileEngineTypeEnum.TENCENT.getValue(), file);
+    }
+
+    @Override
+    public String storageFileWithReturnUrlMinio(MultipartFile file) {
+        return devFileService.uploadReturnUrl(DevFileEngineTypeEnum.MINIO.getValue(), file);
+    }
+
+    @Override
+    public String storageFileWithReturnIdMinio(MultipartFile file) {
+        return devFileService.uploadReturnId(DevFileEngineTypeEnum.MINIO.getValue(), file);
+    }
+}

src/main/java/com/unis/crk/file/service/DevConfigService.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.service;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.unis.crk.file.entity.DevConfig;
+
+import java.util.List;
+
+/**
+ * 配置Service接口
+ *
+ * @author xuyuxiang
+ * @date 2022/4/22 10:41
+ **/
+public interface DevConfigService extends IService<DevConfig> {
+
+    /**
+     * 根据键获取值
+     *
+     * @author xuyuxiang
+     * @date 2022/4/22 14:52
+     **/
+    String getValueByKey(String key);
+
+
+}

src/main/java/com/unis/crk/file/service/DevFileService.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.service;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.unis.crk.file.entity.DevFile;
+import com.unis.crk.file.param.DevFileIdParam;
+import com.unis.crk.file.param.DevFileListParam;
+import com.unis.crk.file.param.DevFilePageParam;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * 文件Service接口
+ *
+ * @author xuyuxiang
+ * @date 2022/2/23 18:27
+ **/
+public interface DevFileService extends IService<DevFile> {
+
+    /**
+     * MultipartFile文件上传，返回文件id
+     *
+     * @author xuyuxiang
+     * @date 2022/4/22 15:53
+     **/
+    String uploadReturnId(String engine, MultipartFile file);
+
+    /**
+     * MultipartFile文件上传，返回文件Url
+     *
+     * @author xuyuxiang
+     * @date 2022/4/22 15:53
+     **/
+    String uploadReturnUrl(String engine, MultipartFile file);
+
+    /**
+     * 文件分页列表接口
+     *
+     * @author xuyuxiang
+     * @date 2022/6/21 15:44
+     **/
+    Page<DevFile> page(DevFilePageParam devFilePageParam);
+
+    /**
+     * 文件列表接口
+     *
+     * @author xuyuxiang
+     * @date 2022/6/21 15:44
+     **/
+    List<DevFile> list(DevFileListParam devFileListParam);
+
+    /**
+     * 下载文件
+     *
+     * @author xuyuxiang
+     * @date 2022/6/21 15:44
+     **/
+    void download(DevFileIdParam devFileIdParam, HttpServletResponse response) throws IOException;
+
+    /**
+     * 删除文件
+     *
+     * @author xuyuxiang
+     * @date 2022/8/4 10:36
+     **/
+    void delete(List<DevFileIdParam> devFileIdParamList);
+
+    /**
+     * 获取文件详情
+     *
+     * @author xuyuxiang
+     * @date 2022/4/24 21:18
+     */
+    DevFile detail(DevFileIdParam devFileIdParam);
+
+    /**
+     * 获取文件详情
+     *
+     * @author xuyuxiang
+     * @date 2022/4/24 21:18
+     */
+    DevFile queryEntity(String id);
+}

src/main/java/com/unis/crk/file/service/impl/DevConfigServiceImpl.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.service.impl;
+
+import cn.hutool.core.convert.Convert;
+import cn.hutool.core.util.ObjectUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.unis.crk.file.controller.CommonCacheOperator;
+import com.unis.crk.file.entity.DevConfig;
+import com.unis.crk.file.mapper.DevConfigMapper;
+import com.unis.crk.file.service.DevConfigService;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+
+/**
+ * 配置Service接口实现类
+ *
+ * @author xuyuxiang
+ * @date 2022/4/22 10:41
+ **/
+@Service
+public class DevConfigServiceImpl extends ServiceImpl<DevConfigMapper, DevConfig> implements DevConfigService {
+
+    private static final String CONFIG_CACHE_KEY = "dev-config:";
+
+
+    @Resource
+    private CommonCacheOperator commonCacheOperator;
+
+    @Override
+    public String getValueByKey(String key) {
+        // 从缓存中取
+//        Object cacheValue = commonCacheOperator.get(CONFIG_CACHE_KEY + key);
+//        if(ObjectUtil.isNotEmpty(cacheValue)) {
+//            return Convert.toStr(cacheValue);
+//        }
+        DevConfig devConfig = this.getOne(new LambdaQueryWrapper<DevConfig>().eq(DevConfig::getConfigKey, key));
+        if(ObjectUtil.isNotEmpty(devConfig)) {
+            // 更新到缓存
+            commonCacheOperator.put(CONFIG_CACHE_KEY + key, devConfig.getConfigValue());
+            return devConfig.getConfigValue();
+        }
+        return null;
+    }
+
+
+}

src/main/java/com/unis/crk/file/service/impl/DevFileServiceImpl.java

@@ -0,0 +1,275 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.service.impl;
+
+import cn.hutool.core.collection.CollStreamUtil;
+import cn.hutool.core.convert.Convert;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.img.ImgUtil;
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.util.NumberUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.IdWorker;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.unis.crk.file.entity.DevFile;
+import com.unis.crk.file.enums.DevFileEngineTypeEnum;
+import com.unis.crk.file.mapper.DevFileMapper;
+import com.unis.crk.file.param.DevFileIdParam;
+import com.unis.crk.file.param.DevFileListParam;
+import com.unis.crk.file.param.DevFilePageParam;
+import com.unis.crk.file.service.DevFileService;
+import com.unis.crk.file.util.CommonDownloadUtil;
+import com.unis.crk.file.util.CommonProperties;
+import com.unis.crk.file.util.CommonResponseUtil;
+import com.unis.crk.file.util.DevFileMinIoUtil;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletResponse;
+import java.io.File;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.util.List;
+
+/**
+ * 文件Service接口实现类
+ *
+ * @author xuyuxiang
+ * @date 2022/2/23 18:43
+ **/
+@Service
+public class DevFileServiceImpl extends ServiceImpl<DevFileMapper, DevFile> implements DevFileService {
+
+    @Resource
+    private CommonProperties commonProperties;
+
+    @Override
+    public String uploadReturnId(String engine, MultipartFile file) {
+        return this.storageFile(engine, file, true);
+    }
+
+    @Override
+    public String uploadReturnUrl(String engine, MultipartFile file) {
+        return this.storageFile(engine, file, false);
+    }
+
+    @Override
+    public Page<DevFile> page(DevFilePageParam devFilePageParam) {
+        QueryWrapper<DevFile> queryWrapper = new QueryWrapper<>();
+        if(ObjectUtil.isNotEmpty(devFilePageParam.getEngine())) {
+            queryWrapper.lambda().eq(DevFile::getEngine, devFilePageParam.getEngine());
+        }
+        if(ObjectUtil.isNotEmpty(devFilePageParam.getSearchKey())) {
+            queryWrapper.lambda().like(DevFile::getName, devFilePageParam.getSearchKey());
+        }
+        return null;
+    }
+
+    @Override
+    public List<DevFile> list(DevFileListParam devFileListParam) {
+        QueryWrapper<DevFile> queryWrapper = new QueryWrapper<>();
+        if(ObjectUtil.isNotEmpty(devFileListParam.getEngine())) {
+            queryWrapper.lambda().eq(DevFile::getEngine, devFileListParam.getEngine());
+        }
+        if(ObjectUtil.isNotEmpty(devFileListParam.getSearchKey())) {
+            queryWrapper.lambda().like(DevFile::getName, devFileListParam.getSearchKey());
+        }
+        return this.list(queryWrapper);
+    }
+
+    @Override
+    public void download(DevFileIdParam devFileIdParam, HttpServletResponse response) throws IOException {
+        DevFile devFile;
+        try {
+            devFile = this.queryEntity(devFileIdParam.getId());
+        } catch (Exception e) {
+            CommonResponseUtil.renderError(response, e.getMessage());
+            return;
+        }
+        if(!devFile.getEngine().equals(DevFileEngineTypeEnum.LOCAL.getValue())) {
+            CommonResponseUtil.renderError(response, "非本地文件不支持此方式下载，id值为：" + devFile.getId());
+            return;
+        }
+        File file = FileUtil.file(devFile.getStoragePath());
+        if(!FileUtil.exist(file)) {
+            CommonResponseUtil.renderError(response, "找不到存储的文件，id值为：" + devFile.getId());
+            return;
+        }
+        CommonDownloadUtil.download(devFile.getName(), IoUtil.readBytes(FileUtil.getInputStream(file)), response);
+    }
+
+    @Override
+    public void delete(List<DevFileIdParam> devFileIdParamList) {
+        this.removeByIds(CollStreamUtil.toList(devFileIdParamList, DevFileIdParam::getId));
+    }
+
+    /**
+     * 存储文件
+     *
+     * @author xuyuxiang
+     * @date 2022/6/16 16:24
+     **/
+    private String storageFile(String engine, MultipartFile file, boolean returnFileId) {
+
+        // 如果引擎为空，默认使用本地
+        if(ObjectUtil.isEmpty(engine)) {
+            engine = DevFileEngineTypeEnum.LOCAL.getValue();
+        }
+
+        // 生成id
+        String fileId = IdWorker.getIdStr();
+
+        // 存储桶名称
+        String bucketName="";
+
+        // 定义存储的url，本地文件返回文件实际路径，其他引擎返回网络地址
+        String storageUrl ="";
+
+        // 根据引擎类型执行不同方法
+        if(engine.equals(DevFileEngineTypeEnum.LOCAL.getValue())) {
+
+            // 使用固定名称defaultBucketName
+        } else if(engine.equals(DevFileEngineTypeEnum.ALIYUN.getValue())) {
+
+            // 使用阿里云默认配置的bucketName
+        } else if(engine.equals(DevFileEngineTypeEnum.TENCENT.getValue())) {
+
+            // 使用腾讯云默认配置的bucketName
+        } else if(engine.equals(DevFileEngineTypeEnum.MINIO.getValue())) {
+
+            // 使用MINIO默认配置的bucketName
+            bucketName = DevFileMinIoUtil.getDefaultBucketName();
+            storageUrl = DevFileMinIoUtil.storageFileWithReturnUrl(bucketName, genFileKey(fileId, file), file);
+        } else {
+            throw new RuntimeException("不支持的文件引擎："+ engine);
+        }
+
+        // 将文件信息保存到数据库
+        DevFile devFile = new DevFile();
+
+        // 设置文件id
+        devFile.setId(fileId);
+
+        // 设置存储引擎类型
+        devFile.setEngine(engine);
+        devFile.setBucket(bucketName);
+        devFile.setName(file.getOriginalFilename());
+        String suffix = ObjectUtil.isNotEmpty(file.getOriginalFilename())?StrUtil.subAfter(file.getOriginalFilename(),
+                StrUtil.DOT, true):null;
+        devFile.setSuffix(suffix);
+        devFile.setSizeKb(Convert.toStr(NumberUtil.div(new BigDecimal(file.getSize()), BigDecimal.valueOf(1024))
+                .setScale(0, BigDecimal.ROUND_HALF_UP)));
+        devFile.setSizeInfo(FileUtil.readableFileSize(file.getSize()));
+        devFile.setObjName(ObjectUtil.isNotEmpty(devFile.getSuffix())?fileId + StrUtil.DOT + devFile.getSuffix():null);
+        // 如果是图片，则压缩生成缩略图
+        if(ObjectUtil.isNotEmpty(suffix)) {
+            if(isPic(suffix)) {
+                try {
+                    devFile.setThumbnail(ImgUtil.toBase64DataUri(ImgUtil.scale(ImgUtil.toImage(file.getBytes()),
+                            100, 100, null), suffix));
+                } catch (Exception ignored) {
+                }
+            }
+        }
+        // 存储路径
+        devFile.setStoragePath(storageUrl);
+
+        // 定义下载地址
+        String downloadUrl;
+
+        // 下载路径，注意：本地文件下载地址设置为下载接口地址 + 文件id
+        if(engine.equals(DevFileEngineTypeEnum.LOCAL.getValue())) {
+            String apiUrl = commonProperties.getBackendUrl();
+            if(ObjectUtil.isEmpty(apiUrl)) {
+                throw new RuntimeException("后端域名地址未正确配置：snowy.config.common.backend-url为空");
+            }
+            downloadUrl= apiUrl + "/dev/file/download?id=" + fileId;
+            devFile.setDownloadPath(downloadUrl);
+        } else {
+            // 阿里云、腾讯云、MINIO可以直接使用存储地址（公网）作为下载地址
+            downloadUrl= storageUrl;
+            devFile.setDownloadPath(devFile.getStoragePath());
+        }
+
+        this.save(devFile);
+
+        // 如果是返回id则返回文件id
+        if(returnFileId) {
+            return fileId;
+        } else {
+            // 否则返回下载地址
+            return downloadUrl;
+        }
+    }
+
+    /**
+     * 生成文件的key，格式如 2021/10/11/1377109572375810050.docx
+     *
+     * @author xuyuxiang
+     * @date 2022/4/22 15:58
+     **/
+    public String genFileKey(String fileId, MultipartFile file) {
+
+        // 获取文件原始名称
+        String originalFileName = file.getOriginalFilename();
+
+        // 获取文件后缀
+        String fileSuffix = FileUtil.getSuffix(originalFileName);
+
+        // 生成文件的对象名称，格式如:1377109572375810050.docx
+        String fileObjectName = fileId + StrUtil.DOT + fileSuffix;
+
+        // 获取日期文件夹，格式如，2021/10/11/
+        String dateFolderPath = DateUtil.thisYear() + StrUtil.SLASH +
+                (DateUtil.thisMonth() + 1) + StrUtil.SLASH +
+                DateUtil.thisDayOfMonth() + StrUtil.SLASH;
+
+        // 返回
+        return dateFolderPath + fileObjectName;
+    }
+
+    @Override
+    public DevFile detail(DevFileIdParam devFileIdParam) {
+        return this.queryEntity(devFileIdParam.getId());
+    }
+
+    @Override
+    public DevFile queryEntity(String id) {
+        DevFile devFile = this.getById(id);
+        if(ObjectUtil.isEmpty(devFile)) {
+            throw new RuntimeException("文件不存在，id值为："+id);
+        }
+        return devFile;
+    }
+
+    /**
+     * 根据文件后缀判断是否图片
+     *
+     * @author xuyuxiang
+     * @date 2020/7/6 15:31
+     */
+    private static boolean isPic(String fileSuffix) {
+        fileSuffix = fileSuffix.toLowerCase();
+        return ImgUtil.IMAGE_TYPE_GIF.equals(fileSuffix)
+                || ImgUtil.IMAGE_TYPE_JPG.equals(fileSuffix)
+                || ImgUtil.IMAGE_TYPE_JPEG.equals(fileSuffix)
+                || ImgUtil.IMAGE_TYPE_BMP.equals(fileSuffix)
+                || ImgUtil.IMAGE_TYPE_PNG.equals(fileSuffix)
+                || ImgUtil.IMAGE_TYPE_PSD.equals(fileSuffix);
+    }
+}

src/main/java/com/unis/crk/file/util/CommonDownloadUtil.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.util;
+
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.util.URLUtil;
+import lombok.extern.slf4j.Slf4j;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.File;
+import java.io.IOException;
+
+/**
+ * 文件下载工具类，使用本类前，对参数校验的异常使用CommonResponseUtil.renderError()方法进行渲染
+ *
+ * @author xuyuxiang
+ * @date 2020/8/5 21:45
+ */
+@Slf4j
+public class CommonDownloadUtil {
+
+    /**
+     * 下载文件
+     *
+     * @param file     要下载的文件
+     * @param response 响应
+     * @author xuyuxiang
+     * @date 2020/8/5 21:46
+     */
+    public static void download(File file, HttpServletResponse response) {
+        download(file.getName(), FileUtil.readBytes(file), response);
+    }
+
+    /**
+     * 下载文件
+     *
+     * @author xuyuxiang
+     * @date 2022/7/31 10:57
+     */
+    public static void download(String fileName, byte[] fileBytes, HttpServletResponse response) {
+        try {
+            response.setHeader("Content-Disposition", "attachment;filename=" + URLUtil.encode(fileName));
+            response.addHeader("Content-Length", "" + fileBytes.length);
+            response.setHeader("Access-Control-Allow-Origin", "*");
+            response.setHeader("Access-Control-Expose-Headers", "Content-Disposition");
+            response.setContentType("application/octet-stream;charset=UTF-8");
+            IoUtil.write(response.getOutputStream(), true, fileBytes);
+        } catch (IOException e) {
+            log.error(">>> 文件下载异常：", e);
+        }
+    }
+}

src/main/java/com/unis/crk/file/util/CommonException.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.util;
+
+import cn.hutool.core.util.StrUtil;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 通用异常
+ *
+ * @author xuyuxiang
+ * @date 2020/4/8 15:54
+ */
+@Getter
+@Setter
+public class CommonException extends RuntimeException {
+
+    private Integer code;
+
+    private String msg;
+
+    public CommonException() {
+        super("服务器异常");
+        this.code = 500;
+        this.msg = "服务器异常";
+    }
+
+    public CommonException(String msg, Object... arguments) {
+        super(StrUtil.format(msg, arguments));
+        this.code = 500;
+        this.msg = StrUtil.format(msg, arguments);
+    }
+
+    public CommonException(Integer code, String msg, Object... arguments) {
+        super(StrUtil.format(msg, arguments));
+        this.code = code;
+        this.msg = StrUtil.format(msg, arguments);
+    }
+}

src/main/java/com/unis/crk/file/util/CommonExceptionEnum.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.util;
+
+import lombok.Getter;
+
+/**
+ * 异常码枚举
+ *
+ * @author xuyuxiang
+ * @date 2022/8/15 16:09
+ **/
+@Getter
+public enum CommonExceptionEnum {
+
+    OK200(200, "请求成功"),
+    ERROR401(401, "未登录"),
+    ERROR403(403, "无权限"),
+    ERROR404(404, "路径不存在"),
+    ERROR405(405, "请求方法不正确"),
+    ERROR415(415, "参数传递异常"),
+    ERROR500(500, "业务异常");
+
+    private final Integer code;
+
+    private final String message;
+
+    CommonExceptionEnum(Integer code, String message) {
+        this.code = code;
+        this.message = message;
+    }
+}

src/main/java/com/unis/crk/file/util/CommonProperties.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.util;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * 通用基础配置
+ *
+ * @author xuyuxiang
+ * @date 2022/1/2 17:03
+ */
+@Getter
+@Setter
+@Component
+@ConfigurationProperties(prefix = "snowy.config.common")
+public class CommonProperties {
+
+    /** 前端地址 */
+    private String frontUrl;
+
+    /** 后端地址 */
+    private String backendUrl;
+}

src/main/java/com/unis/crk/file/util/CommonResponseUtil.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.util;
+
+import cn.hutool.core.util.CharsetUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.http.ContentType;
+import cn.hutool.json.JSONUtil;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+/**
+ * 通用响应工具类
+ *
+ * @author xuyuxiang
+ * @date 2022/8/4 9:40
+ **/
+public class CommonResponseUtil {
+
+    /**
+     * 以流的方式响应错误信息，默认错误消息
+     *
+     * @author xuyuxiang
+     * @date 2022/8/4 9:41
+     **/
+    public static void renderError(HttpServletResponse response) throws IOException {
+        renderError(response, null);
+    }
+
+    /**
+     * 以流的方式响应错误信息，指定错误消息
+     *
+     * @author xuyuxiang
+     * @date 2022/8/4 9:41
+     **/
+    public static void renderError(HttpServletResponse response, String msg) throws IOException {
+        response.setCharacterEncoding(CharsetUtil.UTF_8);
+        response.setContentType(ContentType.JSON.toString());
+        response.getWriter().write(JSONUtil.toJsonStr(ObjectUtil.isNotEmpty(msg)?CommonResult.error(msg):CommonResult.error()));
+    }
+
+    /**
+     * 以流的方式响应错误信息，指定错误码和错误消息
+     *
+     * @author xuyuxiang
+     * @date 2022/8/4 9:41
+     **/
+    public static void renderError(HttpServletResponse response, Integer code, String msg) throws IOException {
+        response.setCharacterEncoding(CharsetUtil.UTF_8);
+        response.setContentType(ContentType.JSON.toString());
+        response.getWriter().write(JSONUtil.toJsonStr(CommonResult.get(code, msg, null)));
+    }
+}

src/main/java/com/unis/crk/file/util/CommonResult.java

@@ -0,0 +1,165 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.util;
+
+import io.swagger.annotations.ApiModelProperty;
+import springfox.documentation.builders.ResponseMessageBuilder;
+import springfox.documentation.service.ResponseMessage;
+
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * 对Ajax请求返回Json格式数据的简易封装
+ *
+ * @author xuyuxiang
+ * @date 2022/8/15 16:08
+ **/
+public class CommonResult<T> implements Serializable {
+    private static final long serialVersionUID = 1L;
+    public static final int CODE_SUCCESS = 200;
+    public static final int CODE_ERROR = 500;
+
+    @ApiModelProperty(value = "状态码")
+    private int code;
+
+    @ApiModelProperty(value = "提示语")
+    private String msg;
+
+    @ApiModelProperty(value = "返回数据")
+    private T data;
+
+    public CommonResult() {
+    }
+
+    public CommonResult(int code, String msg, T data) {
+        this.setCode(code);
+        this.setMsg(msg);
+        this.setData(data);
+    }
+
+    /**
+     * 获取code
+     * @return code
+     */
+    public Integer getCode() {
+        return this.code;
+    }
+
+    /**
+     * 获取msg
+     * @return msg
+     */
+    public String getMsg() {
+        return this.msg;
+    }
+    /**
+     * 获取data
+     * @return data
+     */
+    public T getData() {
+        return this.data;
+    }
+
+    /**
+     * 给code赋值，连缀风格
+     * @param code code
+     * @return 对象自身
+     */
+    public CommonResult<T> setCode(int code) {
+        this.code = code;
+        return this;
+    }
+
+    /**
+     * 给msg赋值，连缀风格
+     * @param msg msg
+     * @return 对象自身
+     */
+    public CommonResult<T> setMsg(String msg) {
+        this.msg = msg;
+        return this;
+    }
+
+    /**
+     * 给data赋值，连缀风格
+     * @param data data
+     * @return 对象自身
+     */
+    public CommonResult<T> setData(T data) {
+        this.data = data;
+        return this;
+    }
+
+
+    // ============================  构建  ==================================
+
+    // 构建成功
+    public static <T> CommonResult<T> ok() {
+        return new CommonResult<>(CODE_SUCCESS, "操作成功", null);
+    }
+    public static <T> CommonResult<T> ok(String msg) {
+        return new CommonResult<>(CODE_SUCCESS, msg, null);
+    }
+    public static <T> CommonResult<T> code(int code) {
+        return new CommonResult<>(code, null, null);
+    }
+    public static <T> CommonResult<T> data(T data) {
+        return new CommonResult<>(CODE_SUCCESS, "操作成功", data);
+    }
+
+    // 构建失败
+    public static <T> CommonResult<T> error() {
+        return new CommonResult<>(CODE_ERROR, "服务器异常", null);
+    }
+
+    public static <T> CommonResult<T> error(Integer code, String msg) {
+        return new CommonResult<>(code, msg, null);
+    }
+
+
+    public static <T> CommonResult<T> error(String msg) {
+        return new CommonResult<>(CODE_ERROR, msg, null);
+    }
+
+    // 构建指定状态码
+    public static <T> CommonResult<T> get(int code, String msg, T data) {
+        return new CommonResult<>(code, msg, data);
+    }
+
+    /*
+     * toString()
+     */
+    @Override
+    public String toString() {
+        return "{"
+                + "\"code\": " + this.getCode()
+                + ", \"msg\": \"" + this.getMsg() + "\""
+                + ", \"data\": \"" + this.getData() + "\""
+                + "}";
+    }
+
+    /**
+     * 响应状态码集合
+     *
+     * @author xuyuxiang
+     * @date 2022/7/25 13:36
+     **/
+    public static List<ResponseMessage> responseList() {
+        return Arrays.stream(CommonExceptionEnum.values()).map(commonExceptionEnum -> new ResponseMessageBuilder()
+                .code(commonExceptionEnum.getCode()).message(commonExceptionEnum.getMessage()).build())
+                .collect(Collectors.toList());
+    }
+}

src/main/java/com/unis/crk/file/util/CommonServletUtil.java

@@ -0,0 +1,86 @@
+package com.unis.crk.file.util;
+
+import cn.hutool.core.util.ObjectUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+import javax.servlet.http.Cookie;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * HttpServlet工具类，获取当前request和response
+ *
+ * @author xuyuxiang
+ * @date 2020/3/30 15:09
+ */
+@Slf4j
+public class CommonServletUtil {
+
+    /**
+     * 从请求中中获取参数
+     *
+     * @author xuyuxiang
+     * @date 2021/10/14 10:44
+     **/
+    public static String getParamFromRequest(String paramName) {
+        HttpServletRequest request = getRequest();
+
+        // 1. 尝试从请求体里面读取
+        String paramValue = request.getParameter(paramName);
+
+        // 2. 尝试从header里读取
+        if (ObjectUtil.isEmpty(paramValue)) {
+            paramValue = request.getHeader(paramName);
+        }
+        // 3. 尝试从cookie里读取
+        if (ObjectUtil.isEmpty(paramValue)) {
+            Cookie[] cookies = request.getCookies();
+            if(ObjectUtil.isNotEmpty(cookies)) {
+                for (Cookie cookie : cookies) {
+                    String cookieName = cookie.getName();
+                    if (cookieName.equals(paramName)) {
+                        return cookie.getValue();
+                    }
+                }
+            }
+        }
+        // 4. 返回
+        return paramValue;
+    }
+
+    public static HttpServletRequest getRequest() {
+        ServletRequestAttributes servletRequestAttributes;
+        try {
+            servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
+        } catch (Exception e) {
+            log.error(">>> 非Web上下文无法获取Request：", e);
+            throw new CommonException("非Web上下文无法获取Request");
+        }
+        if (servletRequestAttributes == null) {
+            throw new CommonException("非Web上下文无法获取Request");
+        } else {
+            return servletRequestAttributes.getRequest();
+        }
+    }
+
+    public static HttpServletResponse getResponse() {
+        ServletRequestAttributes servletRequestAttributes;
+        try {
+            servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
+        } catch (Exception e) {
+            log.error(">>> 非Web上下文无法获取Response：", e);
+            throw new CommonException("非Web上下文无法获取Response");
+        }
+        if (servletRequestAttributes == null) {
+            throw new CommonException("非Web上下文无法获取Response");
+        } else {
+            return servletRequestAttributes.getResponse();
+        }
+    }
+
+    public static boolean isWeb() {
+        return RequestContextHolder.getRequestAttributes() != null;
+    }
+}

src/main/java/com/unis/crk/file/util/DevConfigApi.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.util;
+
+/**
+ * 配置APi接口
+ *
+ * @author xuyuxiang
+ * @date 2022/6/17 10:37
+ **/
+public interface DevConfigApi {
+
+    /**
+     * 根据键获取值
+     *
+     * @author xuyuxiang
+     * @date 2022/6/17 11:11
+     **/
+    String getValueByKey(String key);
+}

src/main/java/com/unis/crk/file/util/DevFileApi.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright [2022] [https://www.xiaonuo.vip]
+ *
+ * Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
+ *
+ * 1.请不要删除和修改根目录下的LICENSE文件。
+ * 2.请不要删除和修改Snowy源码头部的版权声明。
+ * 3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
+ * 4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
+ * 5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
+ * 6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
+ */
+package com.unis.crk.file.util;
+
+import org.springframework.web.multipart.MultipartFile;
+
+/**
+ * 文件API接口，可参考com.unis.dev.core.util.file包下的工具类扩展更多需要的方法
+ *
+ * @author xuyuxiang
+ * @date 2022/6/22 15:21
+ **/
+public interface DevFileApi {
+
+    /* =========本地文件========= */
+
+    /**
+     * 上传文件返回Url
+     *
+     * @param file 文件
+     * @author xuyuxiang
+     * @date 2022/6/22 17:44
+     **/
+    String storageFileWithReturnUrlLocal(MultipartFile file);
+
+    /**
+     * 上传文件返回Id
+     *
+     * @param file 文件
+     * @author xuyuxiang
+     * @date 2022/6/22 17:44
+     **/
+    String storageFileWithReturnIdLocal(MultipartFile file);
+
+    /* =========阿里云文件========= */
+
+    /**
+     * 上传文件返回Url
+     *
+     * @param file 文件
+     * @author xuyuxiang
+     * @date 2022/6/22 17:44
+     **/
+    String storageFileWithReturnUrlAliyun(MultipartFile file);
+
+    /**
+     * 上传文件返回Id
+     *
+     * @param file 文件
+     * @author xuyuxiang
+     * @date 2022/6/22 17:44
+     **/
+    String storageFileWithReturnIdAliyun(MultipartFile file);
+
+    /* =========腾讯云件========= */
+
+    /**
+     * 上传文件返回Url
+     *
+     * @param file 文件
+     * @author xuyuxiang
+     * @date 2022/6/22 17:44
+     **/
+    String storageFileWithReturnUrlTencent(MultipartFile file);
+
+    /**
+     * 上传文件返回Id
+     *
+     * @param file 文件
+     * @author xuyuxiang
+     * @date 2022/6/22 17:44
+     **/
+    String storageFileWithReturnIdTencent(MultipartFile file);
+
+    /* =========MINIO件========= */
+
+    /**
+     * 上传文件返回Url
+     *
+     * @param file 文件
+     * @author xuyuxiang
+     * @date 2022/6/22 17:44
+     **/
+    String storageFileWithReturnUrlMinio(MultipartFile file);
+
+    /**
+     * 上传文件返回Id
+     *
+     * @param file 文件
+     * @author xuyuxiang
+     * @date 2022/6/22 17:44
+     **/
+    String storageFileWithReturnIdMinio(MultipartFile file);
+}

src/main/java/com/unis/crk/file/util/DevFileMinIoUtil.java

@@ -0,0 +1,459 @@
+package com.unis.crk.file.util;
+
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.io.IORuntimeException;
+import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.extra.spring.SpringUtil;
+import cn.hutool.json.JSONArray;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import com.unis.crk.file.enums.DevFileBucketAuthEnum;
+import io.minio.*;
+import io.minio.http.Method;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.activation.MimetypesFileTypeMap;
+import java.io.*;
+
+/**
+ * MINIO文件工具类
+ * 参考文档：http://docs.minio.org.cn/docs/master/java-client-quickstart-guide
+ *
+ * @author xuyuxiang
+ * @date 2022/1/2 18:13
+ */
+@Slf4j
+public class DevFileMinIoUtil {
+
+    private static MinioClient client;
+
+    private static String defaultBucketName;
+
+    private static final String SNOWY_FILE_MINIO_ACCESS_KEY_KEY = "CRK_FILE_MINIO_ACCESS_KEY";
+    private static final String SNOWY_FILE_MINIO_SECRET_KEY_KEY = "CRK_FILE_MINIO_SECRET_KEY";
+    private static final String SNOWY_FILE_MINIO_END_POINT_KEY = "CRK_FILE_MINIO_END_POINT";
+    /**
+     * 文件访问前缀
+     *
+     * @author: ybw
+     * @date: 2024/5/31
+     **/
+    private static final String SNOWY_FILE_MINIO_ACCESS_PREFIX = "CRK_FILE_MINIO_ACCESS_PREFIX";
+    private static final String SNOWY_FILE_MINIO_DEFAULT_BUCKET_NAME = "CRK_FILE_MINIO_DEFAULT_BUCKET_NAME";
+
+
+    /**
+     * 初始化操作的客户端
+     *
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    private static void initClient() {
+
+        DevConfigApi devConfigApi = SpringUtil.getBean(DevConfigApi.class);
+
+        /* accessKey */
+        String accessKey = devConfigApi.getValueByKey(SNOWY_FILE_MINIO_ACCESS_KEY_KEY);
+
+        if(ObjectUtil.isEmpty(accessKey)) {
+            throw new RuntimeException("MINIO文件操作客户端未正确配置：accessKey为空");
+        }
+
+        /* secretKey */
+        String secretKey = devConfigApi.getValueByKey(SNOWY_FILE_MINIO_SECRET_KEY_KEY);
+
+        if(ObjectUtil.isEmpty(secretKey)) {
+            throw new RuntimeException("MINIO文件操作客户端未正确配置：secretKey为空");
+        }
+
+        /* endpoint */
+        String endpoint = devConfigApi.getValueByKey(SNOWY_FILE_MINIO_END_POINT_KEY);
+
+        if(ObjectUtil.isEmpty(endpoint)) {
+            throw new RuntimeException("MINIO文件操作客户端未正确配置：endpoint为空");
+        }
+
+        /* 默认BucketName */
+        defaultBucketName = devConfigApi.getValueByKey(SNOWY_FILE_MINIO_DEFAULT_BUCKET_NAME);
+
+        if(ObjectUtil.isEmpty(defaultBucketName)) {
+            throw new RuntimeException("MINIO文件操作客户端未正确配置：defaultBucketName为空");
+        }
+
+        client = MinioClient.builder().endpoint(endpoint).credentials(accessKey, secretKey).build();
+    }
+
+    /**
+     * 获取默认存储桶名称
+     *
+     * @author xuyuxiang
+     * @date 2022/6/22 18:05
+     **/
+    public static String getDefaultBucketName() {
+        initClient();
+        return defaultBucketName;
+    }
+
+    /**
+     * 销毁操作的客户端
+     *
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static void destroyClient() {
+        // 无需
+    }
+
+    /**
+     * 获取操作的客户端
+     *
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static MinioClient getClient() {
+        return client;
+    }
+
+    /**
+     * 查询存储桶是否存在
+     * 例如：传入参数examplebucket-1250000000，返回true代表存在此桶
+     *
+     * @param bucketName 桶名称
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static boolean doesBucketExist(String bucketName) {
+        try {
+            initClient();
+            BucketExistsArgs bucketExistsArgs = BucketExistsArgs.builder().bucket(bucketName).build();
+            client.bucketExists(bucketExistsArgs);
+        } catch (Exception e) {
+            throw new RuntimeException(e.getMessage());
+        }
+        return false;
+    }
+
+    /**
+     * 设置预定义策略
+     * 预定义策略如公有读、公有读写、私有读
+     *
+     * @param bucketName 桶名称
+     * @param devFileBucketAuthEnum 存储桶权限
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static void setBucketAcl(String bucketName, DevFileBucketAuthEnum devFileBucketAuthEnum) {
+        setFileAcl(bucketName, "*", devFileBucketAuthEnum);
+    }
+
+    /**
+     * 判断是否存在文件
+     *
+     * @param bucketName 桶名称
+     * @param key        唯一标示id，例如a.txt, doc/a.txt
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static boolean isExistingFile(String bucketName, String key) {
+        try {
+            initClient();
+            GetObjectArgs getObjectArgs = GetObjectArgs.builder().bucket(bucketName).object(key).build();
+            InputStream object = client.getObject(getObjectArgs);
+            return !ObjectUtil.isEmpty(object);
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    /**
+     * 存储文件，不返回地址
+     *
+     * @param bucketName 桶名称
+     * @param key        唯一标示id，例如a.txt, doc/a.txt
+     * @param file      文件
+     * @author xuyuxiang
+     * @date 2022/1/5 23:45
+     */
+    public static void storageFile(String bucketName, String key, File file) {
+        BufferedInputStream inputStream;
+        try {
+            inputStream = FileUtil.getInputStream(file);
+        } catch (IORuntimeException e) {
+            throw new RuntimeException("获取文件流异常，名称是："+file.getName());
+        }
+        storageFile(bucketName, key, inputStream);
+    }
+
+    /**
+     * 存储文件，不返回地址
+     *
+     * @param bucketName 桶名称
+     * @param key        唯一标示id，例如a.txt, doc/a.txt
+     * @param multipartFile      文件
+     * @author xuyuxiang
+     * @date 2022/1/5 23:45
+     */
+    public static void storageFile(String bucketName, String key, MultipartFile multipartFile) {
+        InputStream inputStream;
+        try {
+            inputStream = multipartFile.getInputStream();
+        } catch (IOException e) {
+            throw new RuntimeException("获取文件流异常，名称是："+ multipartFile.getName());
+        }
+        storageFile(bucketName, key, inputStream);
+    }
+
+    /**
+     * 存储文件，不返回地址
+     *
+     * @param bucketName 桶名称
+     * @param key        唯一标示id，例如a.txt, doc/a.txt
+     * @param bytes      文件字节数组
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static void storageFile(String bucketName, String key, byte[] bytes) {
+        ByteArrayInputStream byteArrayInputStream = null;
+        try {
+            initClient();
+            byteArrayInputStream = new ByteArrayInputStream(bytes);
+            PutObjectArgs putObjectArgs = PutObjectArgs.builder().bucket(bucketName).object(key)
+                    .contentType(getFileContentType(key)).stream(byteArrayInputStream, bytes.length, -1).build();
+            client.putObject(putObjectArgs);
+        } catch (Exception e) {
+            throw new RuntimeException(e.getMessage());
+        } finally {
+            IoUtil.close(byteArrayInputStream);
+        }
+    }
+
+    /**
+     * 存储文件，不返回地址
+     *
+     * @param bucketName  桶名称
+     * @param key         唯一标示id，例如a.txt, doc/a.txt
+     * @param inputStream 文件流
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static void storageFile(String bucketName, String key, InputStream inputStream) {
+        try {
+            initClient();
+            PutObjectArgs putObjectArgs = PutObjectArgs.builder().bucket(bucketName).object(key)
+                    .contentType(getFileContentType(key)).stream(inputStream, inputStream.available(), -1).build();
+            client.putObject(putObjectArgs);
+        } catch (Exception e) {
+            throw new RuntimeException(e.getMessage());
+        } finally {
+            IoUtil.close(inputStream);
+        }
+    }
+
+    /**
+     * 存储文件，返回外网地址
+     *
+     * @param bucketName 桶名称
+     * @param key        唯一标示id，例如a.txt, doc/a.txt
+     * @param file      文件
+     * @author xuyuxiang
+     * @date 2022/1/5 23:45
+     */
+    public static String storageFileWithReturnUrl(String bucketName, String key, File file) {
+        storageFile(bucketName, key, file);
+        setFileAcl(bucketName, key, DevFileBucketAuthEnum.PUBLIC_READ);
+        return getFileAuthUrl(bucketName, key);
+    }
+
+    /**
+     * 存储文件，返回外网地址
+     *
+     * @param bucketName 桶名称
+     * @param key        唯一标示id，例如a.txt, doc/a.txt
+     * @param multipartFile      文件
+     * @author xuyuxiang
+     * @date 2022/1/5 23:45
+     */
+    public static String storageFileWithReturnUrl(String bucketName, String key, MultipartFile multipartFile) {
+        storageFile(bucketName, key, multipartFile);
+        setFileAcl(bucketName, key, DevFileBucketAuthEnum.PUBLIC_READ);
+        return getFileAuthUrl(bucketName, key);
+    }
+
+    /**
+     * 存储文件，返回外网地址
+     *
+     * @param bucketName 桶名称
+     * @param key        唯一标示id，例如a.txt, doc/a.txt
+     * @param bytes      文件字节数组
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static String storageFileWithReturnUrl(String bucketName, String key, byte[] bytes) {
+        storageFile(bucketName, key, bytes);
+        setFileAcl(bucketName, key, DevFileBucketAuthEnum.PUBLIC_READ);
+        return getFileAuthUrl(bucketName, key);
+    }
+
+    /**
+     * 存储文件，返回外网地址
+     *
+     * @param bucketName  桶名称
+     * @param key         唯一标示id，例如a.txt, doc/a.txt
+     * @param inputStream 文件流
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static String storageFileWithReturnUrl(String bucketName, String key, InputStream inputStream) {
+        storageFile(bucketName, key, inputStream);
+        setFileAcl(bucketName, key, DevFileBucketAuthEnum.PUBLIC_READ);
+        return getFileAuthUrl(bucketName, key);
+    }
+
+    /**
+     * 获取某个bucket下的文件字节
+     *
+     * @param bucketName 桶名称
+     * @param key        唯一标示id，例如a.txt, doc/a.txt
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static byte[] getFileBytes(String bucketName, String key) {
+        try {
+            initClient();
+            GetObjectArgs getObjectArgs = GetObjectArgs.builder().bucket(bucketName).object(key).build();
+            InputStream inputStream = client.getObject(getObjectArgs);
+            return IoUtil.readBytes(inputStream);
+        } catch (Exception e) {
+            throw new RuntimeException(e.getMessage());
+        }
+    }
+
+    /**
+     * 设置文件访问权限管理
+     *
+     * @param bucketName     桶名称
+     * @param key             唯一标示id，例如a.txt, doc/a.txt
+     * @param devFileBucketAuthEnum 文件权限
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static void setFileAcl(String bucketName, String key, DevFileBucketAuthEnum devFileBucketAuthEnum) {
+        try {
+            JSONObject configObject = JSONUtil.createObj().set("Version", "2012-10-17");
+            JSONArray statementArray = JSONUtil.createArray();
+            JSONArray actionArray = JSONUtil.createArray();
+            if(devFileBucketAuthEnum.equals(DevFileBucketAuthEnum.PUBLIC_READ)) {
+                actionArray.put("s3:GetObject");
+            }
+            if(devFileBucketAuthEnum.equals(DevFileBucketAuthEnum.PUBLIC_READ_WRITE)) {
+                actionArray.put("s3:GetObject");
+                actionArray.put("s3:PutObject");
+            }
+            JSONObject statementObject = JSONUtil.createObj();
+            statementObject.set("Effect", "Allow").set("Principal", JSONUtil.createObj().set("AWS", JSONUtil.createArray().put("*")))
+                    .set("Action", actionArray).set("Resource", JSONUtil.createArray().put("arn:aws:s3:::" + bucketName + "/*"));
+            statementArray.put(statementObject);
+            configObject.set("Statement", statementArray);
+            String config = JSONUtil.toJsonStr(configObject);
+            SetBucketPolicyArgs setBucketPolicyArgs = SetBucketPolicyArgs.builder().bucket(bucketName).config(config).build();
+            client.setBucketPolicy(setBucketPolicyArgs);
+        } catch (Exception e) {
+            throw new RuntimeException(e.getMessage());
+        }
+    }
+
+    /**
+     * 拷贝文件
+     *
+     * @param originBucketName 源文件桶
+     * @param originFileKey    源文件名称
+     * @param newBucketName    新文件桶
+     * @param newFileKey       新文件名称
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static void copyFile(String originBucketName, String originFileKey, String newBucketName, String newFileKey) {
+        try {
+            initClient();
+            CopySource copySource = CopySource.builder().bucket(originBucketName).object(originFileKey).build();
+            CopyObjectArgs copyObjectArgs = CopyObjectArgs.builder().source(copySource).bucket(newBucketName).object(newFileKey).build();
+            client.copyObject(copyObjectArgs);
+        } catch (Exception e) {
+            throw new RuntimeException(e.getMessage());
+        }
+    }
+
+    /**
+     * 获取文件的下载地址（带鉴权和有效时间的），生成外网地址
+     *
+     * @param bucketName 文件桶
+     * @param key        唯一标示id，例如a.txt, doc/a.txt
+     * @param timeoutMillis 时效
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static String getFileAuthUrl(String bucketName, String key, Long timeoutMillis) {
+        try {
+            initClient();
+            GetPresignedObjectUrlArgs getPresignedObjectUrlArgs = GetPresignedObjectUrlArgs.builder().bucket(bucketName)
+                    .object(key).method(Method.GET).expiry(timeoutMillis.intValue()).build();
+            return client.getPresignedObjectUrl(getPresignedObjectUrlArgs);
+        } catch (Exception e) {
+            throw new RuntimeException(e.getMessage());
+        }
+    }
+
+    /**
+     * 获取文件的下载地址（永久的，文件必须为公有读），生成外网地址
+     *
+     * @param bucketName 文件桶
+     * @param key        唯一标示id，例如a.txt, doc/a.txt
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static String getFileAuthUrl(String bucketName, String key) {
+        try {
+            initClient();
+            DevConfigApi devConfigApi = SpringUtil.getBean(DevConfigApi.class);
+            return devConfigApi.getValueByKey(SNOWY_FILE_MINIO_ACCESS_PREFIX) + StrUtil.SLASH + bucketName + StrUtil.SLASH + key;
+        } catch (Exception e) {
+            throw new RuntimeException(e.getMessage());
+        }
+    }
+
+    /**
+     * 删除文件
+     *
+     * @param bucketName 文件桶
+     * @param key        唯一标示id，例如a.txt, doc/a.txt
+     * @author xuyuxiang
+     * @date 2022/1/5 23:24
+     */
+    public static void deleteFile(String bucketName, String key) {
+        try {
+            RemoveObjectArgs removeObjectArgs = RemoveObjectArgs.builder().bucket(bucketName).object(key).build();
+            client.removeObject(removeObjectArgs);
+        } catch (Exception e) {
+            throw new RuntimeException(e.getMessage());
+        }
+    }
+
+    /**
+     * 根据文件名获取ContentType
+     *
+     * @author xuyuxiang
+     * @date 2022/1/6 11:27
+     **/
+    private static String getFileContentType(String key) {
+        // 根据文件名获取contentType
+        String contentType = "application/octet-stream";
+        if (key.contains(".")) {
+            contentType = MimetypesFileTypeMap.getDefaultFileTypeMap().getContentType(key);
+        }
+        return contentType;
+    }
+
+}