Minio工具类 - Java

时间：2025-03-24 14:26:20

中引依赖

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

配置

minio:
  endpoint: http://127.0.0.1:9000 #MinIO服务所在地址
  bucketName: test #存储桶名称
  accessKey: admin #访问的key
  secretKey: admin123 #访问的秘钥

项目启动，创建bean：


import ;
import .slf4j.Slf4j;
import ;
import ;
import ;
import ;
import ;

/**
 * @Author: zrs
 * @Date: 2020/12/01/17:05
 * @Description: 创建Bean
 */
@Configuration
@IntegrationComponentScan
@Slf4j
public class MinioConfig {

  @Value("${}")
  private String endpoint;
  @Value("${}")
  private String bucketName;
  @Value("${}")
  private String accessKey;
  @Value("${}")
  private String secretKey;

  @Bean
  public MinioUtils creatMinioClient() {
    return new MinioUtils(endpoint, bucketName, accessKey, secretKey);
  }

}

Minio工具类：


import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import .slf4j.Slf4j;
import ;

/**
 * @Author: zrs
 * @Date: 2020/12/01/10:02
 * @Description: Minio工具类
 */
@Slf4j
public class MinioUtils {

  private static MinioClient minioClient;

  private static String endpoint;
  private static String bucketName;
  private static String accessKey;
  private static String secretKey;

  private static final String SEPARATOR = "/";

  private MinioUtils() {
  }

  public MinioUtils(String endpoint, String bucketName, String accessKey, String secretKey) {
     = endpoint;
     = bucketName;
     = accessKey;
     = secretKey;
    createMinioClient();
  }

  /**
   * 创建minioClient
   */
  public void createMinioClient() {
    try {
      if (null == minioClient) {
        ("minioClient create start");
        minioClient = ().endpoint(endpoint).credentials(accessKey, secretKey)
            .build();
        createBucket();
        ("minioClient create end");
      }
    } catch (Exception e) {
      ("连接MinIO服务器异常：{}", e);
    }
  }

  /**
   * 获取上传文件的基础路径
   *
   * @return url
   */
  public static String getBasisUrl() {
    return endpoint + SEPARATOR + bucketName + SEPARATOR;
  }
   操作存储桶 

  /**
   * 初始化Bucket
   *
   * @throws Exception 异常
   */
  private static void createBucket()
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException, RegionConflictException {
    if (!(().bucket(bucketName).build())) {
      (().bucket(bucketName).build());
    }
  }

  /**
   * 验证bucketName是否存在
   *
   * @return boolean true:存在
   */
  public static boolean bucketExists()
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    return (().bucket(bucketName).build());
  }

  /**
   * 创建bucket
   *
   * @param bucketName bucket名称
   */
  public static void createBucket(String bucketName)
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException, RegionConflictException {
    if (!(().bucket(bucketName).build())) {
      (().bucket(bucketName).build());
    }
  }

  /**
   * 获取存储桶策略
   *
   * @param bucketName 存储桶名称
   * @return json
   */
  private JSONObject getBucketPolicy(String bucketName)
      throws IOException, InvalidKeyException, InvalidResponseException, BucketPolicyTooLargeException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, InsufficientDataException, ErrorResponseException {
    String bucketPolicy = minioClient
        .getBucketPolicy(().bucket(bucketName).build());
    return (bucketPolicy);
  }

  /**
   * 获取全部bucket
   * <p>
   * /cn/#listBuckets
   */
  public static List<Bucket> getAllBuckets()
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    return ();
  }

  /**
   * 根据bucketName获取信息
   *
   * @param bucketName bucket名称
   */
  public static Optional<Bucket> getBucket(String bucketName)
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    return ().stream().filter(b -> ().equals(bucketName)).findFirst();
  }

  /**
   * 根据bucketName删除信息
   *
   * @param bucketName bucket名称
   */
  public static void removeBucket(String bucketName)
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    (().bucket(bucketName).build());
  }

   操作文件对象 

  /**
   * 判断文件是否存在
   *
   * @param bucketName 存储桶
   * @param objectName 对象
   * @return true：存在
   */
  public static boolean doesObjectExist(String bucketName, String objectName) {
    boolean exist = true;
    try {
      minioClient
          .statObject(().bucket(bucketName).object(objectName).build());
    } catch (Exception e) {
      exist = false;
    }
    return exist;
  }

  /**
   * 判断文件夹是否存在
   *
   * @param bucketName 存储桶
   * @param objectName 文件夹名称（去掉/）
   * @return true：存在
   */
  public static boolean doesFolderExist(String bucketName, String objectName) {
    boolean exist = false;
    try {
      Iterable<Result<Item>> results = (
          ().bucket(bucketName).prefix(objectName).recursive(false).build());
      for (Result<Item> result : results) {
        Item item = ();
        if (() && (())) {
          exist = true;
        }
      }
    } catch (Exception e) {
      exist = false;
    }
    return exist;
  }

  /**
   * 根据文件前置查询文件
   *
   * @param bucketName bucket名称
   * @param prefix 前缀
   * @param recursive 是否递归查询
   * @return MinioItem 列表
   */
  public static List<Item> getAllObjectsByPrefix(String bucketName, String prefix,
      boolean recursive)
      throws ErrorResponseException, InsufficientDataException, InternalException, InvalidBucketNameException, InvalidKeyException, InvalidResponseException,
      IOException, NoSuchAlgorithmException, ServerException, XmlParserException {
    List<Item> list = new ArrayList<>();
    Iterable<Result<Item>> objectsIterator = (
        ().bucket(bucketName).prefix(prefix).recursive(recursive).build());
    if (objectsIterator != null) {
      for (Result<Item> o : objectsIterator) {
        Item item = ();
        (item);
      }
    }
    return list;
  }

  /**
   * 获取文件流
   *
   * @param bucketName bucket名称
   * @param objectName 文件名称
   * @return 二进制流
   */
  public static InputStream getObject(String bucketName, String objectName)
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    return minioClient
        .getObject(().bucket(bucketName).object(objectName).build());
  }

  /**
   * 断点下载
   *
   * @param bucketName bucket名称
   * @param objectName 文件名称
   * @param offset 起始字节的位置
   * @param length 要读取的长度
   * @return 流
   */
  public InputStream getObject(String bucketName, String objectName, long offset, long length)
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    return (
        ().bucket(bucketName).object(objectName).offset(offset).length(length)
            .build());
  }

  /**
   * 获取路径下文件列表
   *
   * @param bucketName bucket名称
   * @param prefix 文件名称
   * @param recursive 是否递归查找，如果是false,就模拟文件夹结构查找
   * @return 二进制流
   */
  public static Iterable<Result<Item>> listObjects(String bucketName, String prefix,
      boolean recursive) {
    return (
        ().bucket(bucketName).prefix(prefix).recursive(recursive).build());
  }

  /**
   * 通过MultipartFile，上传文件
   *
   * @param bucketName 存储桶
   * @param file 文件
   * @param objectName 对象名
   */
  public static ObjectWriteResponse putObject(String bucketName, MultipartFile file,
      String objectName, String contentType)
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    InputStream inputStream = ();
    return (
        ().bucket(bucketName).object(objectName).contentType(contentType)
            .stream(
                inputStream, (), -1)
            .build());
  }

  /**
   * 上传本地文件
   *
   * @param bucketName 存储桶
   * @param objectName 对象名称
   * @param fileName 本地文件路径
   */
  public static ObjectWriteResponse putObject(String bucketName, String objectName,
      String fileName)
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    return (
        ()
            .bucket(bucketName).object(objectName).filename(fileName).build());
  }

  /**
   * 通过流上传文件
   *
   * @param bucketName 存储桶
   * @param objectName 文件对象
   * @param inputStream 文件流
   */
  public static ObjectWriteResponse putObject(String bucketName, String objectName,
      InputStream inputStream)
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    return (
        ().bucket(bucketName).object(objectName).stream(
            inputStream, (), -1)
            .build());
  }

  /**
   * 创建文件夹或目录
   *
   * @param bucketName 存储桶
   * @param objectName 目录路径
   */
  public static ObjectWriteResponse putDirObject(String bucketName, String objectName)
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    return (
        ().bucket(bucketName).object(objectName).stream(
            new ByteArrayInputStream(new byte[]{}), 0, -1)
            .build());
  }

  /**
   * 获取文件信息, 如果抛出异常则说明文件不存在
   *
   * @param bucketName bucket名称
   * @param objectName 文件名称
   */
  public static ObjectStat statObject(String bucketName, String objectName)
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    return minioClient
        .statObject(().bucket(bucketName).object(objectName).build());
  }

  /**
   * 拷贝文件
   *
   * @param bucketName bucket名称
   * @param objectName 文件名称
   * @param srcBucketName 目标bucket名称
   * @param srcObjectName 目标文件名称
   */
  public static ObjectWriteResponse copyObject(String bucketName, String objectName,
      String srcBucketName, String srcObjectName)
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    return (
        ()
            .source(().bucket(bucketName).object(objectName).build())
            .bucket(srcBucketName)
            .object(srcObjectName)
            .build());
  }

  /**
   * 删除文件
   *
   * @param bucketName bucket名称
   * @param objectName 文件名称
   */
  public static void removeObject(String bucketName, String objectName)
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    minioClient
        .removeObject(().bucket(bucketName).object(objectName).build());
  }

  /**
   * 批量删除文件
   *
   * @param bucketName bucket
   * @param keys 需要删除的文件列表
   * @return
   */
  /*public static Iterable<Result<DeleteError>> removeObjects(String bucketName, List<String> keys) {
    List<DeleteObject> objects = new LinkedList<>();
    (s -> {
      (new DeleteObject(s));
    });
    return (
        ().bucket(bucketName).objects(objects).build());
  }*/
  public static void removeObjects(String bucketName, List<String> keys) {
    List<DeleteObject> objects = new LinkedList<>();
    (s -> {
      (new DeleteObject(s));
      try {
        removeObject(bucketName, s);
      } catch (Exception e) {
        ("批量删除失败！error:{}",e);
      }
    });
  }

   操作Presigned 

  /**
   * 获取文件外链
   *
   * @param bucketName bucket名称
   * @param objectName 文件名称
   * @param expires 过期时间 <=7 秒级
   * @return url
   */
  public static String getPresignedObjectUrl(String bucketName, String objectName,
      Integer expires)
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, InvalidExpiresRangeException, ServerException, InternalException, NoSuchAlgorithmException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    return (bucketName, objectName, expires);
  }

  /**
   * 给presigned URL设置策略
   *
   * @param bucketName 存储桶
   * @param objectName 对象名
   * @param expires 过期策略
   * @return map
   */
  public static Map<String, String> presignedGetObject(String bucketName, String objectName,
      Integer expires)
      throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, InvalidExpiresRangeException, ServerException, InternalException, NoSuchAlgorithmException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    PostPolicy policy = new PostPolicy(bucketName, objectName,
        ().plusDays(7));
    ("image/png");
    return (policy);
  }


  /**
   * 将URLDecoder编码转成UTF8
   *
   * @param str
   * @return
   * @throws UnsupportedEncodingException
   */
  public static String getUtf8ByURLDecoder(String str) throws UnsupportedEncodingException {
    String url = ("%(?![0-9a-fA-F]{2})", "%25");
    return (url, "UTF-8");
  }

}

如果想使用AWS-S3的方式实现通用存储操作，可以看我这篇文章：/weixin_42170236/article/details/130870166

手写不易，有用请点赞！

相关文章