SpringBoot整合Minio及阿里云OSS（配置文件无缝切换）

已于 2024-09-06 17:56:53 修改
阅读量876 收藏 17
点赞数 18
分类专栏： 常用技术 Spring/SpringBoot # OSS对象存储 文章标签： spring boot 后端 阿里云
于 2024-09-06 17:54:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54158370/article/details/141965836
版权

SpringBoot整合Minio及阿里云OSS

文章目录

1.Minio安装测试

MinIO是一个对象存储解决方案，它提供了与Amazon Web Services S3兼容的API，并支持所有核心S3功能。 MinIO有能力在任何地方部署 - 公有云或私有云，裸金属基础设施，编排环境，以及边缘基础设施。

文档地址：https://www.minio.org.cn/docs/minio/linux/developers/java/API.html#

1.Docker安装

拉取对应的镜像

docker pull minio/minio

创建挂载目录

mkdir -p /dockerData/minio/data
mkdir -p /dockerData/minio/config
启动容器

然后我们启动我们的容器，后面有个目录，就是我们需要挂载的硬盘目录

docker run --privileged -it -p 9000:9000 --name minio \
-e "MINIO_ACCESS_KEY=moshangshang2024" \
--privileged=true \
-e "MINIO_SECRET_KEY=moshangshang2024" \
-v /dockerData/minio/data:/data \
-v /dockerData/minio/config:/root/.minio \
minio/minio server /data

最新版本的minio启动使用这条语句

其中修改了MINIO_ROOT_USER和MINIO_ROOT_PASSWORD名称,增加了web控制台端口，密码长度需大于8位

docker run  --privileged -it \
--name minio \
-p 9000:9000  \
-p 9090:9090  \
-d --restart=always \
-e "MINIO_ROOT_USER=moshangshang2024" \
-e "MINIO_ROOT_PASSWORD=xxxxxxxx" \
-v /dockerData/minio/data:/data \
-v /dockerData/minio/config:/root/.minio \
minio/minio server  /data --console-address ":9090" --address ":9000"

我们只需要访问上面提到的ip地址

http://192.168.1.101:9000

输入刚刚配置的账号moshangshang2024和密码 即可进入
在这里插入图片描述

2.创建bucket

我们首先需要创建一个桶，可以当成是一个目录，选择 create bucket进行创建

在这里插入图片描述

3.上传文件

然后我们选中我们的桶，选择 upload 进行文件上传

在这里插入图片描述

在这里插入图片描述

修改权限

如果要使用SDK，比如Java客户端来操作我们的minio的话，那么我们还需要修改一下我们的bucket权限

在这里插入图片描述
在这里插入图片描述

然后就可以通过http://ip:9000/存储桶名/文件名访问文件

2.SpringBoot整合Minio及阿里云OSS

1.公共部分抽取

1.添加自定义yml配置

#对象存储
oss:
  #对象存储切换配置
  type: minio
  minio:
    endpoint: http://192.168.1.102:9000
    accessKey: root
    secretKey: root
    bucketImageName: test

  #阿里云对象存储的配置信息
  aliyun:
    accessKey: xxxxx
    accessSecret: xxxxx
    endpoint: oss-cn-hangzhou.aliyuncs.com
    bucketImageName: test

2.公共操作方法接口

package com.li.test.minio;

import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.util.List;

public interface OSSOperation {

    /**
     * 获取默认bucketName
     *
     * @return 返回 名称
     */
    public String getBucketName();

    /**
     * 校验bucket是否存在
     *
     * @param bucketName 桶名称
     * @return 返回 boolean - 如果存储桶存在，则为 True。
     */
    public boolean checkBucketExist(String bucketName);

    /**
     * 列出所有存储桶的存储桶信息
     */
    public List<String> listBuckets();

    /**
     * 创建一个存储桶
     *
     * @param bucketName 桶名称
     * @return 返回 boolean - 如果执行成功，则为 True。
     */
    public boolean makeBucket(String bucketName);


    /**
     * 删除一个空的存储桶
     *
     * @param bucketName 桶名称
     * @return 返回 boolean - 如果执行成功，则为 True。
     */
    public boolean removeBucket(String bucketName);


    /**
     * 文件上传
     *
     * @param data       文件数据
     * @param bucketName 上传的桶名称
     */
    public boolean uploadFile(MultipartFile data, String bucketName);

    /**
     * 文件上传
     *
     * @param fileName   文件名
     * @param bucketName 上传的桶名称
     */
    public void downloadFile( String fileName, String bucketName, HttpServletResponse response);

    /**
     * 文件删除
     *
     * @param fileName   文件名
     * @param bucketName 上传的桶名称
     */
    public boolean removeFile(String fileName, String bucketName);
}

2.Minio配置整合

1.添加pom依赖
      <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.5.10</version>
        </dependency>
2.添加配置文件

然后我们需要编写配置文件，用于初始化配置 MinioClient装载到spring容器中

@Data
@ConfigurationProperties(prefix = "oss.minio")
public class MinioOSSProperties {

    private String endpoint;
    private String accessKey;
    private String secretKey;
    private String bucketImageName;

}


/**
 * Minio配置类
 *
 * @author moshangshang
 */
@Configuration
@EnableConfigurationProperties(MinioOSSProperties.class)
@ConditionalOnProperty(prefix = "oss", name = "type",havingValue = "minio", matchIfMissing = true)
public class MinioOSSConfiguration {

    @Resource
    private MinioOSSProperties ossProperties;

    @Bean
    @SneakyThrows
    public MinioClient minioClient() {
        return MinioClient.builder()
                .endpoint(ossProperties.getEndpoint())
                .credentials(ossProperties.getAccessKey(), ossProperties.getSecretKey())
                .build();
    }

}
3.操作接口实现
/**
 * minio操作工具类
 * @author moshangshang
 */
@Slf4j
@Data
@Component
public class MinioUtils {

    @Resource
    private MinioClient minioClient;

    @Resource
    private OssMinioProperties minioProperties;


    /**
     * 校验bucket是否存在
     *
     * @param bucketName 桶名称
     * @return 返回 boolean - 如果存储桶存在，则为 True。
     */
    public boolean checkBucketExist(String bucketName) {
        boolean found = false;
        try {
            found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            if (found) {
                log.info("{} exists", bucketName);
            } else {
                log.info("{} not exist", bucketName);
            }
        } catch (Exception e) {
            log.info("{} checkBucketExist exception", bucketName,e);
        }
        return found;
    }

    /**
     * 列出所有存储桶的存储桶信息
     */
    public List<Bucket> listBuckets() {
        List<Bucket> buckets = new ArrayList<>();
        try {
            buckets = minioClient.listBuckets();
        } catch (Exception e) {
            log.info("listBuckets exception......",e);
        }
        return buckets;

    }

    /**
     * 创建一个存储桶
     *
     * @param bucketName 桶名称
     * @return 返回 boolean - 如果执行成功，则为 True。
     */
    public boolean makeBucket(String bucketName) {
        boolean found = false;
        try {
            minioClient.makeBucket(
                    MakeBucketArgs.builder()
                            .bucket(bucketName)
                            .build());
            found = true;
        } catch (Exception e) {
            log.info("{} makeBucket exception {}", bucketName,e.getMessage(),e);
        }
        return found;
    }


    /**
     * 删除一个空的存储桶
     *
     * @param bucketName 桶名称
     * @return 返回 boolean - 如果执行成功，则为 True。
     */
    public boolean removeBucket(String bucketName) {
        boolean found = false;
        try {
            minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
            found = true;
        } catch (Exception e) {
            log.info("{} removeBucket exception", bucketName);
        }
        return found;
    }


    /**
     * 文件上传
     *
     * @param data       文件数据
     * @param bucketName 上传的桶名称
     */
    public boolean uploadFile(MultipartFile data, String bucketName) {
        boolean flag = checkBucketExist(bucketName);
        if (!flag){
            return false;
        }
        String fileName = data.getOriginalFilename();
        InputStream is = null;
        try {
            is = data.getInputStream();
            minioClient.putObject(
                    PutObjectArgs.builder()
                            .bucket(bucketName)
                            .object(fileName)
                            .stream(is, data.getSize(), -1)
                            .contentType(data.getContentType())
                            .build());
            return true;
        } catch (Exception e) {
            log.info("{} upload exception", bucketName,e);
        }
        return false;
    }

    /**
     * 文件上传
     *
     * @param fileName   文件名
     * @param bucketName 上传的桶名称
     */
    public void downloadFile( String fileName, String bucketName, HttpServletResponse response) {
        GetObjectResponse is = null;
        try {
            GetObjectArgs getObjectArgs = GetObjectArgs.builder()
                    .bucket(bucketName)
                    .object(fileName)
                    .build();
            is = minioClient.getObject(getObjectArgs);
            response.setContentType("application/octet-stream");
            response.setCharacterEncoding("utf-8");
            response.setHeader("Content-Disposition", "attachment;fileName=" + URLEncoder.encode(fileName, "utf-8"));
            IoUtil.copy(is, response.getOutputStream());
            log.info("minio downloadFile success, filePath:{}", fileName);
        } catch (Exception e) {
            log.error("minio downloadFile Exception:{}", e.getMessage(), e);
        } finally {
            IoUtil.close(is);
        }
    }

    /**
     * 文件删除
     *
     * @param fileName   文件名
     * @param bucketName 上传的桶名称
     */
    public boolean removeFile(String fileName, String bucketName) {
        boolean flag = checkBucketExist(bucketName);
        if (!flag){
            return false;
        }
        try {
            minioClient.removeObject(
                    RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build());
            return true;
        } catch (Exception e) {
            log.error("minio removeFile Exception:{}", e.getMessage(), e);
        }
        return false;
    }
}

3.阿里云OSS配置整合

1.pom依赖
     <dependency>
            <groupId>com.aliyun.oss</groupId>
            <artifactId>aliyun-sdk-oss</artifactId>
            <version>3.10.2</version>
        </dependency>
2.添加配置文件
@Data
@ConfigurationProperties(prefix = "oss.aliyun")
public class AliYunOSSProperties {

    private String accessKey;

    private String accessSecret;

    private String endpoint;

    private String bucketImageName;

}

/**
 * 阿里云oss配置类
 *
 * @author moshangshang
 */
@Configuration
@EnableConfigurationProperties(AliYunOSSProperties.class)
@ConditionalOnProperty(prefix = "oss", name = "type",havingValue = "aliyun", matchIfMissing = true)
public class AliYunOSSConfiguration {

    @Resource
    private AliYunOSSProperties ossProperties;

    @Bean
    @SneakyThrows
    public OSS ossClient() {
        return new OSSClientBuilder().build(ossProperties.getEndpoint(),ossProperties.getAccessKey(),ossProperties.getAccessSecret());
    }

}
3.操作接口实现
/**
 * 阿里云oss操作工具类
 * @author moshangshang
 */
@Slf4j
@Data
@Component
@ConditionalOnProperty(prefix = "oss", name = "type",havingValue = "aliyun", matchIfMissing = true)
public class AliYunOSSOperation implements OSSOperation {

    @Resource
    private OSS ossClient;

    @Resource
    private AliYunOSSProperties aliYunOSSProperties;


    @Override
    public String getBucketName() {
        return aliYunOSSProperties.getBucketImageName();
    }

    /**
     * 校验bucket是否存在
     *
     * @param bucketName 桶名称
     * @return 返回 boolean - 如果存储桶存在，则为 True。
     */
    public boolean checkBucketExist(String bucketName) {
        boolean found = false;
        try {
            found = ossClient.doesBucketExist(bucketName);
            if (found) {
                log.info("{} exists", bucketName);
            } else {
                log.info("{} not exist", bucketName);
            }
        } catch (Exception e) {
            log.info("{} checkBucketExist exception", bucketName,e);
        }
        return found;
    }

    /**
     * 列出所有存储桶的存储桶信息
     */
    public List<String> listBuckets() {
        List<String> result = new ArrayList<>();
        try {
           List<Bucket> buckets = ossClient.listBuckets();
           result = buckets.stream().map(Bucket::getName).collect(Collectors.toList());
        } catch (Exception e) {
            log.info("listBuckets exception......",e);
        }
        return result;

    }

    /**
     * 创建一个存储桶
     *
     * @param bucketName 桶名称
     * @return 返回 boolean - 如果执行成功，则为 True。
     */
    public boolean makeBucket(String bucketName) {
        boolean found = false;
        try {
            ossClient.createBucket(bucketName);
            found = true;
        } catch (Exception e) {
            log.info("{} makeBucket exception {}", bucketName,e.getMessage(),e);
        }
        return found;
    }


    /**
     * 删除一个空的存储桶
     *
     * @param bucketName 桶名称
     * @return 返回 boolean - 如果执行成功，则为 True。
     */
    public boolean removeBucket(String bucketName) {
        boolean found = false;
        try {
            ossClient.deleteBucket(bucketName);
            found = true;
        } catch (Exception e) {
            log.info("{} removeBucket exception", bucketName);
        }
        return found;
    }


    /**
     * 文件上传
     *
     * @param data       文件数据
     * @param bucketName 上传的桶名称
     */
    public boolean uploadFile(MultipartFile data, String bucketName) {
        String fileName = data.getOriginalFilename();
        InputStream is = null;
        try {
            is = data.getInputStream();
            ossClient.putObject(bucketName,fileName,data.getInputStream());
            return true;
        } catch (Exception e) {
            log.info("{} upload exception", bucketName,e);
        }
        return false;
    }

    /**
     * 文件下载
     *
     * @param fileName   文件名
     * @param bucketName 上传的桶名称
     */
    public void downloadFile( String fileName, String bucketName, HttpServletResponse response) {
        InputStream is = null;
        try {

            is = ossClient.getObject(bucketName,fileName).getObjectContent();
            response.setContentType("application/octet-stream");
            response.setCharacterEncoding("utf-8");
            response.setHeader("Content-Disposition", "attachment;fileName=" + URLEncoder.encode(fileName, "utf-8"));
            IoUtil.copy(is, response.getOutputStream());
            log.info("minio downloadFile success, filePath:{}", fileName);
        } catch (Exception e) {
            log.error("minio downloadFile Exception:{}", e.getMessage(), e);
        } finally {
            IoUtil.close(is);
        }
    }

    /**
     * 文件删除
     *
     * @param fileName   文件名
     * @param bucketName 上传的桶名称
     */
    public boolean removeFile(String fileName, String bucketName) {
        boolean flag = checkBucketExist(bucketName);
        if (!flag){
            return false;
        }
        try {
            ossClient.deleteObject(bucketName,fileName);
            return true;
        } catch (Exception e) {
            log.error("minio removeFile Exception:{}", e.getMessage(), e);
        }
        return false;
    }
}

4.测试

/**
 * minio测试
 * @author moshangshang
 */
@Slf4j
@RestController
public class OSSController {

    @Resource
    private OSSOperation ossOperation;

    
    @PostMapping("/check")
    public boolean checkBucketExist(@RequestParam("bucketName")String bucketName) {
        return ossOperation.checkBucketExist(bucketName);
    }

    @PostMapping("/upload")
    public boolean upload(@RequestParam("data") MultipartFile data) {
        return ossOperation.uploadFile(data, ossOperation.getBucketName());
    }

    @PostMapping("/download")
    public void download(@RequestParam("fileName")String fileName, HttpServletResponse response) {
        ossOperation.downloadFile(fileName, ossOperation.getBucketName(), response);
    }

    @PostMapping("/remove/file")
    public boolean removeFile(@RequestParam("fileName")String fileName) {
        return ossOperation.removeFile(fileName, ossOperation.getBucketName());
    }

    @PostMapping("/remove/bucket")
    public boolean removeBucket(@RequestParam("bucketName")String bucketName) {
        return ossOperation.removeBucket(bucketName);
    }

    @PostMapping("/add/bucket")
    public boolean makeBucket(@RequestParam("bucketName")String bucketName) {
        return ossOperation.makeBucket(bucketName);
    }


    @PostMapping("/bucket/list")
    public List<String> listBuckets() {
        return ossOperation.listBuckets();
    }


}
陌殇殇
关注
专栏目录
文件对象管理器（集成MinIO、阿里云OSS基本操作及临时token获取）
04-05
文件对象管理器（集成MinIO、阿里云OSS基本操作及临时token获取）
Minio对象存储及Springboot整合Minio分片上传文章-代码
02-23
Minio是一款开源的对象存储服务，它致力于为开发者提供简单、高性能、高可用的云存储解决方案。Minio的设计灵感来源于Amazon S3，适用于存储大量的非结构化数据，如图片、视频、文档等。在本文中，我们将深入探讨...
SpringBoot整合阿里云OSS、天翼云OSS、MinIO对象存储
summon的博客
11-29 2017
这三种对象存储工具都是我在真实项目中使用过的，它们的使用流程相似，接口名称也差不多，但是在一些细节上还是有些不同的地方。为了让大家更好地了解它们，我在文章中都有标明区别。阿里云和天翼云使用起来比较方便，只需要购买服务就可以了。而MinIO就比较麻烦，需要自己搭建一个服务器环境，并在生产环境中满足主备、证书等方面的要求，这也让我在使用过程中踩了不少坑。不过，我会在新的文章中详细介绍如何搭建MinIO服务器以及如何解决它的问题。
【SpringBoot】SpringBoot 集成 Minio、OSS
sco5282的博客
08-31 1141
MinIO 是一款基于 Go 语言发开的高性能、分布式的对象存储系统。简单来说：就是可以存视频、图片 等。可以创建一个 bucket。
服务端文件存储的两种方式minio和阿里云OSS
Demo的博客
04-18 322
存储图片文件并返回路径。
SpringBoot搭载阿里云 对象储存OSS
谜语人的博客
09-21 352
访问该网址后扫码注册,注册完毕后记得修改个人信息,设置安全密码之后点击控制台点击控制台后点左上角三条杠之后选择对象储存点击进入后需要开通OSS储存服务开通之前需要进行实名认证刚开始是免费开通的,直接点击购买即可之后进入Bucket列表点击创建Bucket按照如上配置进行配置配置完成后点击完成创建创建完成后点击名称进入创建好可以在Bucket内上传文件,之后可以直接通过URL进行下载访问点击上传好的文件名即可进入到此OSS注册配置完成。
OSS转到Minio
出去玩去的博客
06-16 280
4、执行同步命令，修改成自己的bucket名称即可。3、创建配置文件,配置文件需在指定位置。1、下载rclone工具执行命令。2、判断是否成功并编译。
【OSS对象存储】Springboot集成阿里云OSS + 私有化部署Minio
Java技术站
07-23 860
1. 掌握阿里云OSS、私有化部署Minio两种对象存储的使用方式。 2. 运用工厂+策略模式，封装OSS对象存储API，可实现动态切换。 3. minio配置https访问
SpringBoot整合Minio
liyh722的博客
08-07 2259
SpringBoot整合Minio
SpringBoot整合——阿里云对象存储（OSS）
weixin_45565886的博客
10-22 2049
SpringBoot整合——阿里云对象存储（OSS）
springboot集成minio完成自己的分布式文件系统
02-28
SpringBoot集成MinIO是构建分布式文件系统的常见方法，尤其对于Java开发者来说，这是一个高效且经济的解决方案。MinIO是一款开源的对象存储服务器，它兼容Amazon S3 API，可以提供高性能、高可用性和安全性。通过将...
SpringBoot(31) 整合MinIO实现文件上传与下载
08-17
SpringBoot以其简洁的配置和强大的功能深受Java开发者喜爱，而MinIO则是一个高性能的对象存储服务器，适合处理大规模的文件存储任务。 首先，让我们了解SpringBoot和MinIO的基本概念。SpringBoot是Spring框架的一个...
SpringBoot整合minio服务（超详细）
热门推荐
yueyue763184的博客
06-10 1万+
创建一个名为public的存储桶（名字可自定义），上传文件。在application.yml文件中编写相关配置。http://ip:9000/存储桶名/文件名。开发中上传接口用得较多，其他接口可自行测试。可以将存储桶的访问权限设置为public.# npm下载element-ui。// 引入ElementUI。
Spring Boot：打造下一代医院管理系统
最新发布
2401_85763639的博客
10-07 1613
目前，界面设计已经成为对软件质量进行评价的一条关键指标，一个好的用户界面可以使用户使用系统的信心和兴趣增加，从而使工作效率提高，JSP技术是将JAVA语言作为脚本语言的，JSP网页给整个服务器端的JAVA库单元提供了一个接口用来服务HTTP的应用程序。一旦输入系统的数据不正确，那么处理后的输出就会扩大这些错误，因此输入的数据的准确性对整个系统的性能起着决定性意义。输出是由电脑对输入的基本信息进行解决，生成高质量的有效信息，并使之具有一定的格式，提供给管理者使用，这是输出设计的主要责任和目标。
Spring Boot DevTools：如何关闭自动重启功能
apple_64847327的博客
10-04 1015
Spring Boot DevTools是Spring Boot的一个开发工具，它能够加速开发和调试过程。自动重启：当代码发生变化时，自动重启应用程序。实时编辑：在某些情况下，支持类的热交换，无需重启。快速应用：通过跳过一些步骤来加速应用程序的启动。
使用 Spring Boot 实现 JWT 生成与验证的自定义类
服务员的博客
09-29 1097
JWT 的结构通常包含三个部分：头部（Header）、载体（Payload）和签名（Signature）。通过对这三个部分进行编码和加密，JWT 能够安全地传递用户信息。有效的 JWT 需要在客户端和服务器之间传递，因此确保它们的安全性是至关重要的。
Spring Boot项目中使用MyBatis
weixin_73060959的博客
10-02 869
在Spring Boot项目中使用MyBatis可以极大地简化配置过程，并且Spring Boot提供了很好的集成支持。你只需要添加必要的依赖，配置数据源，然后创建Mapper接口、XML映射文件和实体类，就可以轻松地进行数据库操作了。
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
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值