MinIO整合SpringBoot（封装Starter）

一、使用docker容器部署MinIO

1、拉取镜像

docker pull minio/minio

2、创建目录

mkdir -p /home/minio/config
mkdir -p /home/minio/data

3、运行容器

	 docker run -p 9000:9000 -p 9090:9090 \
     --name minio \
     -d --restart=always \
     -e "MINIO_ACCESS_KEY=minioadmin" \
     -e "MINIO_SECRET_KEY=minioadmin" \
     -v /home/minio/data:/data \
     -v /home/minio/config:/root/.minio \
     minio/minio server \
     /data --console-address ":9090" -address ":9000"

注意：
1）每行的最后一个\表示的是换行
2）第一行，表示运行容器，并且外部的9000端口和9090端口映射到docker容器的9000端口和9090端口（：前面是外部访问的端口，后面是容器中的端口）
3）第二行容器的名称叫minio
4）第三行容器总是开机自启
5）第四行minio的用户名是minioadmin
6）第五行minio的密码是minioadmin
7）第五六行都是将docker容器中的文件映射到linux文件中，冒号前面是我们第二步创建的文件，冒号后面是minio容器中的文件，/data中就是一个一个的桶文件，/root/.minio中就是配置文件，通过目录映射可以直接在linux文件夹中看到对应的文件，而不用进入到容器中（进入容器：docker exec -it 容器名 /bin/bash）
8）第六七行表示minio服务器启动端口是9090，而文件存放的端口是9000

4、容器启动成功

5、登录minio控制台
docker 容器所在ip:9090,用户名和密码就是创建容器时所设置的

6、创建桶
点击左侧额buckets创建桶，也就是创建一个文件夹

创建一个桶，值得注意的是命名规范：

桶名称必须是全局唯一的。

桶名称只能包含小写字母、数字和连字符(-)。

桶名称的长度必须在 3 到 63 个字符之间。

桶名称不能以连字符(-)开头或结尾

7、设置桶的权限
回到首页，点击manage

设置Access Policy为Public,不设置通过地址访问不了桶中的文件

二、MinIO整合SpringBoot

1、创建一个Maven模块
2、导入minio的依赖

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

3、将其他starter的resource下的MENTA-INF文件拷贝到此模块中

4、编写配置文件

package com.lq.pojo.properties;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * MinIO的yml配置文件
 */
@Data
@ConfigurationProperties(prefix = "minio")
public class MinIOProperties {
    //桶名
    private String bucket; //"mybucket"
    //主机
    private String host;//"http://minio容器所在ip:9000"
    //地址
    private String url; //${minio.host}/${minio.bucket}/
    //用户名
    private String accessKey; //"minioadmin"
    //密码
    private String secretKey; //"minioadmin"
}

5、创建模版

package com.lq.template;


import com.lq.pojo.properties.MinIOProperties;
import io.minio.MinioClient;
import io.minio.ObjectStat;
import io.minio.PutObjectOptions;
import io.minio.Result;
import io.minio.messages.Bucket;
import io.minio.messages.Item;
import lombok.extern.slf4j.Slf4j;
import org.apache.tomcat.util.http.fileupload.IOUtils;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.util.UriUtils;

import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;


/**
 * MinIO模版
 */
@Slf4j
public class MinIOTemplate {
    private MinIOProperties minIOProperties;
    private MinioClient minioClient;

    public MinIOTemplate(MinIOProperties minIOProperties, MinioClient minioClient) {
        this.minIOProperties = minIOProperties;
        this.minioClient = minioClient;
    }


    /**
     * 上传
     */
    public String upload(MultipartFile multipartFile) throws Exception {

        // bucket 不存在，创建
        if (!minioClient.bucketExists(minIOProperties.getBucket())) {
            minioClient.makeBucket(minIOProperties.getBucket());
        }
        try (InputStream inputStream = multipartFile.getInputStream()) {
            // 上传文件的名称
            String fileName = multipartFile.getOriginalFilename();
            // PutObjectOptions，上传配置(文件大小，内存中文件分片大小)
            PutObjectOptions putObjectOptions = new PutObjectOptions(multipartFile.getSize(), 0);

            // 文件的ContentType
            putObjectOptions.setContentType(multipartFile.getContentType());
            minioClient.putObject(minIOProperties.getBucket(), fileName, inputStream, putObjectOptions);
            // 返回访问路径
            return minIOProperties.getUrl() + UriUtils.encode(fileName, StandardCharsets.UTF_8);
        }
    }



    /**
     * 文件下载
     */
    public void download(String fileName, HttpServletResponse response){
        // 从链接中得到文件名
        InputStream inputStream;
        try {
            MinioClient minioClient = new MinioClient(minIOProperties.getHost(), minIOProperties.getAccessKey(), minIOProperties.getSecretKey());
            ObjectStat stat = minioClient.statObject(minIOProperties.getBucket(), fileName);
            inputStream = minioClient.getObject(minIOProperties.getBucket(), fileName);
            response.setContentType(stat.contentType());
            response.setCharacterEncoding("UTF-8");
            response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
            IOUtils.copy(inputStream, response.getOutputStream());
            inputStream.close();
        } catch (Exception e){
            e.printStackTrace();
            System.out.println("有异常：" + e);
        }
    }

    /**
     * 列出所有存储桶名称
     *
     * @return
     * @throws Exception
     */
    public List<String> listBucketNames()
            throws Exception {
        List<Bucket> bucketList = listBuckets();
        List<String> bucketListName = new ArrayList<>();
        for (Bucket bucket : bucketList) {
            bucketListName.add(bucket.name());
        }
        return bucketListName;
    }

    /**
     * 查看所有桶
     *
     * @return
     * @throws Exception
     */
    public List<Bucket> listBuckets()
            throws Exception {
        return minioClient.listBuckets();
    }

    /**
     * 检查存储桶是否存在
     *
     * @param bucketName
     * @return
     * @throws Exception
     */
    public boolean bucketExists(String bucketName) throws Exception {
        boolean flag = minioClient.bucketExists(bucketName);
        if (flag) {
            return true;
        }
        return false;
    }

    /**
     * 创建存储桶
     *
     * @param bucketName
     * @return
     * @throws Exception
     */
    public boolean makeBucket(String bucketName)
            throws Exception {
        boolean flag = bucketExists(bucketName);
        if (!flag) {
            minioClient.makeBucket(bucketName);
            return true;
        } else {
            return false;
        }
    }

    /**
     * 删除桶
     *
     * @param bucketName
     * @return
     * @throws Exception
     */
    public boolean removeBucket(String bucketName)
            throws Exception {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            Iterable<Result<Item>> myObjects = listObjects(bucketName);
            for (Result<Item> result : myObjects) {
                Item item = result.get();
                // 有对象文件，则删除失败
                if (item.size() > 0) {
                    return false;
                }
            }
            // 删除存储桶，注意，只有存储桶为空时才能删除成功。
            minioClient.removeBucket(bucketName);
            flag = bucketExists(bucketName);
            if (!flag) {
                return true;
            }

        }
        return false;
    }

    /**
     * 列出存储桶中的所有对象
     *
     * @param bucketName 存储桶名称
     * @return
     * @throws Exception
     */
    public Iterable<Result<Item>> listObjects(String bucketName) throws Exception {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            return minioClient.listObjects(bucketName);
        }
        return null;
    }

    /**
     * 列出存储桶中的所有对象名称
     *
     * @param bucketName 存储桶名称
     * @return
     * @throws Exception
     */
    public List<String> listObjectNames(String bucketName) throws Exception {
        List<String> listObjectNames = new ArrayList<>();
        boolean flag = bucketExists(bucketName);
        if (flag) {
            Iterable<Result<Item>> myObjects = listObjects(bucketName);
            for (Result<Item> result : myObjects) {
                Item item = result.get();
                listObjectNames.add(item.objectName());
            }
        }
        return listObjectNames;
    }

    /**
     * 删除一个对象
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     * @throws Exception
     */
    public boolean removeObject(String bucketName, String objectName) throws Exception {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            List<String> objectList = listObjectNames(bucketName);
            for (String s : objectList) {
                if(s.equals(objectName)){
                    minioClient.removeObject(bucketName, objectName);
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 文件访问路径
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     * @return
     * @throws Exception
     */
    public String getObjectUrl(String bucketName, String objectName) throws Exception {
        boolean flag = bucketExists(bucketName);
        String url = "";
        if (flag) {
            url = minioClient.getObjectUrl(bucketName, objectName);
        }
        return url;
    }
}

6、写自动配置类

package com.lq.autoconfigure;

import com.lq.pojo.properties.MinIOProperties;
import com.lq.template.MinIOTemplate;
import io.minio.MinioClient;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/**
 * MinIO自动装配类
 */
@Configuration
@EnableConfigurationProperties(MinIOProperties.class)
public class MinIOAutoConfiguration {
  @Bean
    public MinIOTemplate minIOTemplate(MinIOProperties minIOProperties){
    //创建minIO客户端
  MinioClient minioClient = new MinioClient(minIOProperties.getHost(),minIOProperties.getAccessKey(),minIOProperties.getSecretKey());

    return new MinIOTemplate(minIOProperties,minioClient);
  }
}

7、修改MENTA-INF下的spring.factories文件

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.lq.autoconfigure.MinIOAutoConfiguration

8、yml配置文件

minio:
  bucket: "mybucket"
  host: "http://minio容器所在ip:9000"
  url: "${minio.host}/${minio.bucket}/"
  accessKey: "minioadmin"
  secretKey: "minioadmin"

9、测试
测试的服务中导入我们创建的这个starter

   <!--minio-->
    <dependency>
        <groupId>com.lq</groupId>
        <artifactId>fastCar-starter-minio</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>

编写一个接口

@RestController
@RequestMapping("/minIO/test")
public class MinIOTest {
    @Autowired
    private MinIOTemplate minIOTemplate;
    @PostMapping("/upload")
    public void upload(MultipartFile file) throws Exception {
        minIOTemplate.upload(file);
    }
}

用apifox测试

可以看到我们的桶中已经上传成功

注意：
1）上传测试时的参数名要和接口中的文件名保持一致

2）通过第8步的host/桶名/文件名也可以访问到文件，前提是文件所在桶的Access Policy是public
3）其他方法的测试同理
4）步骤5中的上传方法，minio分片大小
我这里设置的是0，也就是说没有最小文件上传大小限制，你可以根据自己的需求设置

 PutObjectOptions putObjectOptions = new PutObjectOptions(multipartFile.getSize(), 0);

这个方法的源码是这样的

   public PutObjectOptions(long objectSize, long partSize) throws IllegalArgumentException {
        if (partSize > 0L) {
            if (partSize < 5242880L) {
                throw new IllegalArgumentException("part size " + partSize + " is not supported; minimum allowed 5MiB");
            }

            if (partSize > 5368709120L) {
                throw new IllegalArgumentException("part size " + partSize + " is not supported; maximum allowed 5GiB");
            }
        }

        if (objectSize >= 0L) {
            if (objectSize > 5497558138880L) {
                throw new IllegalArgumentException("object size " + objectSize + " is not supported; maximum allowed 5TiB");
            } else {
                this.objectSize = objectSize;
                if (partSize > 0L) {
                    if (partSize > objectSize) {
                        partSize = objectSize;
                    }

                    this.partSize = partSize;
                    this.partCount = (int)Math.ceil((double)objectSize / (double)partSize);
                    if (this.partCount > 10000) {
                        throw new IllegalArgumentException("object size " + this.objectSize + " and part size " + this.partSize + " make more than " + 10000 + "parts for upload");
                    }
                } else {
                    double pSize = Math.ceil((double)objectSize / 10000.0);
                    pSize = Math.ceil(pSize / 5242880.0) * 5242880.0;
                    this.partSize = (long)pSize;
                    if (pSize > 0.0) {
                        this.partCount = (int)Math.ceil((double)objectSize / pSize);
                    } else {
                        this.partCount = 1;
                    }
                }

            }
        } else if (partSize <= 0L) {
            throw new IllegalArgumentException("valid part size must be provided when object size is unknown");
        } else {
            this.objectSize = -1L;
            this.partSize = partSize;
            this.partCount = -1;
        }
    }

三、MinIO官方文档使用

minio

可以根据官方文档的指示搭建自己的starter
进入技术文档

左侧工具栏，选择SDK，JAVA

点击快速指南

这里面就有很多解释