minio分佈式存儲系列（二）__SpringBoot集成minio API相關使用

上篇文章我們介紹了minio存儲服務是什麼，如何部署，如何通過頁面去使用，如果還沒看上篇文章介紹的，請點擊Minio分佈式存儲系列（一）__介紹及開箱使用
衆所周知，我們開發編程的時候，不可能總是通過頁面去上傳文件，這時候我們視乎要通過Minio提供的API去操作呢？此篇文章重點介紹：

1、如何通過Java語言操作Minio，重點介紹項目中常用的API方法；
2、SpringBoot如何集成Minio Java Client API，如何將一個minioClient注入到Spring中進行使用
3、針對Minio 的Java Java Client API 提供工具類（文章末尾有彩蛋）。

在介紹Minio 常用Minio之前，我們先回顧一下Minio的相關概念：

桶的概念：
通俗理解爲：類似於計算機裏面的文件夾，但是又區分與文件夾的概念，因爲文件夾裏面可以創建文件夾，但是Minio的概念裏，創建的桶是唯一的，不允許在桶裏面在創建新桶。

什麼是文件對象：
通俗理解爲：類似於計算機裏面的文件，但是在Minio的概念裏，所有的文件都統稱爲對象，所以後續的AIP操作都是針對文件對象進行操作。

在知道這兩個概念之後，我們接下來介紹minio的常用方法，

如何通過Java語言操作Minio，重點介紹項目中常用的API方法

1、如何創建一個Minio Client對象

MinioClient minioClient = new MinioClient(url,port, accessKey, secretKey,secure);

註明：
url - http訪問地址；
port - 訪問地址端口；
accessKey - 用戶名
secretKey - 密碼
secure - url是否採用HTTPS，是則填寫“true”，否則填寫“false”

示例：

MinioClient minioClient = new MinioClient("https://play.min.io", 9000, "Q3AM3UQ867SPQQA43P2F", "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG", true);

2、判斷一個桶是否存在

public boolean bucketExists(String bucketName)

註明：
bucketName - 桶名稱

示例：

boolean found = minioClient.bucketExists("mybucket");
if (found) {
  System.out.println("mybucket 存在");
} else {
  System.out.println("mybucket 不存在");
}

3、創建一個桶

public void makeBucket(String bucketName)

示例：

try {
  // 如果桶不存在，則創建。
  boolean found = minioClient.bucketExists("mybucket");
  if (found) {
    System.out.println("mybucket 存在");
  } else {
    // 創建名爲'mybucket'的桶。
    minioClient.makeBucket("mybucket");
    System.out.println("mybucket創建成功");
  }
} catch (MinioException e) {
  System.out.println("Error occurred: " + e);
}

4、列出所有存在的桶

public List<Bucket> listBuckets()

示例：

try {
  // 列出所有存在的桶
  List<Bucket> bucketList = minioClient.listBuckets();
  for (Bucket bucket : bucketList) {
    System.out.println(bucket.creationDate() + ", " + bucket.name());
  }
} catch (MinioException e) {
  System.out.println("Error occurred: " + e);
}

5、刪除一個桶

public void removeBucket(String bucketName)

注意：通過API源碼發現，如果桶裏面有文件對象，則會把文件對象一併刪除。

示例：

try {
  // 刪除之前先檢查`mybucket`是否存在。
  boolean found = minioClient.bucketExists("mybucket");
  if (found) {
    // 刪除`mybucket`存儲桶，注意，只有存儲桶爲空時才能刪除成功。
    minioClient.removeBucket("mybucket");
    System.out.println("mybucket 刪除成功");
  } else {
    System.out.println("mybucket 不存在");
  }
} catch(MinioException e) {
  System.out.println("Error occurred: " + e);
}

文件對象的相關操作API如下：

1、獲取文件對象輸入流

public InputStream getObject(String bucketName, String objectName)

註明：
bucketName - 桶名稱
objectName - 文件對象名稱

示例：

try {
  // 調用statObject()來判斷對象是否存在。
  // 如果不存在, statObject()拋出異常。
  // 否則代表對象存在。
  minioClient.statObject("mybucket", "myobject");
  // 獲取"myobject"的輸入流。
  InputStream stream = minioClient.getObject("mybucket", "myobject");
  // 讀取輸入流直到EOF並打印到控制檯。
  byte[] buf = new byte[16384];
  int bytesRead;
  while ((bytesRead = stream.read(buf, 0, buf.length)) >= 0) {
    System.out.println(new String(buf, 0, bytesRead));
  }
  // 關閉流，此處爲示例，流關閉最好放在finally塊。
  stream.close();
} catch (MinioException e) {
  System.out.println("Error occurred: " + e);
}

註明：
statObject(String bucketName, String objectName)方法用於判斷文件對象是否存在，如果不存在，則報異常，我下一個章節會通過修改源碼來講解如何通過返回true或者false的方式告知調用者文件對象是否存在

2、下載文件對象指定區域的字節數組流

public InputStream getObject(String bucketName, String objectName, long offset, Long length)

註明：
offset - 起始字節的位置
length - 要讀取的長度 (可選，如果無值則代表讀到文件結尾)

3、下載並將文件保存到本地

public void getObject(String bucketName, String objectName, String fileName)

示例：

try {
  // 獲取myobject的流並保存到wj.jpg文件中。
  minioClient.getObject("mybucket", "myobject", "wj.jpg");

} catch (MinioException e) {
  System.out.println("Error occurred: " + e);
}

4、通過字節流的方式上傳文件對象

public void putObject(String bucketName, String objectName, InputStream stream, PutObjectOptions options)

註明：
通過查看API源碼發現，上傳的文件流大小訪問在5M到5T之間，我下一個章節分析源碼時，會給大家講到爲什麼這麼設計，這麼設計的好處。

示例：

File file =new File("/home/wj/myobject.txt");
FileInputStream img =new FileInputStream(file);
PutObjectOptions options = new PutObjectOptions(imgs.length(), -1);
//文件對象名稱的名稱定義，最好把文件的後綴名給寫上，這樣方便知道獲取的文件都是什麼類型
client.putObject("mybucket", "myobject.txt",inputStream,options);

5、通過文件上傳到對象中

 public void putObject(String bucketName, String objectName, String filename, PutObjectOptions options)

6、通過使用服務器端副本組合來自不同源對象的數據來創建新的對象

public void composeObject(String bucketName,String objectName,List<ComposeSource> sources,Map<String, String> headerMap,ServerSideEncryption sse)

示例：

 // Create a ComposeSource to compose Object.
ComposeSource s1 = new ComposeSource("test","wj1.txt");
ComposeSource s2 = new ComposeSource("test","wj2.txt");
ComposeSource s3 = new ComposeSource("test","wj3.txt");
// Adding the ComposeSource to an ArrayList
 List<ComposeSource> sourceObjectList = new ArrayList<ComposeSource>();
 sourceObjectList.add(s1);
 sourceObjectList.add(s2);
 sourceObjectList.add(s3);
client.composeObject("test","wj4.txt", sourceObjectList, null, null);

註明：
將存儲已存在的文件對象wj1.txt、wj2.txt、wj3.txt合併成一個wj4.txt文件對象，
合併的原理，我會在下一個章節通過源碼分析，進行解釋說明。

7、獲取對象的元數據

public ObjectStat statObject(String bucketName, String objectName)

8、刪除一個對象

public void removeObject(String bucketName, String objectName)

9、生成一個給HTTP PUT請求用的presigned URL。瀏覽器/移動端的客戶端可以用這個URL進行下載，即使其所在的存儲桶是私有的。這個presigned URL可以設置一個失效時間，默認值是7

public String presignedPutObject(String bucketName, String objectName, Integer expires)

到此，操作Minio Java Client API常用的方法到這裏就介紹完了，具體剩下的方法請讀者自行參考官網：Minio Java Client API官網

SpringBoot如何集成minio Java Client API，如何將一個minioClient注入到Spring中進行使用

1、引入操作Minio客戶端的最新jar包

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

2、在application.yml中填寫Minio服務端配置文件

#minio配置
minio:
  url: https://play.min.io  #對象存儲服務的URL
  port: 9000
  accessKey: Q3AM3UQ867SPQQA43P2F #Access key就像用戶ID，可以唯一標識你的賬戶
  secretKey: tfteSlswRu7BJ86wekitnifILbZam1KYY3TG  #Secret key是你賬戶的密碼

3、編寫Minio客戶端配置類，並注入到Spring中


import io.minio.MinioClient;
import io.minio.errors.InvalidEndpointException;
import io.minio.errors.InvalidPortException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MinioConfig {


    @Value("${minio.url}")
    private String url;
    @Value("${minio.port}")
    private int port;
    @Value("${minio.accessKey}")
    private String accessKey;
    @Value("${minio.secretKey}")
    private String secretKey;
    
    @Bean
    public MinioClient getMinioClient() throws InvalidPortException, InvalidEndpointException {
        MinioClient minioClient = new MinioClient(url,port, accessKey, secretKey,true);
        return minioClient;
    }

}

可以在代碼裏面通過註解@Autowired獲取一個minioClient客戶端，如何調用minioClient內的方法進行桶的創建和上傳文件對象。

@Autowired
private MinioClient minioClient;

到此，SpringBoot如何集成minio Java Client API，如何將一個minioClient注入到Spring中進行使用，就算是介紹完了，接下來給大家提供MinioClient工具類

針對minio 的Java Java Client API 提供工具類


import io.minio.MinioClient;
import io.minio.ObjectStat;
import io.minio.Result;
import io.minio.errors.*;
import io.minio.messages.Bucket;
import io.minio.messages.DeleteError;
import io.minio.messages.Item;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;

@Component
public class MinioUtils {

private Logger logger = LoggerFactory.getLogger(MinioUtils.class);
    @Autowired
    private MinioClient minioClient;

    private static final int DEFAULT_EXPIRY_TIME = 7 * 24 * 3600;


    /**
     * 判斷桶是否存在
     */
    public boolean isBucker(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        boolean found = minioClient.bucketExists(bucketName);
        if (found) {
            return true;
        }
        return false;
    }


    /**
     * 如果桶不存在，則創建
     **/
    public boolean mkdirBucket(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, RegionConflictException, InsufficientDataException, NoSuchAlgorithmException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        // 如存儲桶不存在，創建之。
        boolean found = minioClient.bucketExists(bucketName);
        if (!found) {
            // 創建名爲bucketName的存儲桶。
            minioClient.makeBucket(bucketName);
            return true;
        } else {
            return false;
        }
    }

    /**
     * 列出所有存儲桶的名稱
     */
    public List<String> listBuckets() throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        List<Bucket> bucketList = minioClient.listBuckets();
        List<String> bucketListName = new ArrayList<>();
        for (Bucket bucket : bucketList) {
            bucketListName.add(bucket.name());
        }
        return bucketListName;
    }

    /**
     * 刪除一個桶
     **/
    public boolean removeBucket(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        // 刪除之前先檢查`my-bucket`是否存在。
        boolean found = isBucker(bucketName);
        if (found) {
            Iterable<Result<Item>> myObjects = minioClient.listObjects(bucketName);
            for (Result<Item> result : myObjects) {
                Item item = result.get();
               //有對象文件，則刪除失敗
                if (item.size()>0){
                    return false;
                }
            }
            // 刪除`bucketName`存儲桶，注意，只有存儲桶爲空時才能刪除成功。
            minioClient.removeBucket(bucketName);
            found = isBucker(bucketName);
            if(!found){
                return true;
            }

        }
        return false;
    }

    /**
     * 獲取單個桶中的所有文件對象名稱
     * **/
    public List<String> getBucketObjectName(String bucketName) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
        boolean found = isBucker(bucketName);
        List<String> listObjetcName=new ArrayList<>();
        if (found){
            Iterable<Result<Item>> myObjects = minioClient.listObjects(bucketName);
            for (Result<Item> result : myObjects) {
                Item item = result.get();
                listObjetcName.add(item.objectName());
            }
        }
        return listObjetcName;
    }

    /**
     * 上傳文件
     * **/
    public boolean putObject(String bucketName, String objectName, String Path,String fileName) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
        boolean found=isBucker(bucketName);
        if (found){
            minioClient.putObject(bucketName,objectName,Path+fileName,null);
            ObjectStat objectStat= minioClient.statObject(bucketName, objectName);
            //判斷文件對象是否上傳成功
            if (objectStat.length()>0){
                return true;
            }
        }
        return false;
    }



    /**
     * 以流的形式獲取一個文件對象
     * **/
    public InputStream getObjectInputStream(String bucketName, String objectName) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
        boolean found= isBucker(bucketName);
        if (found){
            try {
               ObjectStat objectStat= minioClient.statObject(bucketName, objectName);
               if (objectStat.length()>0){
                   // 獲取objectName的輸入流。
                   InputStream stream = minioClient.getObject(bucketName, objectName);
                   return stream;
               }
            }catch (Exception e){
            }
        }
        return null;
    }

    /**
     *下載並將文件保存到本地,下載成功返回true，下載失敗返回false
     * **/
    public boolean  getObject(String bucketName, String objectName,String path,String fileName) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
        boolean found= isBucker(bucketName);
        if (found){
            try {
                ObjectStat objectStat= minioClient.statObject(bucketName, objectName);
                if (objectStat.length()>0){
                    minioClient.getObject(bucketName, objectName,path+fileName);
                    return true;
                }
            }catch (Exception e){
            }
        }
        return false;
    }


    /**
     * 刪除指定桶的單個文件對象
     */

    public boolean removeObject(String bucketName, String objectName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        // 從bucketName中刪除objectName
        boolean found=isBucker(bucketName);
        if (found){
            minioClient.removeObject(bucketName, objectName);
            return true;
        }
        return false;
    }

    /**
     * 刪除指定桶的多個文件對象,返回刪除錯誤的對象列表，全部刪除成功，返回空列表
     * **/

    public List<String> removeObjectList(String bucketName, List<String> objectNames) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
        List<String> listerrorObjectName=new ArrayList<>();
        // 從bucketName中刪除objectName
        boolean found=isBucker(bucketName);
        if (found){
            Iterable<Result<DeleteError>> results = minioClient.removeObjects(bucketName, objectNames);
            for (Result<DeleteError> result : results) {
                DeleteError error = result.get();
                listerrorObjectName.add(error.objectName());
            }
        }
        return listerrorObjectName;
    }



    /**
     * 生成一個給HTTP GET請求用的presigned URL。瀏覽器/移動端的客戶端可以用這個URL進行下載，即使其所在的存儲桶是私有的。這個presigned URL可以設置一個失效時間，默認值是7天。
     *
     * **/

    public String presignedGetObject(String bucketName, String objectName,Integer expires) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException, InvalidExpiresRangeException {
        boolean found=isBucker(bucketName);
        String url ="";
        if (found){
            if (expires < 1 || expires>DEFAULT_EXPIRY_TIME){
                throw new InvalidExpiresRangeException(expires, "expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
            }
            url= minioClient.presignedGetObject(bucketName, objectName, expires);
        }
        return url;
    }


    /**
     * 生成一個給HTTP PUT請求用的presigned URL。瀏覽器/移動端的客戶端可以用這個URL進行上傳，即使其所在的存儲桶是私有的。這個presigned URL可以設置一個失效時間，默認值是7天。
     * **/
    public String presignedPutObject(String bucketName, String objectName,Integer expires) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException, InvalidExpiresRangeException {
        boolean found=isBucker(bucketName);
        String url ="";
        if (found){
            if (expires < 1 || expires>DEFAULT_EXPIRY_TIME){
                throw new InvalidExpiresRangeException(expires, "expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
            }
            url= minioClient.presignedPutObject(bucketName, objectName, expires);
        }
        return url;
    }


}

到此，Minio客戶端常用方法、SpringBoot集成Minio API相關使用及Minio客戶端工具類，到這裏就介紹結束了，我們下期將通過源碼分析介紹Minio原理和思想，針對個別重要的方法進行源碼解釋說明，修改源碼，使其功能更完善，使用通俗易懂的語言給大家解密Minio源碼的神祕面紗。

如果你對我感興趣，歡迎隨時關注我，點贊，贈人玫瑰，手有餘香，如果你還有任何疑問或者不理解的地方，或者有更好的建議，或大家想了解某方面的知識點，歡迎大家在下方留言，我會第一時間回覆大家！

minio分佈式存儲系列（二）__SpringBoot集成minio API相關使用

minio分佈式存儲系列（二）__SpringBoot集成minio API相關使用

ollama使用

Window 安裝 Python 失敗 0x80070643，發生嚴重錯誤

TiDB Vector 太香啦：以圖搜圖初體驗！

《最新出爐》系列入門篇-Python+Playwright自動化測試-41-錄製視頻

ubuntu20.04安裝百度輸入法，親測有效！

minio分佈式存儲系列（二）__SpringBoot集成minio API相關使用

minio分佈式存儲系列（一）__介紹及開箱使用

ubuntu20.04安裝微信客戶端，親測有效！

ubuntu20.04安裝搜狗輸入法，親測有效！

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結