SpringBoot集成Minio实战详解

这篇具有很好参考价值的文章主要介绍了SpringBoot集成Minio实战详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Minio简介

介绍高性能分布式存储文件服务Minio:Minio是基于Go语言编写的对象存储服务,适合于存储大容量非结构化的数据,例如图片、音频、视频、日志文件、备份数据和容器/虚拟机镜像等,而一个对象文件可以是任意大小,从几kb到最大5T不等。区别于分布式存储系统,minio的特色在于简单、轻量级,对开发者友好!!!,认为存储应该是一个开发问题而不是一个运维问题。

1.安装minio

可以到官网去下载
链接: https://www.minio.org.cn/download.shtml
minio springboot,java中间件,spring boot,java,docker,后端
本文采用的是使用主流的安装方式:docker安装(docker的教程大家可以访问b站的教程进行学习,本文不作重点讲解)
链接: https://blog.csdn.net/ouyang_zhen/article/details/118961684
linux系统中敲入如下命令

docker search minio
docker pull minio/minio
docker run -d -p 9000:9000 --name=minio --restart=always -e "MINIO_ROOT_USER=admin" -e "MINIO_ROOT_PASSWORD=admin123456" -v /home/data:/data -v /home/config:/root/.minio  minio/minio server /data --console-address ":9000" --address ":9090"
docker logs -f containerid

或者使用docker-compose启动
通过配置docker-compose.yml文件管理容器,通过docker-compose up -d 启动容器
docker-compose.yml文件
这里的9100是配置访问minio自带的web管理后台,9090是配置的服务器

version: "3.1"
services:
  minio:
    image: minio/minio:latest
    container_name: minio
    ports:
      - "9100:9000"
      - "9090:9090"
    volumes:
      - "./data:/data"
    environment:
      MINIO_ACCESS_KEY: "root"
      MINIO_SECRET_KEY: "12345678"
    command: server /data --console-address=":9000" --address=":9090"
    logging:
      driver: "json-file"
      options:
        max-size: "1m"

当出现如下图所示即代码运行成功,通过宿主机ip:9000访问,输入命令里的账号/密码登录即可:
minio springboot,java中间件,spring boot,java,docker,后端
启动成功后访问 ip+9000(你运行的端口号) 如下图所示例,输入你在命令行里的用户名和我密码

minio springboot,java中间件,spring boot,java,docker,后端

2.minio Ui界面的简单使用

minio springboot,java中间件,spring boot,java,docker,后端

3.minio结合springboot

项目目录结构:
minio springboot,java中间件,spring boot,java,docker,后端

修改配置文件
1,yml文件配置
2,minio配置类并注入容器进行管理
3,封装minio操作服务器的API的工具类,项目中封装了单文件上传、下载、删除、查看功能,桶的创建等
公司具体的存储业务,在次基础上根据公司业务来自行扩展
4,编写controller层,用postman进行简单的测试(测试类型:文本、文档、表格、音频、视频、图片)
yml配置:

spring:
  # 配置文件上传大小限制
  servlet:
    multipart:
      max-file-size: 200MB
      max-request-size: 200MB
minio:
  server: http://120.76.159.196
  port: 9090
  accessKey: root
  secretKey: 12345678
  bucket: test
  urlprefix: /minio/



配置类:

/**
 * @Author xiaozq
 * @Date 2022/11/17 9:54
 * <p>@Description: 注意:这里不能用@Data,需手动写gitter,setter
 * reason:与@ConfigurationProperties一起用的时候,配置文件的值不能赋值给对应类属性,属性值均为null</p>
 */
@Configuration
@ConfigurationProperties(prefix = "minio")
public class MinioConfig {

    private String server;

    private int port;

    private String accessKey;

    private String secretKey;

    // 桶名
    private String bucket;

    // 统一前缀
    private String urlPrefix;

    /**
     * 创建minio连接对象
     * @return
     */
    @Bean
    public MinioClient minioClient(){
        return  MinioClient.builder()
                           .endpoint(server,port,false)
                           .credentials(accessKey,secretKey)
                           .build();
    }

    public void setServer(String server) {
        this.server = server;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public void setAccessKey(String accessKey) {
        this.accessKey = accessKey;
    }

    public void setSecretKey(String secretKey) {
        this.secretKey = secretKey;
    }

    public void setBucket(String bucket) {
        this.bucket = bucket;
    }


    public void setUrlPrefix(String urlPrefix) { this.urlPrefix = urlPrefix; }

    public String getUrlPrefix() {
        return urlPrefix;
    }

    public String getServer() {
        return server;
    }

    public int getPort() {
        return port;
    }

    public String getAccessKey() {
        return accessKey;
    }

    public String getSecretKey() {
        return secretKey;
    }

    public String getBucket() {
        return bucket;
    }
}



自定义封装操作minio的api工具类:

**
 * @Author xiaozq
 * @Date 2022/8/5 10:42
 * <p>@Description:</p>
 */
@Component
public class MinioTemplate {

    @Autowired
    private MinioClient minioClient;

    @Value("${minio.bucket}")
    public String bucketName;

    @Value("${minio.urlprefix}")
    public String urlprefix;

    /**
     * 判断bucket是否存在,不存在则创建
     * @param name
     */
    public void existBucket(String name){
        try {
            boolean exist = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            if(!exist){
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(name).build());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 创建存储bucket
     * @param bucketName 存储bucket名称
     * @return Boolean
     */
    public Boolean makeBucket(String bucketName) {
        try {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 删除存储bucket
     * @param bucketName 存储bucket名称
     * @return Boolean
     */
    public Boolean removeBucket(String bucketName) {
        try {
            minioClient.removeBucket(RemoveBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 文件上传
     * @param file
     * @return
     */
    public Map<String, String> upload(MultipartFile file) {

        String filename = FileUtils.extractUploadFilename(file);
        try {
            InputStream inputStream = file.getInputStream();
            // 上传到minio服务器
            minioClient.putObject(PutObjectArgs.builder()
                    .bucket(this.bucketName)
                    .object(filename)
                    .stream(inputStream, -1L, 10485760L)
                    .build());
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 返回地址
        Map<String,String > resultMap = new HashMap<>();
        resultMap.put("url",filename);
        return  resultMap;
    }

    /**
     * 文件下载
     * @param fileName 文件名
     * @param delete   是否删除
     * @throws IOException
     */
    public void fileDownload(@RequestParam(name = "fileName") String fileName,
                             @RequestParam(defaultValue = "false") Boolean delete,
                             HttpServletResponse response) {

            InputStream inputStream   = null;
            OutputStream outputStream = null;
            try {
                if (StringUtils.isBlank(fileName)) {
                response.setHeader("Content-type", "text/html;charset=UTF-8");
                String data = "文件下载失败";
                OutputStream ps = response.getOutputStream();
                ps.write(data.getBytes("UTF-8"));
                return;
            }

            outputStream = response.getOutputStream();
            // 获取文件对象
            inputStream =minioClient.getObject(GetObjectArgs.builder().bucket(this.bucketName).object(fileName).build());
            byte buf[] = new byte[1024];
            int length = 0;
            response.reset();
            response.setHeader("Content-Disposition", "attachment;filename=" +
                    URLEncoder.encode(fileName.substring(fileName.lastIndexOf("/") + 1), "UTF-8"));
            response.setContentType("application/octet-stream");
            response.setCharacterEncoding("UTF-8");
            // 输出文件
            while ((length = inputStream.read(buf)) > 0) {
                outputStream.write(buf, 0, length);
            }
            inputStream.close();
            // 判断:下载后是否同时删除minio上的存储文件
            if (BooleanUtils.isTrue(delete)) {
                minioClient.removeObject(RemoveObjectArgs.builder().bucket(this.bucketName).object(fileName).build());
            }
        } catch (Throwable ex) {
            response.setHeader("Content-type", "text/html;charset=UTF-8");
            String data = "文件下载失败";
            try {
                OutputStream ps = response.getOutputStream();
                ps.write(data.getBytes("UTF-8"));
            }catch (IOException e){
                e.printStackTrace();
            }
        } finally {
            try {
            outputStream.close();
            if (inputStream != null) {
                    inputStream.close();
                }}catch (IOException e){
                e.printStackTrace();
            }
        }
    }


    /**
     * 查看文件对象
     * @param bucketName 存储bucket名称
     * @return 存储bucket内文件对象信息
     */
    public List<ObjectItem> listObjects(String bucketName) {
        Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName).build());
        List<ObjectItem> objectItems = new ArrayList<>();
        try {
            for (Result<Item> result : results) {
                Item item = result.get();

                ObjectItem objectItem = new ObjectItem();
                objectItem.setObjectName(item.objectName());
                objectItem.setSize(item.size());

                objectItems.add(objectItem);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return objectItems;
    }

    /**
     * 批量删除文件对象
     * @param bucketName 存储bucket名称
     * @param objects 对象名称集合
     */
    public Map<String, String> removeObjects(String bucketName, List<String> objects) {
        Map<String,String > resultMap = new HashMap<>();
        List<DeleteObject> dos = objects.stream().map(e -> new DeleteObject(e)).collect(Collectors.toList());
        try {
             minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(dos).build());
            resultMap.put("mes","删除成功");
        }catch (Exception e){
            e.printStackTrace();
            resultMap.put("mes","网络异常,删除失败");
        }
        return resultMap;
    }

}




上传文件名替换工具类:

public class FileUtils {

    /**
     * 编码文件名
     * 日期路径 + UUID
     * 示例:fileName=2022/11/18/统计报表1668758006562.txt
     */
    public static final String extractUploadFilename(MultipartFile file)
    {
        String fileName = file.getOriginalFilename();
        // 注意,这里需要加上 \\ 将 特殊字符 . 转意 \\. ,否则异常
        String[] fileArray = fileName.split("\\.");
        fileName = datePath() + "/" + fileArray[0]+System.currentTimeMillis()+"."+fileArray[1];
        return fileName;
    }

    /**
     * 日期路径 即年/月/日 如2018/08/08
     */
    public static final String datePath() {
        Date now = new Date();
        return DateFormatUtils.format(now, "yyyy/MM/dd");
    }
}



controller层:

@RestController
public class MinioController {

    @Autowired
    private MinioTemplate minioTemplate;

    @Value("${minio.server}")
    private String server;

    @Value("${minio.port}")
    private Integer port;

    @Value("${minio.bucket}")
    private String bucket;


    /**
     * 单文件上传
     * @param file 文件
     * @return
     */
    @PostMapping("/uploadone")
    public Object uploadOne(MultipartFile file) {
        return minioTemplate.upload(file);
    }

    /**
     *  单文件下载
     * @param fileName 文件
     * @param delete 下载完后是否删除, 请谨慎传参
     */
    @GetMapping("/download")
    public void download(@RequestParam(value = "fileName") String fileName,
                         @RequestParam(defaultValue = "false")Boolean delete, HttpServletResponse response) {
        minioTemplate.fileDownload(fileName,delete,response);
    }

    /**
     * 查看存储的文件列表
     * @param bucket 桶
     * @return
     */
    @GetMapping("/list")
    public  Object fileList(@RequestParam(value = "bucket") String bucket) {
        return minioTemplate.listObjects(bucket);
    }

    /**
     * 删除文件
     * @param bucket 桶
     * @param list 文件名列表
     * @return
     */
    @DeleteMapping ("/remove")
    public  Object fileremove(@RequestParam String bucket,@RequestParam List<String> list) {
        return minioTemplate.removeObjects(bucket,list);
    }

}



接下来就是用postman测试,非常便利:测试存储文档、表格、日志、视频、音频、图片等上传、下载:
minio springboot,java中间件,spring boot,java,docker,后端
以上就是minio入门的所有内容
更多可参考官网文档:链接: https://min.io/docs/minio/kubernetes/upstream/
如果对源码感兴趣可以访问:链接: https://github.com/minio/minio文章来源地址https://www.toymoban.com/news/detail-776666.html

到了这里,关于SpringBoot集成Minio实战详解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Minio入门系列【5】JAVA集成Minio之存储桶操作API使用详解

    官方文档:https://min.io/docs/minio/kubernetes/upstream/index.html?ref=docs-redirect SDK:https://github.com/minio/minio-java Minio 提供了多种语言的SDK,比如java、go、python等。JAVA开发平台可以选择JS和java SDK,也就是前端和后端都可以直接集成minio。 每个OSS的用户都会用到上传服务。Web端常见的上传

    2024年02月05日
    浏览(49)
  • SpringBoot+MinIO实现minio部署和使用

    Minio是一个go编写基于Apache License v2.0开源协议的对象存储系统,是为海量数据存储、人工智能、大数据分析而设计,它完全兼容Amazon S3接口,十分符合存储大容量的非结构化数据从几十kb到最大5T不等。是一个小而美的开源分布式存储软件。 特点 简单、可靠:Minio采用简单可靠

    2024年02月13日
    浏览(34)
  • MinIO安装配置访问以及SpringBoot整合MinIO

    详细介绍了如何在CentOS7和Windows系统上安装配置MinIO对象存储服务,并提供了SpringBoot项目与MinIO整合的步骤,帮助开发者快速实现文件的上传、下载与管理。

    2024年02月04日
    浏览(49)
  • springboot整合minio

    minio是对象存储服务。 它基于Apache License 开源协议,兼容Amazon S3云存储接口。适合存储非结构化数据,如图片,音频,视频,日志等。对象文件最大可以达到5TB。 优点有高性能,可扩展,操作简单,有图形化操作界面,读写性能优异等。 minio的安装也很简单,有兴趣的可以去

    2024年02月07日
    浏览(41)
  • SpringBoot3整合MinIO

    配套视频:SpringBoot3整合MinIO MinIO项目应用可参考视频 【SpringBoot3+Vue3+Uniapp小程序项目实战】 MinIO 是一个基于 Apache License v2.0 开源协议的对象存储服务。它兼容亚马逊 S3 云存储服务接口,非常适合于存储大容量非结构化的数据,例如图片、视频、日志文件、备份数据和容器

    2024年02月21日
    浏览(53)
  • Minio安装及整合SpringBoot

    一. MinIO概述 官网地址:https://minio.org.cn MinIO是一款基于Apache License v2.0开源协议的分布式文件系统(或者叫对象存储服务),可以做为云存储的解决方案用来保存海量的图片、视频、文档等。由于采用Golang实现,服务端可以工作在Windows、Linux、 OS X和FreeBSD上。配置简单,基本

    2024年01月19日
    浏览(40)
  • springboot实现文件上传到minio

    一、前言 最近在项目中用的使用minio来上传文件,因此在这里给告诉大家如何实现 二、实现文件上传至minio 1.添加相关的maven依赖 2.minio连接配置 (1)首先配置minio属性 (2)接着配置minio连接,代码如下: (3)在YAML添加minio配置 3.定义minio工具类,代码如下: 4.编写实现文件

    2024年02月09日
    浏览(39)
  • springboot 本地/minio 附件下载优化

    本地上传大文件内存溢出 Direct buffer memory 附件下载服务端传流给前端需要将流缓存完毕才可以下载,导致大文件下载系统崩溃 后端服务采用nio本地上传到服务器指定目录,通过nginx代理提供下载 Java8出现了NIO,缓存,通道,选择器。在 写NIO程序的时候,经常使用ByteBuffer来读

    2024年02月07日
    浏览(40)
  • springboot实现minio文件分片上传

    在Spring Boot中实现MinIO的文件分片上传涉及到几个关键步骤。MinIO是一个高性能的分布式对象存储服务,它兼容Amazon S3的API。分片上传主要用于上传大文件,将大文件分成多个部分,分别上传,最后再将这些部分合并成一个完整的文件。这样做的好处是提高了上传的可靠性,并

    2024年01月17日
    浏览(60)
  • SpringBoot整合Minio的详细步骤

    小伙伴们好,欢迎关注,一起学习,无限进步 minio 是对象存储服务。它基于 Apache License 开源协议,兼容 Amazon S3 云存储接口。适合存储非结构化数据,如图片,音频,视频,日志等。对象文件最大可以达到 5TB。 优点有高性能,可扩展,操作简单,有图形化操作界面,读写性

    2024年04月26日
    浏览(34)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包