Spring Boot 集成 MinIO 实现文件上传

已于 2024-06-21 14:45:34 修改
阅读量658 收藏 5
点赞数 7
分类专栏： Java Spring框架 文章标签： spring boot java 后端
于 2024-06-21 14:43:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48471044/article/details/139860900
版权

Spring Boot 集成 MinIO 实现文件上传

一、 Minio 服务准备

MinIO的搭建过程参考 Docker 搭建 MinIO 对象存储。

登录MinIO控制台，新建一个 Bucket，修改 Bucket 权限为公开。

在这里插入图片描述

二、MinIO 集成

  1. 添加 MinIO 依赖
<!-- https://mvnrepository.com/artifact/io.minio/minio -->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>${minio.version}</version>
</dependency>
  1. 在项目配置文件application.yml中添加自定义配置。properties 文件自行转换
minio:
  host: http://【服务器公网ip】:【minio运行端口号，默认9000】/
  access-key: 账号
  secret-key: 密码
  1. 创建配置文件类
@Data
@Component
public class MinioConfig {
 
    @Value(value = "${minio.host}")
    private String host;
 
    @Value(value = "${minio.access-key}")
    private String accessKey;
 
    @Value(value = "${minio.secret-key}")
    private String secretKey;

    @Bean
    public MinioClient minioClient(){

        return MinioClient.builder()
                .endpoint(host)
                .credentials(accessKey, secretKey)
                .build();
    }
}
  1. 创建文件上传工具类
@Component
@Slf4j
@AllArgsConstructor
public class MinioUtils {

    private final MinioClient minioClient;
    private final MinioConfig minioConfig;

    /**
     * 初始化Bucket
     */
    private void createBucket(String bucketName) {
        // 设置公开读写
        String POLICY_PATTERN = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:GetObject\"],\"Resource\":[\"arn:aws:s3:::%s/*\"]}]}";
        try {
            // 判断 BucketName 是否存在
            if (!bucketExists(bucketName)) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            }
            minioClient.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(
                    String.format(POLICY_PATTERN, bucketName)
            ).build());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 验证bucketName是否存在
     *
     * @return boolean true:存在
     */
    public boolean bucketExists(String bucketName) {
        if (StringUtils.isBlank(bucketName)) {
            throw new ServerException(ErrorCode.BUCKET_NAME_NOT_NULL);
        }
        boolean flag = true;
        try {
            flag = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }


    /**
     * 获取全部bucket
     * <p>
     */
    public List<String> getAllBuckets() {
        List<String> list = null;
        try {
            final List<Bucket> buckets = minioClient.listBuckets();
            list = new ArrayList<>(buckets.size());
            for (Bucket bucket : buckets) {
                list.add(bucket.name());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 根据bucketName获取信息
     *
     * @param bucketName bucket名称
     * @return
     */
    public String getBucket(String bucketName) throws Exception {
        final Optional<Bucket> first = minioClient.listBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
        String name = null;
        if (first.isPresent()) {
            name = first.get().name();
        }
        return name;
    }

    /**
     * 获取桶中文件名和大小列表
     *
     * @param bucketName bucket名称
     * @param recursive  查询是否递归
     * @return
     */
    public List<Object> getFileList(String bucketName, boolean recursive) {
        if (StringUtils.isEmpty(bucketName)) {
            throw new ServerException(ErrorCode.BUCKET_NAME_NOT_NULL);
        }
        List<Object> items = new ArrayList<>();
        try {
            Iterable<Result<Item>> myObjects = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName).prefix("/2022-08-03/4674a894-abaf-48cb-9ea9-40a4e8560af9/Desktop").recursive(recursive).build());
            Iterator<Result<Item>> iterator = myObjects.iterator();
            String format = "{'fileName':'%s','fileSize':'%s'}";
            for (Result<Item> myObject : myObjects) {
                System.out.println(myObject.get().objectName());
            }
            while (iterator.hasNext()) {
                Item item = iterator.next().get();
                items.add(JSON.parse(String.format(format, item.objectName(), formatFileSize(item.size()))));
//                items.add(JSON.parse(String.format(format, "/".concat("test").concat("/").concat(item.objectName()), formatFileSize(item.size()))));
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.info(e.getMessage());
        }
        items.remove(0);
        return items;
    }


    /**
     * 文件上传
     *
     * @param bucketName 存储桶名称
     * @param file       file
     * @return map
     */
    public Map<String, Object> uploadFile(String bucketName, MultipartFile[] file) {
        if (file == null || file.length == 0) {
            throw new ServerException(ErrorCode.FILE_NAME_NOT_NULL);
        }
        createBucket(bucketName);

        List<String> urlList = new ArrayList<>(file.length);
        for (MultipartFile multipartFile : file) {
            String originFileName = multipartFile.getOriginalFilename();
            if (StringUtils.isBlank(originFileName)) {
                throw new ServerException(ErrorCode.FILE_NAME_NOT_NULL);
            }
            String[] originFileNameArr = originFileName.split("\\.");
            String suffix = originFileNameArr[originFileNameArr.length - 1];
            String newFileName = UUID.randomUUID().toString().replace("-", "").concat(".").concat(suffix);
            urlList.add(String.format("%s%s/%s", minioConfig.getHost(), bucketName, newFileName));
            try {
                // 文件上传
                InputStream in = multipartFile.getInputStream();
                minioClient.putObject(PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(newFileName)
                        .stream(in, multipartFile.getSize(), -1)
                        .contentType(multipartFile.getContentType())
                        .build());
                in.close();
            } catch (Exception e) {
                log.error(e.getMessage());
            }
        }
        Map<String, Object> data = new HashMap<>();
        data.put("bucketName", bucketName);
        data.put("urlList", urlList);
        return data;
    }

    /**
     * 获取上传文件的完整路径
     *
     * @param bucketName 桶名称
     * @param fileName   文件名
     * @return
     */
    public String getPresignedObjectUrl(String bucketName, String fileName) {
        if (StringUtils.isEmpty(bucketName)) {
            throw new ServerException(ErrorCode.BUCKET_NAME_NOT_NULL);
        }
        if (StringUtils.isEmpty(fileName)) {
            throw new ServerException(ErrorCode.FILE_NAME_NOT_NULL);
        }
        // 验证桶是否存在在
        final boolean validationBucket = bucketExists(bucketName);
        if (!validationBucket) {
            throw new ServerException(ErrorCode.BUCKET_NOT_EXIST);
        }
        // 验证文件是否存在
        final boolean validationFileName = doFileNameExist(bucketName, fileName);
        if (!validationFileName) {
            throw new ServerException(ErrorCode.FILE_NOT_EXIST);
        }
        String url = null;
        try {
            // 获取桶和文件的完整路径
            url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                    .bucket(bucketName)
                    .object(fileName)
                    .method(Method.GET)
                    .build());
        } catch (MinioException e) {
            log.error("Error occurred: " + e);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return url;
    }

    /**
     * 创建文件夹或目录
     *
     * @param bucketName 存储桶
     * @param objectName 目录路径
     */
    public Map<String, String> putDirObject(String bucketName, String objectName) throws Exception {
        // 判断桶是否存在
        if (!bucketExists(bucketName)) {
            throw new ServerException(ErrorCode.BUCKET_NAME_NOT_EXIST);
        }
        final ObjectWriteResponse response = minioClient.putObject(
                PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(
                                new ByteArrayInputStream(new byte[]{}), 0, -1)
                        .build());
        Map<String, String> map = new HashMap<>();
        map.put("etag", response.etag());
        map.put("versionId", response.versionId());
        return map;
    }

    /**
     * 判断文件是否存在
     *
     * @param fileName 对象
     * @return true：存在
     */
    public boolean doFileNameExist(String bucketName, String fileName) {
        if (StringUtils.isEmpty(bucketName)) {
            throw new ServerException(ErrorCode.BUCKET_NAME_NOT_NULL);
        }
        if (StringUtils.isEmpty(fileName)) {
            throw new ServerException(ErrorCode.FILE_NAME_NOT_NULL);
        }
        boolean exist = true;
        try {
            minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(fileName).build());
        } catch (Exception e) {
            exist = false;
        }
        return exist;
    }

    /**
     * 文件下载
     *
     * @param response
     * @param fileName
     */
    public void downloadFile(HttpServletResponse response, String bucketName, String fileName) {
        if (StringUtils.isEmpty(bucketName)) {
            throw new ServerException(ErrorCode.BUCKET_NAME_NOT_NULL);
        }
        if (StringUtils.isEmpty(fileName)) {
            throw new ServerException(ErrorCode.FILE_NAME_NOT_NULL);
        }
        // 判断文件是否存在
        final boolean flag = doFileNameExist(bucketName, fileName);
        if (!flag) {
            throw new ServerException(ErrorCode.FILE_NOT_EXIST);
        }
        InputStream in = null;
        try {
            // 获取对象信息
            StatObjectResponse stat = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(fileName).build());
            response.setContentType(stat.contentType());
            response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
            // 文件下载
            in = minioClient.getObject(
                    GetObjectArgs.builder().bucket(bucketName).object(fileName).build());
            IOUtils.copy(in, response.getOutputStream());
        } catch (Exception e) {
            log.error(e.getMessage());
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    log.error(e.getMessage());
                }
            }
        }
    }

    /**
     * 删除文件
     *
     * @param bucketName bucket名称
     * @param fileName   文件名称
     *                   说明：当前方法不能真正删除，需要验证
     */
    public void deleteFile(String bucketName, String fileName) {
        if (StringUtils.isEmpty(bucketName)) {
            throw new ServerException(ErrorCode.BUCKET_NAME_NOT_NULL);
        }
        if (StringUtils.isEmpty(fileName)) {
            throw new ServerException(ErrorCode.FILE_NAME_NOT_NULL);
        }
        try {
            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build());
        } catch (Exception e) {
            log.error(e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 批量文件删除
     *
     * @param bucketName bucket名称
     * @param fileNames  文件名
     */
    public void deleteBatchFile(String bucketName, List<String> fileNames) {
        if (StringUtils.isEmpty(bucketName)) {
            throw new ServerException(ErrorCode.BUCKET_NAME_NOT_NULL);
        }
        if (CollectionUtils.isEmpty(fileNames)) {
            throw new ServerException(ErrorCode.FILE_NAME_NOT_NULL);
        }
        try {
            List<DeleteObject> objects = new LinkedList<>();
            for (String fileName : fileNames) {
                objects.add(new DeleteObject(fileName));
            }
            Iterable<Result<DeleteError>> results =
                    minioClient.removeObjects(
                            RemoveObjectsArgs.builder().bucket(bucketName).objects(objects).build());
            for (Result<DeleteError> result : results) {
                DeleteError error = result.get();
                log.error("Error occurred: " + error);
            }
        } catch (Exception e) {
            log.error("批量删除失败！error:{}", e);
        }
    }

    /**
     * 文件大小
     *
     * @param fileS
     * @return
     */
    private static String formatFileSize(long fileS) {
        DecimalFormat df = new DecimalFormat("#.00");
        String fileSizeString = "";
        String wrongSize = "0B";
        if (fileS == 0) {
            return wrongSize;
        }
        if (fileS < 1024) {
            fileSizeString = df.format((double) fileS) + " B";
        } else if (fileS < 1048576) {
            fileSizeString = df.format((double) fileS / 1024) + " KB";
        } else if (fileS < 1073741824) {
            fileSizeString = df.format((double) fileS / 1048576) + " MB";
        } else {
            fileSizeString = df.format((double) fileS / 1073741824) + " GB";
        }
        return fileSizeString;
    }
}

三、上传文件实战

新建 UploadController，实现上传文件接口。

@Tag(name = "基础接口")
@AllArgsConstructor
@RestController
@RequestMapping("/file")
public class UploadController {
    private final MinioUtils minioUtils;

    @PostMapping("upload")
    @Operation(summary = "上传文件")
    public Result<Map<String, Object>> upload(@RequestParam(defaultValue = "common") String bucketName,
                                   @RequestParam(name = "file", required = false) MultipartFile[] file) {
        return Result.ok(minioUtils.uploadFile(bucketName, file));
    }
}

调用上传文件接口后，系统会根据 bucketName 首先判断 bucket 是否存在，不存在则会开始创建，并且设置成公共读写。然后遍历文件数组，对文件重命名，并且记录下上传后的文件访问 url。最后进行文件上传。

Flobby529
关注
  • 7
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot 集成 MinIO 实现文件上传、下载和删除
weixin_58724261的博客
09-26 801
2.在minio.exe目录下创建start.bat配置启动文件："D:\Java\MinIo"是服务启动时文件存放的位置。MinIO 是一种开源的对象存储服务，它基于云原生架构构建，并提供了高性能、易于扩展和安全的存储解决方案。1.创建一个 Spring Boot 项目。2.配置类，用来连接Minio。4.创建一个 Spring Boot 项目。2.添加依赖，注意依赖版本。3.工具类，用来操作文件。1.yaml配置文件。一.安装和配置 MinIO 服务器。3.双击minio.exe文件启动。
Spring Boot配置MinIO（实现文件上传、读取、下载、删除）
swj81192的博客
04-23 1198
Spring Boot配置MinIO（实现文件上传、读取、下载、删除）
Spring Boot + MinIO 实现文件上传
sunyingboaini的博客
05-17 1139
文件切片上传是指将大文件分割成小的片段，然后通过多个请求并行上传这些片段，最终在服务器端将这些片段合并还原为完整的文件。这种方式有助于规避一些上传过程中的问题，如网络不稳定、上传中断等，并能提高上传速度。通过本文，我们深入了解了如何使用Spring Boot和MinIO实现文件切片上传技术。通过文件切片上传，我们能够提高文件上传的速度，优化用户体验。在实际应用中，我们可以根据需求进行性能优化和功能拓展，使得文件上传系统更加强大和可靠。
springboot整合minio上传文件
weixin_38972910的博客
09-04 2840
springboot整合minio上传文件
springboot实现文件上传到minio
qq_42077317的博客
09-11 839
最近在项目中用的使用minio来上传文件，因此在这里给告诉大家如何实现。4.最后在controller层调用下就可以了。4.编写实现文件上传的Service。（3）在YAML添加minio配置。二、实现文件上传至minio。1.添加相关的maven依赖。（1）首先配置minio属性。2.minio连接配置。
SpringBoot整合MinIO服务器实现文件上传功能
bianmy1的博客
07-21 959
SpringBoot整合MinIO服务器实现文件上传功能
Spring boot整合MinIO客户端实现文件管理
06-27
MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和...Spring boot整合MinIO客户端实现文件管理
java spring boot集成minio文件上传下载
最新发布
05-19
资源内容为java操作minio文件上传下载，也涉及到加密操作，主要是minio的SSE-C模式，具体内容在Sprintboot01ApplicationTests.MinioTest()中。 包含以下内容： //1.测试数据上传 testUploadString(); //2.测试数据...
Spring Boot 集成 MinIO（分布式对象存储系统）
09-27
内容概要：首先带着读者...阅读建议：此资源以开发 Spring Boot 集成 MinIO 学习其原理和内核，不仅是代码编写实现也更注重内容上的需求分析和方案设计，所以在学习的过程要结合这些内容一起来实践，并调试对应的代码。
springboot集成minio实现的文件服务组件(含Vue前端源码).zip
06-24
1. **SpringBoot集成MinIO** - **配置**: 首先，我们需要在SpringBoot的`application.properties`或`application.yml`文件中添加MinIO的相关配置，如访问地址、端口、用户名、密码等。 - **依赖**: 在项目中引入...
springboot集成minio完成自己的分布式文件系统
02-28
通过将MinIO与SpringBoot结合，我们可以轻松地在应用程序中实现文件的上传、下载、管理和共享功能，而无需依赖昂贵的云服务。 首先，我们要理解SpringBoot的核心特性。SpringBoot是Spring框架的一个简化版，它旨在...
Spring Boot轻松整合Minio实现文件上传下载功能【建议收藏】
专注Java后端技术干货、项目源码总结分享，期待您的关注。
03-16 1425
当然，也可以直接访问minio的地址：http://IP地址:9001/xk-admin/1710558001536.jpg。控制台日志重定向到/usr/local/minio/minio.log文件中。测试接口：http://localhost:8099/oss/download。测试接口：http://localhost:8099/oss/upload。测试接口：http://localhost:8099/oss/info。测试接口：http://localhost:8099/oss/url。
SpringBoot3整合Minio实现文件上传
qq_55754838的博客
09-01 1278
本文将零开始讲解minio实现文件上传的过程，包括其中可能会出现的一个问题以及解决办法。
SpringBoot + minio实现文件切片极速上传技术（api调用和minio部署，不涉及底层逻辑））
IT小辉同学
06-02 8795
有朋友让我放下！我想，拿起来就已经很难，那放下大概也不会容易！！！
SpringBoot：整合 Minio 实现文件上传及下载
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
06-24 542
对象存储服务OSS（Object Storage Service）是一种海量、安全、低成本、高可靠的云存储服务，适合存放任意类型的文件。容量和处理能力弹性扩展，多种存储类型供选择，全面优化存储成本，今天我这里主要讲解SpringBoot如何集成MinIO。springboot 集成 minio 非常简单，通过封装 minioclient，可增加代码的灵活性可扩展性，隔离底层存储接口，后续入要更换其他的存储，经过简单的适配即可实现，通过REST提供存储的基础能力接口，可非常简单的被使用。
Springboot集成minio上传文件
人无远虑,必有近忧.
12-18 2509
文章目录1. minio的安装配置2. springboot配置pom.xml请注意版本号：8.2.1版本过高或者过低都可能会报错3. yml 配置文件4. MinioConfig 配置类5. MinioUtils 工具类6. ObjectWriteResponse 上传后返回的对象region() 方法可以获取上传后的服务端图片对应的完整访问路径 1. minio的安装配置 官方网址：https://docs.min.io/docs/minio-quickstart-guide.html 本人
MinIO环境搭建&SpringBoot集成MiniO
withme977的博客
01-24 2410
MinIO兼容亚马逊S3(Simple Storage Service，简单存储服务)云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而且每个对象文件可以是任意大小，从几kb到最大5T不等。以上主要是MiniO业务的一些常规操作，实现类里面的具体路径以及桶需要的操作路径，由于我是docker安装的MiniO服务器，都放在同一台服务器上可能会有影响，路径可以自行处理下！3. 编写MinIO配置类，注册MinioClient客户端的Bean对象。
Minio 教程 - Minio 分片上传文件putObject接口流程源码分析
qq_33240556的博客
05-14 622
分片上传（也称为多部分上传）是一种将大文件分割成多个小块（分片），独立上传每个分片，最后再由客户端通知服务器合并这些分片成为完整文件的上传策略。这种方式特别适用于网络环境不稳定或文件尺寸超过单个请求限制的场景。
spring boot 集成minio实现文件批量上传
04-22
可以使用Minio Java客户端来实现Spring Boot与Minio的集成，下面是一个基本的步骤： 1.引入Minio Java客户端的依赖： ...以上就是Spring Boot集成Minio实现文件批量上传的过程，希望对你有帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值