SpringBoot整合云存储MinIo

   一、参考项

MinIo (官网):  MinIO | 高性能，对Kubernetes友好的对象存储
MinIo SDK for Java(官网): Java Client API参考文档 | Minio中文文档

三、引入Pom文件

<!-- https://mvnrepository.com/artifact/io.minio/minio -->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>6.0.8</version>
</dependency>

二、定义抽象类

public abstract class BaseObjectStorage {

    /**
     * 上传文件
     *
     * @param pathAndName
     * @param file
     */
    public abstract void upload(String pathAndName, File file);

    /**
     * 授权
     *
     * @param pathAndName
     * @param time
     * @return
     */
    public abstract String authorize(String pathAndName, long time);

    /**
     * 授权(路径全)
     *
     * @param pathAndName
     * @param time
     * @return
     */
    public abstract String authorizeAllName(String pathAndName, long time);

    /**
     * 临时上传文件授权
     *
     * @param dir
     * @return
     */
    public abstract Map<String, Object> tokens(String dir);

    /**
     * 删除文件
     *
     * @param pathAndName
     */
    public abstract void deleteFile(String pathAndName);

}

三、OSS实现类

package cn.xhh.xhh.core.objectstorage;

import java.io.File;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Map;
import org.joda.time.DateTime;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import org.xmlpull.v1.XmlPullParserException;
import com.google.common.collect.Maps;
import io.minio.MinioClient;
import io.minio.PostPolicy;
import io.minio.errors.ErrorResponseException;
import io.minio.errors.InsufficientDataException;
import io.minio.errors.InternalException;
import io.minio.errors.InvalidArgumentException;
import io.minio.errors.InvalidBucketNameException;
import io.minio.errors.InvalidEndpointException;
import io.minio.errors.InvalidExpiresRangeException;
import io.minio.errors.InvalidPortException;
import io.minio.errors.NoResponseException;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

@Component
@Slf4j
public class MinioObjectStorage extends BaseObjectStorage {

  @Data
  @Component
  @ConfigurationProperties(prefix = "minio")
  public static class MinioInfo {
    private String endpoint;
    private String host;
    private String accessKeyId;
    private String accessKeySecret;
    private String bucketName;
    private String rootDirectory;
  }

  @Autowired
  private MinioInfo minioInfo;

  private static volatile MinioClient minioClient;

  private MinioClient init() {
    if (minioClient == null) {
      synchronized (MinioObjectStorage.class) {
        if (minioClient == null) {
          try {
            minioClient = new MinioClient(minioInfo.host, minioInfo.accessKeyId,
                minioInfo.accessKeySecret);
          } catch (InvalidEndpointException | InvalidPortException e) {
            log.error("minio初始化失败", e);
          }
        }
      }
    }
    return minioClient;
  }

  @SuppressWarnings("deprecation")
  @Override
  public void upload(String pathAndName, File file) {
    MinioClient minioClient = init();
    try {
      minioClient.putObject(minioInfo.bucketName, minioInfo.rootDirectory + pathAndName,
          file.getAbsolutePath());
    } catch (InvalidKeyException | InvalidBucketNameException | NoSuchAlgorithmException
        | NoResponseException | ErrorResponseException | InternalException
        | InvalidArgumentException | InsufficientDataException | IOException
        | XmlPullParserException e) {
      log.error("minio上传失败", e);
    }
  }

  @Override
  public String authorize(String pathAndName, long time) {
    MinioClient minioClient = init();
    String url = "";
    try {
      url = minioClient.presignedGetObject(minioInfo.bucketName,
          minioInfo.rootDirectory + pathAndName, Integer.parseInt(String.valueOf(time)));
    } catch (InvalidKeyException | NumberFormatException | InvalidBucketNameException
        | NoSuchAlgorithmException | InsufficientDataException | NoResponseException
        | ErrorResponseException | InternalException | InvalidExpiresRangeException | IOException
        | XmlPullParserException e) {
      log.error("minio生成下载连接失败", e);
    }
    url = url.replaceAll(minioInfo.host, minioInfo.endpoint);
    return url;
  }

  @Override
  public String authorizeAllName(String pathAndName, long time) {
    MinioClient minioClient = init();
    String url = "";
    try {
      url = minioClient.presignedGetObject(minioInfo.bucketName, pathAndName,
          Integer.parseInt(String.valueOf(time)));
    } catch (InvalidKeyException | NumberFormatException | InvalidBucketNameException
        | NoSuchAlgorithmException | InsufficientDataException | NoResponseException
        | ErrorResponseException | InternalException | InvalidExpiresRangeException | IOException
        | XmlPullParserException e) {
      log.error("minio生成下载连接失败", e);
    }
    url = url.replaceAll(minioInfo.host, minioInfo.endpoint);
    return url;
  }

  @Override
  public Map<String, Object> tokens(String dir) {
    Map<String, Object> result = Maps.newHashMap();
    MinioClient minioClient = init();
    long expireTime = 60;
    long expireEndTime = System.currentTimeMillis() + expireTime * 1000;
    DateTime expiration = new DateTime(expireEndTime);
    dir = "frontend/xhh/" + dir;
    PostPolicy policy = null;
    try {
      policy = new PostPolicy(minioInfo.bucketName, "frontend", true, DateTime.now().plusSeconds(30));
    } catch (InvalidArgumentException e) {
      log.error("minio生成策略失败", e);
    }
    Map<String, String> formData = Maps.newHashMap();
    try {
      formData = minioClient.presignedPostPolicy(policy);
      formData.remove("key");
    } catch (InvalidKeyException | InvalidBucketNameException | NoSuchAlgorithmException
        | InsufficientDataException | NoResponseException | ErrorResponseException
        | InternalException | InvalidArgumentException | IOException | XmlPullParserException e) {
      log.error("minio生成上传链接失败", e);
    }
    result.put("storeType", "minio");
    result.put("storageType", "minio");
    result.put("formData", formData);
    result.put("accessId", minioInfo.accessKeyId);
    result.put("expire", String.valueOf(expireEndTime / 1000));
    result.put("dir", dir);
    result.put("host", minioInfo.endpoint + "/" + minioInfo.bucketName);
    return result;
  }

  @Override
  public void deleteFile(String pathAndName) {
    MinioClient minioClient = init();
    try {
      minioClient.removeObject(minioInfo.bucketName, minioInfo.rootDirectory + pathAndName);
    } catch (InvalidKeyException | InvalidBucketNameException | NoSuchAlgorithmException
        | InsufficientDataException | NoResponseException | ErrorResponseException
        | InternalException | InvalidArgumentException | IOException | XmlPullParserException e) {
      log.error("minio删除失败", e);
    }
  }
  
  public static void main(String[] args) throws Exception {
    MinioClient minioClient = new MinioClient("http://kf-ocs.ziroom.com","admin","password");
    File file = new File("/Users/zhangmiao/Downloads/abc/template/");
    
    for(int i = 0 ; i < file.listFiles().length;i++) {
      minioClient.putObject("data", "frontend/xhh/template/" + file.listFiles()[i].getName(),
          file.listFiles()[i].getAbsolutePath());
    }
    
  }

}

四、application配置文件

objectstorage.type: minio
minio:
  endpoint: https://s-xhh.udesk.cn/xhh-minio
  access-key-id: admin
  access-key-secret: Ceb1qX!@Z
  bucket-name: data
  root-directory: xhh/export/