《SpringBoot2.0 实战》系列-整合MinIo实现文件上传、下载

最新推荐文章于 2024-06-05 13:49:42 发布
最新推荐文章于 2024-06-05 13:49:42 发布
阅读量2.2k 收藏 14
点赞数 2
分类专栏： springboot2.0实战 文章标签： MinIo springboot 文件上传
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HXNLYW/article/details/109744670
版权

MinIo简介

MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。

MinIO官方文档：https://docs.min.io/cn/

安装

  • docker 安装：
docker run -p 9000:9000 --name minio1 \
  -e "MINIO_ACCESS_KEY=gourd.hu" \
  -e "MINIO_SECRET_KEY=gourd123456" \
  -v /mnt/data:/data \
  -v /mnt/config:/root/.minio \
  minio/minio server /data
  • docker-compose 安装:
version: '3.3'
services:
  # minio
  minio:
    image: minio/minio
    container_name: minio
    hostname: minio
    command: server /data
    restart: always
    ports:
      - "9000:9000"
    volumes:
      - /home/gourd/minio/data:/data
      - /home/gourd/minio/config:/root/.minio
    environment:
    	# 配置域名或者公网IP端口。
      - MINIO_DOMAIN=http://111.231.111.150:9000
      - MINIO_ACCESS_KEY=gourd.hu
      - MINIO_SECRET_KEY=gourd123456

注意：

MINIO_SECRET_KEY密钥必须大于8位，否则会创建失败

管理后台

安装完之后，可登录管理后台查看文件、修改密码等。

地址： 你配置的MINIO_DOMAIN
账号： 默认你配置的MINIO_ACCESS_KEY
密码： 默认你配置的MINIO_SECRET_KEY

在这里插入图片描述

springboot整合

pom.xml中引入MinIO依赖
<!--minio-->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.0.1</version>
</dependency>
application.yml中配置MinIO
# MinIo文件服务器
min:
  io:
    endpoint: http://111.231.111.150:9000
    accessKey: gourd.hu
    secretKey: gourd123456
核心类

minio配置属性类

/**
 * minio配置属性
 *
 * @author gourd.hu
 */
@Data
@ConfigurationProperties(prefix = "min.io")
public class MinIoProperties {
    /**
     * Minio 服务地址
     */
    private String endpoint;

    /**
     * Minio ACCESS_KEY
     */
    private String accessKey;

    /**
     * Minio SECRET_KEY
     */
    private String secretKey;
}

minio工具类，列出了常用的文件操作，如需其他的操作，需要参看官网java-api文档：https://docs.min.io/cn/java-client-api-reference.html

/**
 * minio工具类
 *
 * @author gourd.hu
 */
@Configuration
@EnableConfigurationProperties({MinIoProperties.class})
public class MinIoUtil {
    private MinIoProperties minIo;
    public MinIoUtil(MinIoProperties minIo) {
        this.minIo = minIo;
    }
    private static MinioClient minioClient;
    @PostConstruct
    public void init() {
        try {
            minioClient = MinioClient.builder()
                    .endpoint(minIo.getEndpoint())
                    .credentials(minIo.getAccessKey(), minIo.getSecretKey())
                    .build();
        } catch (Exception e) {
            ResponseEnum.MIN_IO_INIT_FAIL.assertFail(e);
        }
    }

    /**
     * 判断 bucket是否存在
     *
     * @param bucketName
     * @return
     */
    public static boolean bucketExists(String bucketName) {
        try {
            return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            ResponseEnum.MIN_IO_BUCKET_CHECK_FAIL.assertFail(e);
        }
        return false;
    }

    /**
     * 判断 bucket是否存在
     *
     * @param bucketName
     * @param region
     * @return
     */
    public static boolean bucketExists(String bucketName, String region) {
        try {
            return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).region(region).build());
        } catch (Exception e) {
            ResponseEnum.MIN_IO_BUCKET_CHECK_FAIL.assertFail(e);
        }
        return false;
    }

    /**
     * 创建 bucket
     *
     * @param bucketName
     */
    public static void makeBucket(String bucketName) {
        try {
            boolean isExist = bucketExists(bucketName);
            if (!isExist) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            }
        } catch (Exception e) {
            ResponseEnum.MIN_IO_BUCKET_CREATE_FAIL.assertFail(e);
        }
    }

    /**
     * 创建 bucket
     *
     * @param bucketName
     * @param region
     */
    public static void makeBucket(String bucketName, String region) {
        try {
            boolean isExist = bucketExists(bucketName, region);
            if (!isExist) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).region(region).build());
            }
        } catch (Exception e) {
            ResponseEnum.MIN_IO_BUCKET_CREATE_FAIL.assertFail(e);
        }
    }

    /**
     * 删除 bucket
     *
     * @param bucketName
     * @return
     */
    public static void deleteBucket(String bucketName) {
        try {
            minioClient.deleteBucketEncryption(
                    DeleteBucketEncryptionArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            ResponseEnum.MIN_IO_BUCKET_DELETE_FAIL.assertFail(e);
        }
    }

    /**
     * 删除 bucket
     *
     * @param bucketName
     * @return
     */
    public static void deleteBucket(String bucketName, String region) {
        try {
            minioClient.deleteBucketEncryption(
                    DeleteBucketEncryptionArgs.builder().bucket(bucketName).bucket(region).build());
        } catch (Exception e) {
            ResponseEnum.MIN_IO_BUCKET_DELETE_FAIL.assertFail(e);
        }
    }

    /**
     * 文件上传
     *
     * @param bucketName
     * @param objectName
     * @param filePath
     */
    public static void uploadObject(String bucketName, String objectName, String filePath) {
        putObject(bucketName, null, objectName, filePath);
    }

    /**
     * 文件上传
     *
     * @param bucketName
     * @param objectName
     * @param filePath
     */
    public static void uploadObject(String bucketName, String region, String objectName, String filePath) {
        putObject(bucketName, region, objectName, filePath);
    }

    /**
     * 文件上传
     *
     * @param multipartFile
     * @param bucketName
     * @return
     */
    public static String uploadObject(MultipartFile multipartFile, String bucketName) {
        // bucket 不存在，创建
        if (!bucketExists(bucketName)) {
            makeBucket(bucketName);
        }
        return putObject(multipartFile, bucketName, null);
    }

    /**
     * 文件上传
     *
     * @param multipartFile
     * @param bucketName
     * @return
     */
    public static String uploadObject(MultipartFile multipartFile, String bucketName, String region) {
        // bucket 不存在，创建
        if (!bucketExists(bucketName, region)) {
            makeBucket(bucketName, region);
        }
        return putObject(multipartFile, bucketName, region);
    }

    /**
     * 文件下载
     *
     * @param bucketName
     * @param region
     * @param fileName
     * @return
     */
    public static void downloadObject(String bucketName, String region, String fileName) {
        HttpServletResponse response = RequestHolder.getResponse();
        // 设置编码
        response.setCharacterEncoding(XmpWriter.UTF8);
        try (ServletOutputStream os = response.getOutputStream();
             GetObjectResponse is = minioClient.getObject(
                     GetObjectArgs.builder()
                             .bucket(bucketName)
                             .region(region)
                             .object(fileName)
                             .build());) {

            response.setHeader("Content-Disposition", "attachment;fileName=" +
                    new String(fileName.getBytes("gb2312"), "ISO8859-1"));
            ByteStreams.copy(is, os);
            os.flush();
        } catch (Exception e) {
            ResponseEnum.MIN_IO_FILE_DOWNLOAD_FAIL.assertFail(e);
        }
    }

    /**
     * 获取文件
     *
     * @param bucketName
     * @param region
     * @param fileName
     * @return
     */
    public static String getObjectUrl(String bucketName, String region, String fileName) {
        String objectUrl = null;
        try {
            objectUrl = minioClient.getPresignedObjectUrl(
                    GetPresignedObjectUrlArgs.builder()
                            .method(Method.GET)
                            .bucket(bucketName)
                            .region(region)
                            .object(fileName)
                            .build());
        } catch (Exception e) {
            ResponseEnum.MIN_IO_FILE_GET_FAIL.assertFail(e);
        }
        return objectUrl;
    }

    /**
     * 删除文件
     *
     * @param bucketName
     * @param objectName
     */
    public static void deleteObject(String bucketName, String objectName) {
        try {
            minioClient.removeObject(
                    RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
        } catch (Exception e) {
            ResponseEnum.MIN_IO_FILE_DELETE_FAIL.assertFail(e);
        }
    }

    /**
     * 删除文件
     *
     * @param bucketName
     * @param region
     * @param objectName
     */
    public static void deleteObject(String bucketName, String region, String objectName) {
        try {
            minioClient.removeObject(
                    RemoveObjectArgs.builder().bucket(bucketName).region(region).object(objectName).build());
        } catch (Exception e) {
            ResponseEnum.MIN_IO_FILE_DELETE_FAIL.assertFail(e);
        }
    }

    /**
     * 上传文件
     *
     * @param multipartFile
     * @param bucketName
     * @return
     */
    private static String putObject(MultipartFile multipartFile, String bucketName, String region) {
        try (InputStream inputStream = multipartFile.getInputStream()) {
            // 上传文件的名称
            String fileName = multipartFile.getOriginalFilename();
            minioClient.putObject(PutObjectArgs.builder()
                    .bucket(bucketName)
                    .region(region)
                    .object(fileName)
                    .stream(inputStream, multipartFile.getSize(), ObjectWriteArgs.MIN_MULTIPART_SIZE)
                    .contentType(multipartFile.getContentType())
                    .build());
            // 返回访问路径
            return getObjectUrl(bucketName, region, fileName);
        } catch (Exception e) {
            ResponseEnum.MIN_IO_FILE_UPLOAD_FAIL.assertFail(e);
        }
        return null;
    }

    /**
     * 上传文件
     *
     * @param bucketName
     * @param region
     * @param objectName
     * @param filePath
     */
    private static String putObject(String bucketName, String region, String objectName, String filePath) {
        try {
            minioClient.uploadObject(
                    UploadObjectArgs.builder()
                            .bucket(bucketName)
                            .region(region)
                            .object(objectName)
                            .filename(filePath)
                            .build());
            // 返回访问路径
            return getObjectUrl(bucketName, region, objectName);
        } catch (Exception e) {
            ResponseEnum.MIN_IO_FILE_UPLOAD_FAIL.assertFail(e);
        }
        return null;
    }
}

测试

controller控制器入口方法，上传完之后可以在管理后台查看到。

	/**
     * minio上传文件
     *
     */
    @PostMapping("/minio-upload")
    @ApiOperation(value="minio上传文件")
    public BaseResponse minioUpload(MultipartFile file){
        return BaseResponse.ok(MinIoUtil.uploadObject(file,"gourd","suzhou"));
    }
    /**
     * minio下载文件
     *
     */
    @GetMapping("/minio-download")
    @ApiOperation(value="minio下载文件")
    public void minioDownload(){
        MinIoUtil.downloadObject("gourd","suzhou","paixu.gif");
    }

在这里插入图片描述

结语

至此，MinIo整合实现文件上传、下载功能就好了。如有错误之处，欢迎指正。

代码摘自本人的开源项目cloud-plus：https://blog.csdn.net/HXNLYW/article/details/104635673

葫芦胡
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java开发案例-springboot-10-整合MinIO实现文件上传与下载-源代码+文档.rar
05-31
Java开发案例-springboot-10-整合MinIO实现文件上传与下载-源代码+文档.rar Java开发案例-springboot-10-整合MinIO实现文件上传与下载-源代码+文档.rar Java开发案例-springboot-10-整合MinIO实现文件上传与下载-源...
SpringBoot(31) 整合MinIO实现文件上传与下载
08-17
在本教程中，我们将深入探讨如何使用SpringBoot框架与MinIO进行集成，以实现文件的上传和下载功能。SpringBoot以其简洁的配置和强大的功能深受Java开发者喜爱，而MinIO则是一个高性能的对象存储服务器，适合处理大...
minio（RELEASE.2021-04） 和s3cmd（2.1.0_2 ）部署
blackoon88的博客
04-21 1935
文章目录前言一、minio安装1.文件下载2.安装文件3.启动停止服务二、s3cmd安装1.下载安装包2.安装配置3.使用3.1 minio web端3.2s3cmd上传下载文件总结 前言 分布式文件存储，支持java API，选用minio，当然也可以使用阿里的OSS，azure S3等其他技术； 本地文件上传，下载文件可以使用s3cmd,所以本地安装下s3cmd. 提示：以下是本篇文章正文内容，下面案例可供参考 一、minio安装 对于中小型企业，如果不选择存储上云，那么 Minio 是个不错的选
springboot整合minio
qq_36090537的博客
11-29 9083
minio是对象存储服务。它基于Apache License 开源协议，兼容Amazon S3云存储接口。适合存储非结构化数据，如图片，音频，视频，日志等。对象文件最大可以达到5TB。
Spring Boot轻松整合Minio实现文件上传下载功能
最新发布
jjc4261的博客
06-05 599
该方法主要实现逻辑：在项目启动的时候初始化Bucket，如果没有则进行创建！新建minio.sh shell脚本文件。，自定义端口启动（默认端口：9000）注意：浏览器访问需要开启防火墙端口！minio 默认账号密码为。进入服务器查看文件上传情况。添加到开机自启动服务中。进入init.d目录。给shell脚本赋权。
SpringBoot整合minio服务（超详细）
yueyue763184的博客
06-10 1万+
创建一个名为public的存储桶（名字可自定义），上传文件。在application.yml文件中编写相关配置。http://ip:9000/存储桶名/文件名。开发中上传接口用得较多，其他接口可自行测试。可以将存储桶的访问权限设置为public.# npm下载element-ui。// 引入ElementUI。
SpringBoot-集成Minio
孟孟的博客
10-24 7315
Minio 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。Minio是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL。
MinIO的上传和下载
King_of_liuguan的博客
07-07 3480
我们经常接触到的关于minio的上传下载都是在项目中导入minio依赖，然后给配置一个MinioConfig，配置minio服务的地址账号密码等，如下图。
SpringBoot2 整合MinIO中间件实现文件便捷管理功能
08-18
SpringBoot2 整合 MinIO 中间件...SpringBoot2 整合 MinIO 中间件可以实现文件便捷管理功能，主要通过 MinIO 简介、MinIO 存储机制、MinIO 环境搭建、SpringBoot 整合 MinIO、MinIO 配置类和文件上传六个方面来实现。
Spring boot整合MinIO客户端实现文件管理
06-27
MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和...Spring boot整合MinIO客户端实现文件管理
Minio对象存储及Springboot整合Minio分片上传文章-代码
02-23
这里，我们定义了一个`MinioBucketOperations`接口，用于封装与Minio相关的操作，例如上传、下载、删除文件等。你可以根据需求实现这个接口。 要实现分片上传，我们需要对大文件进行切片处理。在上传前，计算文件的...
【Java编程系列】Minio实现文件上传下载
热门推荐
Yangy的博客
09-26 1万+
最近给一个租户做minio的独立存储部署，使用过程中，有了一点使用心得，做一个记录分享，希望可以帮到有需要的朋友~~~
springboot整合minio（实现文件的上传和下载超详细入门）
2301_78646673的博客
11-05 8298
目前可用于文件存储的网络服务选择也有不少，比如阿里云OSS、七牛云、腾讯云等等，可是收费都有点小贵。为了省钱，很多公司使用MinIO做为文件服务器。官网：https://www.minio.org.cn/MinIO是一个开源的分布式对象存储服务器，支持S3协议并且可以在多节点上实现数据的高可用和容错。它采用Go语言开发，拥有轻量级、高性能、易部署等特点，并且可以自由选择底层存储介质。它基于Apache License 开源协议，兼容Amazon S3云存储接口。
SpringBoot整合MinIO详细步骤
Coder_ljw的博客
07-20 1779
SpringBoot整合MinIO详细步骤，本篇文章主要讲解了SpringBoot整合MinIO详细步骤，MinIO是目前非常流行的分布式对象存储系统（OSS），安装部署过程需要大家熟练掌握，同学们可以动手实操练习。
SpringBoot整合Minio
鸟人的博客
08-15 1096
在企业开发中，我们经常会使用到文件存储的业务，Minio就是一个不错的文件存储工具，下面我们来看看如何在SpringBoot中整合Miniopom文件指定SpringBoot项目所依赖的软件工具包 YML SpringBoot配置文件 MinioClientConfig Minio的配置类 MinioUtil 操作Minio的工具类，实现了判断Bucket是否存在，创建Bucket，上传文件，下载文件等功能 案例 在SpringBoot中如何使用MinioUtil操作Minio，一般我们会使用Minio当做
Springboot整合 Minio
兵哥的博客
06-08 2169
【代码】Springboot整合 Minio。
SpringBoot整合Minio实现文件上传、下载
玩转Java
11-18 1万+
springboot-minio
SpringBoot整合Minio(实现上传与下载)
regaer1029的博客
07-18 2303
SpringBoot整合Minio完成简单文件的上传与下载
Springboot整合MinIO
普通人一枚
04-24 1160
Springboot整合MinIO
springboot 整合minio 实现多级目录下文件的下载
05-24
要实现Spring Boot整合MinIO实现多级目录下文件的下载，可以按照以下步骤进行： 1. 引入MinIO的依赖 在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <version>7.1.0</version> </dependency> ``` 2. 配置MinIO连接信息 在application.yml文件中添加以下配置信息： ```yaml minio: endpoint: http://localhost:9000 # MinIO服务地址 accessKey: minioadmin # 访问Key secretKey: minioadmin # 访问Secret bucketName: test-bucket # 存储桶名称 ``` 3. 创建MinIO客户端 创建MinIO客户端的代码如下： ```java @Configuration public class MinioConfig { @Value("${minio.endpoint}") private String endpoint; @Value("${minio.accessKey}") private String accessKey; @Value("${minio.secretKey}") private String secretKey; @Value("${minio.bucketName}") private String bucketName; @Bean public MinioClient minioClient() throws InvalidPortException, InvalidEndpointException { return MinioClient.builder() .endpoint(endpoint) .credentials(accessKey, secretKey) .build(); } @Bean public String bucketName() { return bucketName; } } ``` 4. 实现文件下载接口 实现文件下载接口的代码如下： ```java @RestController @RequestMapping("/file") public class FileController { @Autowired private MinioClient minioClient; @Autowired private String bucketName; @GetMapping("/download") public ResponseEntity<Resource> downloadFile(@RequestParam("path") String path) throws Exception { String[] pathArr = path.split("/"); String objectName = pathArr[pathArr.length - 1]; String objectPath = path.substring(0, path.lastIndexOf("/") + 1); InputStream inputStream = minioClient.getObject(GetObjectArgs.builder() .bucket(bucketName) .object(objectPath + objectName) .build()); ByteArrayResource resource = new ByteArrayResource(inputStream.readAllBytes()); return ResponseEntity.ok() .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + objectName + "\"") .body(resource); } } ``` 其中，`path`参数是要下载的文件路径，例如：`folder1/folder2/test.txt`。 5. 测试文件下载接口 启动应用程序后，访问`http://localhost:8080/file/download?path=folder1/folder2/test.txt`即可下载名为`test.txt`的文件，该文件位于MinIO存储桶的`folder1/folder2/`路径下。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值