MinIO 是 GlusterFS 创始人之一Anand Babu Periasamy 发布新的开源项目。Minio兼容Amason 的S3 分布式对象存储项目,采用Colang实现，客户端支持java,python,javascript,Golang 语言。
官网：https://www.minio.org.cn/
Minio 可以作为云存储的解决方案用来保存海量的图片，文档，视频。由于采用Golang实现，服务端可以工作在windows ，linux,osx 和 FreeBSD上。安装和配置十分简单，基本是复制可执行程序，单行命令就可以运行起来。minio 还可以通过容器部署以及部署到k8s 集群。

安装

第一步：下载，地址：https://www.minio.org.cn/download.shtml#/windows

image.png
第二步：在本地硬盘中并新建一个minio文件夹：
image.png

在minio.exe 文件夹的路径处输入cmd 进入命令行界面（该exe 文件不能双击运行），输入命令： minio.exe server D:\Program Files\minio\minio

image.png

Minio 部署使用默认的root 凭据开始RootUser 和 RootPass都为minioadmin。可以使用Minio控制台测试部署，这是一个内置在MinIo Server 中的嵌入式基于web的对象浏览器。将主机上运行的Web浏览器指向http://127.0.0.1:9000 并使用root 凭据登录。你可以使用浏览器创建存储桶，上传对象和浏览Minio 服务器内容

minio启动成功，浏览器登陆：http://127.0.0.1:9000/login，即可进入minio界面

image.png

默认的RootUser和RootPass，都为minioadmin，进入MinIO控制台。如下图所示：

image.png

创建完成后再之前新建的minioData 文件夹下就可以看到我们创建的桶文件夹

使用：

第一步: 创建 bucket。点击BUckets--->createBucket

image.png
image.png image.png image.png
image.png image.png

上传后的文件我们要查看的话 选中对应的文件点击右边的Share生成链接然后就可以用别的浏览器进行访问了,但是这样有个问题,只有7天的有效期,如果我们想将文件暴露出去,而不是通过分享这个url来进行访问呢?

那么我们应该直接访问Minio的ip+端口/桶名称/文件名

也就是 http://127.0.0.1:9000/wegosimple/1.jpg 这样去访问

image.png

但是页面是这样提示的,因为我们没有权限直接这样去访问这个资源

我们可以给他添加权限,首先进入Manager

image.png image.png image.png

再去访问的时候就可以直接访问了

image.png

集成Java
好了 这个是在windows中使用 使用的 那么我们要如何在java中进行集成呢?

我这里使用了maven来操作

首先让我们导入jar

 <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>7.0.2</version>
        </dependency>
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>3.14.9</version>
            <scope>compile</scope>
        </dependency>

yml文件配置

# Tomcat
server:
  port: 9100
 
# 自定义配置项，方便在代码中使用
minio:
  endpoint: 127.0.0.1
  port: 9001
  accessKey: minioadmin
  secretKey: minioadmin
  bucketName: upload
spring:
  servlet:
    multipart:
      max-file-size: 10000MB
      max-request-size: 20000MB

编写配置类

package com.taotao.test2.config;

import io.minio.MinioClient;
import io.minio.errors.InvalidEndpointException;
import io.minio.errors.InvalidPortException;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @program: test2
 * @ClassName MinioConfig
 * @description: 编写配置类
 * @author: wangjin
 * @create: 2023-11-03 17:23
 * @Version 1.0
 **/
@Data
@Configuration
//加载yml文件中以minio开头的配置项
@ConfigurationProperties(prefix = "minio")
public class MinioConfig {
    /*会自动的对应配置项中对应的key*/
    private String endpoint;//minio.endpoint
    private String accessKey;
    private String secretKey;
    private Integer port;

    @Bean
    public MinioClient getMinioClient() throws InvalidPortException, InvalidEndpointException {

        MinioClient minioClient = new MinioClient(getEndpoint(), getPort(), getAccessKey(), getSecretKey(), false);
        return minioClient;
    }

}

编写工具类

package com.taotao.test2.config;
 
import io.minio.MinioClient;
import io.minio.ObjectStat;
import io.minio.PutObjectOptions;
import io.minio.Result;
import io.minio.errors.*;
import io.minio.messages.DeleteError;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
 
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URLEncoder;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
 
@Component
public class MinioClientUtil {
    @Value("${minio.bucketName}")
    private String bucketName;
    @Resource
    private MinioClient minioClient;
 
    private static final int DEFAULT_EXPIRY_TIME = 7 * 24 * 3600;
 
    /**
     * 检查存储桶是否存在
     */
    public boolean bucketExists(String bucketName) throws InvalidKeyException, ErrorResponseException,
            IllegalArgumentException, InsufficientDataException, InternalException, InvalidBucketNameException,
            InvalidResponseException, NoSuchAlgorithmException, XmlParserException, IOException {
        boolean flag = minioClient.bucketExists(this.bucketName);
        if (flag) return true;
        return false;
    }
 
    /**
     * 通过InputStream上传对象
     *
     * @param objectName 存储桶里的对象名称
     * @param stream     要上传的流 (文件的流)
     */
    public boolean putObject(String objectName, InputStream stream) throws Exception {
 
        //判断 桶是否存在
        boolean flag = bucketExists(bucketName);
 
        if (flag) {
            //往桶中添加数据   minioClient 进行添加
 
            /**
             *   参数1： 桶的名称
             *   参数2： 文件的名称
             *   参数3： 文件的流
             *   参数4： 添加的配置
             */
            minioClient.putObject(bucketName, objectName, stream, new PutObjectOptions(stream.available(), -1));
            ObjectStat statObject = statObject(objectName);
            if (statObject != null && statObject.length() > 0) {
                return true;
            }
        }
        return false;
    }
 
    /**
     * 删除一个对象
     * @param objectName 存储桶里的对象名称
     */
    public boolean removeObject(String objectName)throws Exception {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            minioClient.removeObject(bucketName, objectName);
            return true;
        }
        return false;
    }
    /**
     * 删除指定桶的多个文件对象,返回删除错误的对象列表，全部删除成功，返回空列表
     * @param objectNames 含有要删除的多个object名称的迭代器对象
     */
    public List<String> removeObject(List<String> objectNames) throws Exception {
        List<String> deleteErrorNames = new ArrayList<>();
        boolean flag = bucketExists(bucketName);
        if (flag) {
            Iterable<Result<DeleteError>> results = minioClient.removeObjects(bucketName, objectNames);
            for (Result<DeleteError> result : results) {
                DeleteError error = result.get();
                deleteErrorNames.add(error.objectName());
            }
        }
        return deleteErrorNames;
    }
 
    /**
     * 获取对象的元数据
     * @param objectName 存储桶里的对象名称
     */
    public ObjectStat statObject(String objectName) throws Exception {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            ObjectStat statObject = minioClient.statObject(bucketName, objectName);
            return statObject;
        }
        return null;
    }
 
    /**
     * 文件访问路径
     * @param objectName 存储桶里的对象名称
     */
    public String getObjectUrl(String objectName) throws Exception {
        boolean flag = bucketExists(bucketName);
        String url = "";
        if (flag) {
            url = minioClient.getObjectUrl(bucketName, objectName);
        }
        return url;
    }
    public void getObject(String filename, HttpServletResponse response){
        InputStream in = null;
        OutputStream out = null;
        try{
            in=minioClient.getObject(bucketName,filename);
            int length=0;
            byte[] buffer = new byte[1024];
            out = response.getOutputStream();
            response.reset();
            response.addHeader("Content-Disposition",
                    " attachment;filename=" + URLEncoder.encode(filename, "UTF-8"));
            response.setContentType("application/octet-stream");
            while ((length = in.read(buffer)) > 0) {
                out.write(buffer, 0, length);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (in != null){
                try {
                    in.close();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 
}
 

编写控制器

package com.taotao.test2.controller;
 

import com.taotao.test2.config.MinioClientUtil;
import io.minio.errors.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
 
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.UUID;
 
@RestController
public class TestController {
    @Autowired
    public void setMinioClientUtil(MinioClientUtil minioClientUtil) {
        this.minioClientUtil = minioClientUtil;
    }
 
    private MinioClientUtil minioClientUtil;
 
    @PostMapping("/upload")
    public String uploadMinio(@RequestPart MultipartFile file) throws Exception {
 
        //拿到图片  MultipartFile封装接受的类
        //拿到图片的名称
        String filename = file.getOriginalFilename();
 
        //拿到图片的 UUId + 图片类型 (解决图片重名的问题 )
        String uuid = UUID.randomUUID().toString();
        String imgType = filename.substring(filename.lastIndexOf("."));
 
        //图片文件的新名称 xxx/uuid.jpg   图片拼接后的名
        String fileName = uuid + imgType;
 
        boolean flag = minioClientUtil.putObject(fileName, file.getInputStream());
 
 
        String path = "/upload/" + fileName;
 
        return path;
    }
    @PostMapping("/downLoad")
    public void downLoadMinio(String url,HttpServletResponse response) throws Exception {
       // String objectUrl = minioClientUtil.getObjectUrl("a9e203f9-1bbb-4d59-8c28-3a183c064502.sql")
        String trim = url.trim();
        String path = trim.substring(trim.indexOf("/", 1), trim.length());
        minioClientUtil.getObject(path,response);

    }
 
}

上传接口调用

image.png image.png