SpringBoot使用策略模式实现文件存储【MinIO、阿里云OSS】

最新推荐文章于 2024-07-20 22:54:53 发布
最新推荐文章于 2024-07-20 22:54:53 发布
阅读量469 收藏 4
点赞数 19
分类专栏： Spring系列 文章标签： spring boot 策略模式 阿里云
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39311781/article/details/138824753
版权

引入依赖

<!-- minio -->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.5.2</version>
</dependency>

<!-- Aliyun OSS SDK -->
<dependency>
    <groupId>com.aliyun.oss</groupId>
    <artifactId>aliyun-sdk-oss</artifactId>
    <version>3.17.1</version>
</dependency>

配置

oss:
  type: MINIO
  endpoint: http://192.168.249.132:9001
  accessKey: xxx
  secretKey: xxx
  bucket: test
  prefix:
  nginxHost:

配置属性类

package com.qiangesoft.oss.config;

import com.qiangesoft.oss.constant.FileStoreTypeEnum;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 文件配置属性类
 *
 * @author qiangesoft
 * @date 2024-05-13
 */
@Data
@Component
@ConfigurationProperties(prefix = "oss")
public class FileStoreProperties {

    /**
     * 存储类型：local/minio/aliyun
     */
    private FileStoreTypeEnum type = FileStoreTypeEnum.LOCAL;

    /**
     * 服务地址
     */
    private String endpoint;

    /**
     * 认证账户
     */
    private String accessKey;

    /**
     * 认证密码
     */
    private String secretKey;

    /**
     * 默认桶
     */
    private String bucket;

    /**
     * 路径前缀【type为local时生效】
     */
    private String prefix;

    /**
     * nginx代理
     */
    private String nginxHost;

}

策略工厂

package com.qiangesoft.oss.config;

import com.qiangesoft.oss.constant.FileStoreTypeEnum;
import com.qiangesoft.oss.strategy.FileStrategy;
import org.springframework.util.ObjectUtils;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 策略工厂
 *
 * @author qiangesoft
 * @date 2024-05-13
 */
public final class StrategyFactory {

    private static final Map<FileStoreTypeEnum, FileStrategy> STRATEGY_MAP = new ConcurrentHashMap<>();

    /**
     * 通过类型获取策略
     *
     * @param type
     * @return
     */
    public static FileStrategy getStrategy(FileStoreTypeEnum type) {
        return STRATEGY_MAP.get(type);
    }

    /**
     * 注册策略
     *
     * @param type
     * @param strategy
     */
    public static void register(FileStoreTypeEnum type, FileStrategy strategy) {
        if (ObjectUtils.isEmpty(type)) {
            return;
        }
        STRATEGY_MAP.put(type, strategy);
    }
}

策略接口

package com.qiangesoft.oss.strategy;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;

/**
 * 文件存储策略
 *
 * @author qiangesoft
 * @date 2023-04-21
 */
public interface FileStrategy extends InitializingBean {

    String POINT = ".";

    String SLASH = "/";

    /**
     * 存在分类
     *
     * @param catalog
     * @return
     * @throws Exception
     */
    boolean existsCatalog(String catalog) throws Exception;

    /**
     * 创建分类
     *
     * @param catalog
     * @throws Exception
     */
    void createCatalog(String catalog) throws Exception;

    /**
     * 获取分类
     *
     * @return
     */
    List<String> listCatalogs() throws Exception;

    /**
     * 删除分类
     *
     * @param catalog
     * @throws Exception
     */
    void removeCatalog(String catalog) throws Exception;

    /**
     * 上传文件
     *
     * @param catalog
     * @param file
     * @return
     * @throws Exception
     */
    String uploadFile(String catalog, MultipartFile file) throws Exception;

    /**
     * 删除文件
     *
     * @param catalog
     * @param fileName
     * @throws Exception
     */
    void removeFile(String catalog, String fileName) throws Exception;

    /**
     * 删除文件
     *
     * @param catalog
     * @param fileNames
     * @throws Exception
     */
    void removeFiles(String catalog, List<String> fileNames) throws Exception;

}

策略实现类

package com.qiangesoft.oss.strategy;

import com.qiangesoft.oss.config.FileStoreProperties;
import com.qiangesoft.oss.config.StrategyFactory;
import com.qiangesoft.oss.constant.FileStoreTypeEnum;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

/**
 * 本地策略实现
 *
 * @author qiangesoft
 * @date 2024-05-13
 */
@Slf4j
@RequiredArgsConstructor
@Service
@Primary
@ConditionalOnProperty(prefix = "oss", name = "type", havingValue = "local")
public class LocalStrategyImpl implements FileStrategy {

    private String prefix;

    public LocalStrategyImpl(FileStoreProperties fileStoreProperties) {
        this.prefix = fileStoreProperties.getPrefix();
    }

    @Override
    public boolean existsCatalog(String catalog) throws Exception {
        File file = new File(prefix + SLASH + catalog);
        return file.exists();
    }

    @Override
    public void createCatalog(String catalog) throws Exception {
        File file = new File(prefix + SLASH + catalog);
        if (!file.exists()) {
            file.mkdirs();
        }
    }

    @Override
    public List<String> listCatalogs() throws Exception {
        File file = new File(prefix);
        File[] files = file.listFiles();
        List<String> list = new ArrayList<>();
        for (File subFile : files) {
            if (subFile.isDirectory()) {
                list.add(subFile.getName());
            }
        }
        return list;
    }

    @Override
    public void removeCatalog(String catalog) throws Exception {
        File file = new File(prefix + SLASH + catalog);
        if (file.exists()) {
            file.delete();
        }
    }

    @Override
    public String uploadFile(String catalog, MultipartFile file) throws Exception {
        return null;
    }

    @Override
    public void removeFile(String catalog, String fileName) throws Exception {

    }

    @Override
    public void removeFiles(String catalog, List<String> fileNames) throws Exception {

    }

    @Override
    public void afterPropertiesSet() throws Exception {
        StrategyFactory.register(FileStoreTypeEnum.LOCAL, this);
    }
}

package com.qiangesoft.oss.strategy;

import com.qiangesoft.oss.config.FileStoreProperties;
import com.qiangesoft.oss.config.StrategyFactory;
import com.qiangesoft.oss.constant.FileStoreTypeEnum;
import io.minio.*;
import io.minio.messages.Bucket;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import org.springframework.web.multipart.MultipartFile;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * minio策略实现
 *
 * @author qiangesoft
 * @date 2024-05-13
 */
@Slf4j
@RequiredArgsConstructor
@Service
@ConditionalOnProperty(prefix = "oss", name = "type", havingValue = "minio")
public class MinioStrategyImpl implements FileStrategy {

    private MinioClient minioClient;

    public MinioStrategyImpl(FileStoreProperties fileStoreProperties) {
        this.minioClient = MinioClient.builder()
                .credentials(fileStoreProperties.getAccessKey(), fileStoreProperties.getSecretKey())
                .endpoint(fileStoreProperties.getEndpoint())
                .build();
    }

    @Override
    public boolean existsCatalog(String catalog) throws Exception {
        BucketExistsArgs args = BucketExistsArgs.builder().bucket(catalog).build();
        return minioClient.bucketExists(args);
    }

    @Override
    public void createCatalog(String catalog) throws Exception {
        if (!this.existsCatalog(catalog)) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(catalog).build());
        }
    }

    @Override
    public List<String> listCatalogs() throws Exception {
        return minioClient.listBuckets().stream().map(Bucket::name).collect(Collectors.toList());
    }

    @Override
    public void removeCatalog(String catalog) throws Exception {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(catalog).build());
    }

    @Override
    public String uploadFile(String catalog, MultipartFile file) throws Exception {
        // 参数校验
        Assert.notNull(catalog, "bucketName is not blank");
        Assert.notNull(file, "file is not null");

        // 判断存储桶是否存在
        createCatalog(catalog);

        // 文件名
        String filename = file.getOriginalFilename();

        // 上传
        minioClient.putObject(PutObjectArgs.builder()
                .bucket(catalog)
                .object(filename)
                .stream(file.getInputStream(), file.getSize(), -1)
                .contentType(file.getContentType())
                .build());
        return catalog + SLASH + filename;
    }

    @Override
    public void removeFile(String catalog, String fileName) throws Exception {
        minioClient.removeObject(RemoveObjectArgs.builder().bucket(catalog).object(fileName).build());
    }

    @Override
    public void removeFiles(String catalog, List<String> fileNames) throws Exception {
        List<DeleteObject> deleteObjectList = new ArrayList<>();
        for (String fileName : fileNames) {
            DeleteObject deleteObject = new DeleteObject(fileName);
            deleteObjectList.add(deleteObject);
        }
        Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(catalog).objects(deleteObjectList).build());
        for (Result<DeleteError> result : results) {
            DeleteError error = result.get();
            log.error("Error in deleting object " + error.objectName() + "; " + error.message());
        }
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        StrategyFactory.register(FileStoreTypeEnum.MINIO, this);
    }
}

package com.qiangesoft.oss.strategy;

import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.model.Bucket;
import com.aliyun.oss.model.DeleteObjectsRequest;
import com.aliyun.oss.model.DeleteObjectsResult;
import com.qiangesoft.oss.config.FileStoreProperties;
import com.qiangesoft.oss.config.StrategyFactory;
import com.qiangesoft.oss.constant.FileStoreTypeEnum;
import io.minio.messages.DeleteObject;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import org.springframework.web.multipart.MultipartFile;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 阿里云策略实现
 *
 * @author qiangesoft
 * @date 2024-05-13
 */
@Slf4j
@RequiredArgsConstructor
@Service
@ConditionalOnProperty(prefix = "oss", name = "type", havingValue = "aliyun")
public class AliyunStrategyImpl implements FileStrategy {

    private OSS ossClient;

    public AliyunStrategyImpl(FileStoreProperties fileStoreProperties) {
        this.ossClient = new OSSClientBuilder().build(fileStoreProperties.getEndpoint(),
                fileStoreProperties.getAccessKey(), fileStoreProperties.getSecretKey());
    }

    @Override
    public boolean existsCatalog(String catalog) throws Exception {
        return ossClient.doesBucketExist(catalog);
    }

    @Override
    public void createCatalog(String catalog) throws Exception {
        if (!this.existsCatalog(catalog)) {
            ossClient.createBucket(catalog);
        }
    }

    @Override
    public List<String> listCatalogs() throws Exception {
        return ossClient.listBuckets().stream().map(Bucket::getName).collect(Collectors.toList());
    }

    @Override
    public void removeCatalog(String catalog) throws Exception {
        ossClient.deleteBucket(catalog);
    }

    @Override
    public String uploadFile(String catalog, MultipartFile file) throws Exception {
        // 参数校验
        Assert.notNull(catalog, "bucketName is not blank");
        Assert.notNull(file, "file is not null");

        // 判断存储桶是否存在
        createCatalog(catalog);

        // 文件名
        String filename = file.getOriginalFilename();

        // 上传
        ossClient.putObject(catalog, filename, file.getInputStream());
        return catalog + SLASH + filename;
    }

    @Override
    public void removeFile(String catalog, String fileName) throws Exception {
        ossClient.deleteObject(catalog, fileName);
    }

    @Override
    public void removeFiles(String catalog, List<String> fileNames) throws Exception {
        List<DeleteObject> deleteObjectList = new ArrayList<>();
        for (String fileName : fileNames) {
            DeleteObject deleteObject = new DeleteObject(fileName);
            deleteObjectList.add(deleteObject);
        }

        DeleteObjectsResult result = ossClient.deleteObjects(new DeleteObjectsRequest(catalog).withKeys(fileNames));
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        StrategyFactory.register(FileStoreTypeEnum.ALI_OSS, this);
    }
}

文件服务类

package com.qiangesoft.oss.service;

import org.springframework.web.multipart.MultipartFile;

import java.util.List;

/**
 * 文件服务接口
 *
 * @author qiangesoft
 * @date 2024-05-13
 */
public interface IFileService {

    /**
     * 创建分类
     *
     * @param catalog
     * @throws Exception
     */
    void createCatalog(String catalog) throws Exception;

    /**
     * 获取分类
     *
     * @return
     */
    List<String> listCatalogs() throws Exception;

    /**
     * 删除分类
     *
     * @param catalog
     * @throws Exception
     */
    void removeCatalog(String catalog) throws Exception;

    /**
     * 上传文件
     *
     * @param catalog
     * @param file
     * @return
     * @throws Exception
     */
    String uploadFile(String catalog, MultipartFile file) throws Exception;

    /**
     * 删除文件
     *
     * @param catalog
     * @param fileName
     * @throws Exception
     */
    void removeFile(String catalog, String fileName) throws Exception;

    /**
     * 删除文件
     *
     * @param catalog
     * @param fileNames
     * @throws Exception
     */
    void removeFiles(String catalog, List<String> fileNames) throws Exception;

}


package com.qiangesoft.oss.service;

import com.qiangesoft.oss.config.FileStoreProperties;
import com.qiangesoft.oss.config.StrategyFactory;
import com.qiangesoft.oss.strategy.FileStrategy;
import org.springframework.beans.BeansException;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;

/**
 * 文件服务实现类
 *
 * @author qiangesoft
 * @date 2024-05-13
 */
@Service
public class FileServiceImpl implements IFileService, ApplicationContextAware, CommandLineRunner {

    private ApplicationContext applicationContext;

    private FileStrategy fileStrategy;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public void run(String... args) throws Exception {
        FileStoreProperties fileStoreProperties = this.applicationContext.getBean(FileStoreProperties.class);
        fileStrategy = StrategyFactory.getStrategy(fileStoreProperties.getType());
    }

    @Override
    public void createCatalog(String catalog) throws Exception {
        fileStrategy.createCatalog(catalog);
    }

    @Override
    public List<String> listCatalogs() throws Exception {
        return fileStrategy.listCatalogs();
    }

    @Override
    public void removeCatalog(String catalog) throws Exception {
        fileStrategy.removeCatalog(catalog);
    }

    @Override
    public String uploadFile(String catalog, MultipartFile file) throws Exception {
        return fileStrategy.uploadFile(catalog, file);
    }

    @Override
    public void removeFile(String catalog, String fileName) throws Exception {
        fileStrategy.removeFile(catalog, fileName);
    }

    @Override
    public void removeFiles(String catalog, List<String> fileNames) throws Exception {
        fileStrategy.removeFiles(catalog, fileNames);
    }

}
PG_强哥
关注
  • 19
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
文件对象管理器（集成MinIO、阿里云OSS基本操作及临时token获取）
04-05
文件对象管理器（集成MinIO、阿里云OSS基本操作及临时token获取）
Springboot开发的多类型文件存储服务（源码）
06-01
本项目是基于Spring Boot开发的多类型文件存储服务，它提供了对多种文件存储服务的支持，包括本地存储、阿里云OSS（Object Storage Service）、Minio以及fastDFS。 首先，我们来看本地文件系统（Local）存储。这是...
SpringBoot项目实现文件上传，MINIO+OSS阿里云
m0_58462450的博客
02-23 1193
只能在创建桶时启用。retention：保留是指在一段时间内防止对象删除的规则。添加minio的配置文件，注意：@Value的注解导入是spring的原生注解。下载后是一个minio.exe的文件，可以先创一个文件夹来存放数据以及文件。versioning: 版本控制允许在同一个键下保留同一个对象的多个版本。再在管理创建用户拿到对应的ID以及Secret。quota：配额用于限制桶内的数据量。添加依赖后，在yml文件下配置相关配置。在文件的目录下cmd进入控制台。在yml文件中配置相对应的配置。
Minio对象存储
weixin_30575309的博客
06-23 1406
目录 Minio对象存储 1、概述 2、功能特性 3.2、多节点 3.3、分布式 4、分布式minio集群搭建 4.1、集群规划 4.3、编写集群启动脚本（所有节点） 4.4、编写服务脚本（...
AWS-S3通用存储操作，操作minio、oss、cos等所有兼容s3协议的云存储（含有大文件分片上传实现）
qq_43548590的博客
07-11 93
通用存储操作common包，支持所有兼容amazon-s3协议的云存储，如minio、oss、cos等，以后客户用啥云储存一套代码都能搞定了
SpringBoot+策略模式实现多种文件存储模式
weixin_39311781的博客
01-08 832
策略模式是一种行为型模式，它将对象和行为分开，将行为定义为一个行为接口和具体行为的实现。
策略模式实现文件上传
qq_68512683的博客
07-21 287
策略模式上传文件(超详细)
Minio代理阿里云OSS springboot使用教程
newbie_God的博客
03-04 1213
Java客户端 首先创建一个Springboot项目，在resources中的application.yml文件添加如下配置： server: port: 8080 spring: servlet: multipart: enabled: true #开启文件上传 max-file-size: 500MB max-request-size: 500MB minio: endpoint: http://localhost:9000 #Min...
SpringBoot整合阿里云OSS、天翼云OSS、MinIO对象存储
summon的博客
11-29 1751
这三种对象存储工具都是我在真实项目中使用过的，它们的使用流程相似，接口名称也差不多，但是在一些细节上还是有些不同的地方。为了让大家更好地了解它们，我在文章中都有标明区别。阿里云和天翼云使用起来比较方便，只需要购买服务就可以了。而MinIO就比较麻烦，需要自己搭建一个服务器环境，并在生产环境中满足主备、证书等方面的要求，这也让我在使用过程中踩了不少坑。不过，我会在新的文章中详细介绍如何搭建MinIO服务器以及如何解决它的问题。
SpringBoot整合——阿里云对象存储（OSS）
weixin_45565886的博客
10-22 1902
SpringBoot整合——阿里云对象存储（OSS）
基于springboot，springcloud，nacos，minio，xxl-job-admin，kibana，.zip
02-23
这些技术组合在一起，可以构建出一个完整的微服务架构体系：SpringBoot和SpringCloud负责服务的开发和治理，Nacos提供服务发现和配置管理，MinIO用于存储中间结果或日志文件，XXL-Job实现任务调度，而Kibana则帮助...
从零搭建Spring Boot脚手架整合OSS作为文件服务器的详细教程
09-07
可以使用阿里云的SDK或Minio的SDK来实现这一功能，通过封装成Spring Boot Starter，使得配置和使用更加便捷。 - **Spring Boot Starter**：通过自定义的Spring Boot Starter，可以轻松地在项目中切换不同的OSS服务...
minio服务部署方案与启动客户端源码.docx
09-21
minio为轻量的文件存储服务，功能基本和阿里云的OSS一样，部署和使用简单快速，以下为单节点部署方案。已经springboot一键启动的客户端整合。
基于SpringBoot等构建的云网盘存储系统.zip
05-25
可以选择使用分布式文件系统如Hadoop HDFS或云服务商提供的对象存储服务（如AWS S3、阿里云OSS）。SpringBoot可以通过集成相关的存储库，如MinIO或RiakCS，实现对这些服务的便捷访问。 4. **RESTful API设计** ...
spring boot(学习笔记第十四课)
最新发布
sealaugh32的专栏
07-20 1016
以上练习了基于内存的认证，实际上，正式的系统开发都是使用数据库进行认证，在这里练习使用使用数据库的用户数据进行认证。注意，这样公司的数据库里面是没有用户的明文密码，即使数据库泄露，也不会暴漏用户的明文密码。注意，每次生成的密码都不一样，但是每个生成的都好用。的认证处理，都会使用这个。
Spring Boot+WebSocket向前端推送消息
2301_76419561的博客
07-20 1428
WebSocket是一种在单个TCP连接上进行全双工通信的协议，允许服务器主动向客户端推送信息，同时也能从客户端接收信息。WebSocket协议诞生于2008年，并在2011年成为国际标准。这种协议解决了传统HTTP请求中需要不断轮询服务器的问题，通过建立持久化的连接，实现了高效的双向数据传输。具体如下：基本特点：WebSocket建立在TCP协议之上，提供了一个全双工通信通道。这意味着服务器和客户端可以在一个连接上同时发送和接收信息，且数据交换更加高效。
【spring boot】初学者项目快速练手
m0_67357141的博客
07-17 996
快速生成一个初始的项目代码，会生成一个demo文件打开intellj idea，导入demo文件。
minio和阿里云oss
08-26
MinIO和阿里云OSS都是云存储服务，可以用来存储和管理大规模的数据。 MinIO是一个开源的对象存储服务器，它兼容Amazon S3协议，可以在本地或私有云环境中部署。MinIO提供高性能的存储和访问速度，并具有强大的扩展性。它可以在小型部署环境中运行，也可以在大规模集群中进行水平扩展，以满足不同规模的需求。 阿里云OSS（Object Storage Service）是阿里云提供的对象存储服务。它具有高可靠性、高可用性和高扩展性，适用于各种应用场景。阿里云OSS提供了丰富的功能和工具，例如数据备份、静态网站托管、图片和视频处理等。它还支持多种安全保护机制，确保存储的数据安全性。 总的来说，MinIO是一个开源的、可自行部署的对象存储服务器，而阿里云OSS是阿里云提供的托管式对象存储服务。选择哪个服务取决于你的具体需求和预算。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

PG_强哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值