对象存储MinIO(实现文件上传读取下载删除)

Posted ZHOU_VIP

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了对象存储MinIO(实现文件上传读取下载删除)相关的知识,希望对你有一定的参考价值。

一、 MinIO

        MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服

务接口,非常适合于存储大容量非结构化的数据,例如图片、视频、日志文件、备份数据和容器/

虚拟机镜像等,而一个对象文件可以是任意大小,从几kb到最大5T不等。

        MinIO是一个非常轻量的服务,可以很简单的和其他应用的结合,类似 NodeJS, Redis 或者

mysql

二、 MinIO安装和启动

       由于MinIO是一个单独的服务器,需要单独部署,有关MinIO在Windows系统上的使用请查看

以下博客。

window10安装minio_angelasp的博客-CSDN博客_win10 安装minio

三、 pom.xml(maven依赖文件)

<!-- SpringBoot Web容器 -->
<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
       <groupId>io.minio</groupId>
       <artifactId>minio</artifactId>
       <version>8.3.4</version>
</dependency>

 四、 applicatin.properties(配置文件)

# 设置单个文件大小
spring.servlet.multipart.max-file-size= 50MB
#minio文件服务器配置
s3.url=http://localhost:9000
s3.accessKey=admin
s3.secretKey=admin123
s3.bucketName=test

五、 编写Java业务类

minio涉及到的方法有:判断存储桶是否存在,创建存储桶,上传文件,读取文件、下载文件,删

除文件等操作

1、StorageProperty 存储属性类:

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
 
 
@Data
@Component
@ConfigurationProperties(prefix = "s3")
public class StorageProperty 
    private String url;
    private String accessKey;
    private String secretKey;
//    private long callTimeOut = 60000;
//    private long readTimeOut = 300000;

2、minio配置类: 

import io.minio.BucketExistsArgs;
import io.minio.MinioClient;
import io.minio.messages.Bucket;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
 
import javax.annotation.PostConstruct;
import java.util.List;
 

@Slf4j
@Component
@Configuration
public class MinioClientConfig 
 
    @Autowired
    private StorageProperty storageProperty;
 
    private static MinioClient minioClient;
 
 
    /**
     * @description: 获取minioClient
     * @date 2021/6/22 16:55
     * @return io.minio.MinioClient
     */
    public static MinioClient getMinioClient()
        return minioClient;
    
 
    /**
     * 判断 bucket是否存在
     *
     * @param bucketName:
     *            桶名
     * @return: boolean
     * @date : 2020/8/16 20:53
     */
    @SneakyThrows(Exception.class)
    public static boolean bucketExists(String bucketName) 
        return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
    
 
 
    /**
     * 获取全部bucket
     *
     * @param :
     * @return: java.util.List<io.minio.messages.Bucket>
     * @date : 2020/8/16 23:28
     */
    @SneakyThrows(Exception.class)
    public static List<Bucket> getAllBuckets() 
        return minioClient.listBuckets();
    
 
    /**
     * 初始化minio配置
     *
     * @param :
     * @return: void
     * @date : 2020/8/16 20:56
     */
    @PostConstruct
    public void init() 
        try 
            minioClient = MinioClient.builder()
                    .endpoint(storageProperty.getUrl())
                    .credentials(storageProperty.getAccessKey(), storageProperty.getSecretKey())
                    .build();
         catch (Exception e) 
            e.printStackTrace();
            log.error("初始化minio配置异常: 【】", e.fillInStackTrace());
        
    
 

3、minio工具类 

import io.minio.*;
 
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
 
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.Map;
 

@Slf4j
@Component
public class MinioUtil 
    
    /**
     * Minio文件上传
     *
     * @param file       文件实体
     * @param fileName   修饰过的文件名 非源文件名
     * @param bucketName 所存文件夹(桶名)
     * @return
     */
    public ResultEntity<Map<String, Object>> minioUpload(MultipartFile file, String fileName, String bucketName) 
        ResultEntity<Map<String, Object>> resultEntity = new ResultEntity();
        try 
            MinioClient minioClient = MinioClientConfig.getMinioClient();
            // fileName为空,说明要使用源文件名上传
            if (fileName == null) 
                fileName = file.getOriginalFilename();
                fileName = fileName.replaceAll(" ", "_");
            
            InputStream inputStream = file.getInputStream();
            PutObjectArgs objectArgs = PutObjectArgs.builder().bucket(bucketName).object(fileName)
                    .stream(inputStream, file.getSize(), -1).contentType(file.getContentType()).build();
            //文件名称相同会覆盖
            minioClient.putObject(objectArgs);
            return resultEntity;
         catch (Exception e) 
            e.printStackTrace();
            return null;
        
    
 
 
    /**
     * 检查存储桶是否存在
     *
     * @param bucketName 存储桶名称
     * @return
     */
    public boolean bucketExists(String bucketName) 
        boolean flag = false;
        try 
            flag = MinioClientConfig.bucketExists(bucketName);
            if (flag) 
                return true;
            
         catch (Exception e) 
            e.printStackTrace();
            return false;
        
        return false;
    
 
    /**
     * 获取文件流
     *
     * @param fileName   文件名
     * @param bucketName 桶名(文件夹)
     * @return
     */
    public InputStream getFileInputStream(String fileName, String bucketName) 
        try 
            MinioClient minioClient = MinioClientConfig.getMinioClient();
            return minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileName).build());
         catch (Exception e) 
            e.printStackTrace();
            log.error(e.getMessage());
        
        return null;
    
 
 
    /**
     * @param bucketName:
     * @author
     * @description: 创建桶
     * @date 2022/8/16 14:36
     */
    public void createBucketName(String bucketName) 
        try 
            if (StringUtils.isBlank(bucketName)) 
                return;
            
            MinioClient minioClient = MinioClientConfig.getMinioClient();
            boolean isExist = MinioClientConfig.bucketExists(bucketName);
            if (isExist) 
                log.info("Bucket  already exists.", bucketName);
             else 
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            
         catch (Exception e) 
            e.printStackTrace();
            log.error(e.getMessage());
        
    
    /**
     * 下载文件
     *
     * @param originalName 文件路径
     */
    public InputStream downloadFile(String bucketName, String originalName, HttpServletResponse response) 
        try 
            MinioClient minioClient = MinioClientConfig.getMinioClient();
            InputStream file = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(originalName).build());
            String filename = new String(originalName.getBytes("ISO8859-1"), StandardCharsets.UTF_8);
            if (StringUtils.isNotBlank(originalName)) 
                filename = originalName;
            
            response.setHeader("Content-Disposition", "attachment;filename=" + filename);
            ServletOutputStream servletOutputStream = response.getOutputStream();
            int len;
            byte[] buffer = new byte[1024];
            while ((len = file.read(buffer)) > 0) 
                servletOutputStream.write(buffer, 0, len);
            
            servletOutputStream.flush();
            file.close();
            servletOutputStream.close();
            return file;
         catch (Exception e) 
            e.printStackTrace();
            return null;
        
    
 
    /**
     * @param bucketName:
     * @description: 删除桶
     * @date 2022/8/16 14:36
     */
    public void deleteBucketName(String bucketName) 
        try 
            if (StringUtils.isBlank(bucketName)) 
                return;
            
            MinioClient minioClient = MinioClientConfig.getMinioClient();
            boolean isExist = MinioClientConfig.bucketExists(bucketName);
            if (isExist) 
                minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
            
         catch (Exception e) 
            e.printStackTrace();
            log.error(e.getMessage());
        
    
    /**
     * @param bucketName:
     * @description: 删除桶下面所有文件
     * @date 2022/8/16 14:36
     */
    public void deleteBucketFile(String bucketName) 
        try 
            if (StringUtils.isBlank(bucketName)) 
                return;
            
            MinioClient minioClient = MinioClientConfig.getMinioClient();
            boolean isExist = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            if (isExist) 
                minioClient.deleteBucketEncryption(DeleteBucketEncryptionArgs.builder().bucket(bucketName).build());
            
         catch (Exception e) 
            e.printStackTrace();
            log.error(e.getMessage());
        
    
 
    /**
     * 根据文件路径得到预览文件绝对地址
     *
     * @param bucketName
     * @param fileName
     * @return
     */
    public String getPreviewFileUrl(String bucketName, String fileName) 
        try 
            MinioClient minioClient = MinioClientConfig.getMinioClient();
            return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().bucket(bucketName).object(fileName).build());
         catch (Exception e) 
            e.printStackTrace();
            return "";
        
    

 六、 MinIoController

文件上传、文件读取、文件下载、文件删除接口如下:


@RestController
@RequestMapping("/minio")
public class MinIoController extends BaseController 
 
    MinioUtil minioUtil = new MinioUtil();
 
    /**
     * 上传文件
     * @param file
     * @return
     */
    @PostMapping("/uploadFile")
    public AjaxResult uploadFile(@RequestBody MultipartFile file) 
        MinioClient minioClient = MinioClientConfig.getMinioClient();
        if (minioClient == null) 
            return AjaxResult.error("连接MinIO服务器失败", null);
        
        ResultEntity<Map<String, Object>> result = minioUtil.minioUpload(file, "", "data-enpower");
        if (result.getCode() == 0) 
            return AjaxResult.success("上传成功");
         else 
            return AjaxResult.error("上传错误!!!");
        
    
 
    /**
     * 获取文件预览地址
     * @param fileName
     * @return
     */
    @RequestMapping("/getRedFile")
    public AjaxResult getRedFile(@RequestBody String fileName) 
        MinioClient minioClient = MinioClientConfig.getMinioClient();
        if (minioClient == null) 
            return AjaxResult.error("连接MinIO服务器失败", null);
        
        String url = minioUtil.getPreviewFileUrl("data-enpower",fileName);
        return AjaxResult.success(url);
    
 
    /**
     * 下载文件
     * @param fileName
     * @param response
     * @return
     */
    @RequestMapping("/downloadFile")
    public String downloadFile(@RequestParam String fileName, HttpServletResponse response) 
        MinioClient minioClient = MinioClientConfig.getMinioClient();
        if (minioClient == null) 
            return "连接MinIO服务器失败";
        
        return minioUtil.downloadFile("data-enpower",fileName,response) != null ? "下载成功" : "下载失败";
    
 
    /**
     * 删除文件
     *
     * @param fileName 文件路径
     * @return
     */
    @PostMapping("/deleteFile")
    public String deleteFile(String fileName) 
        MinioClient minioClient = MinioClientConfig.getMinioClient();
        if (minioClient == null) 
            return "连接MinIO服务器失败";
        
        boolean flag = minioUtil.deleteFile("data-enpower",fileName);
        return flag == true ? "删除成功" : "删除失败";
    
 
 

对象存储MinIO基本用法

对象存储服务MinIO的基本用法 

https://www.cnblogs.com/hackyle/p/minio-demo.html

 

Java操作MinIO实现文件的上传和删除。

 文章解决的问题:将本地Java项目resources目录下的一个PNG图片上传到MinIO,然后将上传的图片删除。

目录

一、MinIO的安装:

​二、安装与开启服务:

 三、MinIO的使用:

四、Java操作MinIO:


一、MinIO的安装:

官网地址:MinIO | High Performance, Kubernetes Native Object Storage

选择下载win serve版本即可:

 二、安装与开启服务:

1、找到下载的目录,并将那个.exe文件移动到你想安装的位置。

2、然后进入该目录的CMD命令行终端。

输入以下命令开启服务: 

 .\\minio.exe server exe文件的地址

  //这是我安装的位置
 .\\minio.exe server D:\\application\\MinIO

启动成功之后:

  输入对应网址打开管理端页面:

 三、MinIO的使用:

1、创建一个存储桶:

2、对新建的桶进行两个修改:

修改的目的:

其他应用能够仅通过URL就能访问图片,并且图片访问期限为永久。(如果不做修改,不能通过URL路径直接访问图片,并且提供的路径有时间限制,一段时间之后就不能访问了)

 

四、Java操作MinIO:

Maven依赖:

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

包括了对上传与删除操作:

import io.minio.*;
import io.minio.errors.*;
import lombok.Data;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.Date;

@Data
public class MinIO 
    private String address; //IP地址
    private String userName; //用户名
    private String password; //密码
    private MinioClient minioClient;  //操作对象

    MinIO(String address, String userName, String password) 
        this.address = address;
        this.userName = userName;
        this.password = password;

    

    //获取操作对象:
    public MinioClient getMinioClient() 
        if (this.minioClient == null) 
            this.minioClient = MinioClient.builder()
                    .endpoint(this.getAddress())
                    .credentials(this.getUserName(), this.getPassword())
                    .build();
        
        return this.minioClient;
    

    //上传文件:
    public String upload(MultipartFile multipartFile, String bucketName) throws Exception 
        //一、设置文件存放的路径信息
        String fileName = multipartFile.getName();        //获取文件名称:
        String timeRandom = String.valueOf(System.currentTimeMillis());        //获取当前时间戳:
        fileName = timeRandom + "_" + fileName;         //拼接文件名:
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  //格式化当前日期:
        String objectName = sdf.format(new Date()) + "/" + fileName;       //最后存储的路径:  格式为:时间/文件

        //二、上传文件
        this.getMinioClient().putObject(PutObjectArgs.builder().
                bucket(bucketName) //桶名称
                .object(objectName) //路径
                //以下为默认配置:
                .stream(multipartFile.getInputStream(), multipartFile.getSize(), -1)
                .contentType(multipartFile.getContentType())
                .build());

        //三、访问路径:
        return this.address + "/" + bucketName + "/" + objectName;
    

    //删除文件:
    public   void delete(String bucketName,String fileName) 
        /**
         * String bucketName = "test2";
         * String fileName = "/2023-04-07/16808560218465670_img.png";
         * address+bucketName+fileName 就是访问路径,删除需要后两个参数。
         */
        try 
            this.getMinioClient().removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build());
         catch (Exception e) 
            System.out.println("删除失败");
        
        System.out.println("删除成功");
    



    //查询某个桶是否存在:
    public Boolean isExit(String bucketName) throws Exception 
        boolean found =
             this.getMinioClient().bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        if (found) 
            System.out.println("存储桶存在!");
            return true;
         else 
            System.out.println("存储桶不存在!");
            return false;
        
    



Main函数调用:

public class Main 
    public static void main(String[] args) throws Exception 
        MinIO minIO = new MinIO("http://127.0.0.1:9000","minioadmin","minioadmin");
        String bucket = "test";

        //一、上传文件:
        //将file转化为MultipartFile (图片在项目的resources目录下,必须将文件转化为为MultipartFile类型)
        File file = new File("src/main/resources/img.png");
        FileInputStream fileInputStream = new FileInputStream(file);
        MultipartFile multipartFile = new MockMultipartFile(file.getName(), file.getName(),
                MediaType.IMAGE_PNG_VALUE //PNG类型的图片,所以用这个枚举。点击MediaType有对应类型
                , fileInputStream);

        String url = minIO.upload(multipartFile, bucket);//上传
        System.out.println("上传之后的URL为:"+url);

        //二、删除刚刚上传的图片:
        String fileName = "/2023-04-07/1680857898025_img.png";
        minIO.delete(bucket,fileName);

    

 执行结果:

以上是关于对象存储MinIO(实现文件上传读取下载删除)的主要内容,如果未能解决你的问题,请参考以下文章

Java编程系列Minio实现文件上传下载

Java编程系列Minio实现文件上传下载

高性能云原生数据对象存储MinIO实战-上

高可用对象存储实战使用Python操作Minio存储桶

Spring Boot 整合 Minio 实现文件上传

Minio 整合springboot 开发 实现文件上传