springboot+minio文件上传下载工具类

引入依赖

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

配置文件

minio:
  end-point: http://localhost:9000
  access-key: minioadmin
  secret-key: minioadmin

工具类

import com.google.common.io.ByteStreams;
import io.minio.*;
import io.minio.errors.*;
import io.minio.http.Method;
import io.minio.messages.Item;
import lombok.Getter;
import lombok.Setter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.PostConstruct;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;

/**
 * @author cheng
 */
@Component
@Setter
@Getter
public class MinIoUtils {

    /**
     * minIo的连接信息
     */

    @Value("${minio.end-point}")
    private String endPoint;

    @Value("${minio.access-key}")
    private String accessKey;

    @Value("${minio.secret-key}")
    private String secretKey;

    static MinioClient minioClient;

    @PostConstruct
    public void initClient() {
        //建立minIO连接
        minioClient = MinioClient.builder()
                .endpoint(endPoint)
                .credentials(accessKey, secretKey)
                .build();
    }

    /**
     * 获取所有文件名
     *
     * @param bucket 存储文件夹
     * @return
     */
    public static List<String> findFiles(String bucket) {
        try {
            // 检查 bucket是否存在。
            BucketExistsArgs bucketExistsArgs = BucketExistsArgs.builder().bucket(bucket).build();
            boolean found = minioClient.bucketExists(bucketExistsArgs);
            if (found) {
                // 列出bucket里的对象
                ListObjectsArgs listObjectsArgs = ListObjectsArgs.builder()
                        //指定文件桶
                        .bucket(bucket)
                        //是否递归查找
                        .recursive(true).build();
                Iterable<Result<Item>> myObjects = minioClient.listObjects(listObjectsArgs);
                List<String> files = new ArrayList<>();
                //遍历查询结果，返回结果中的所有文件
                for (Result<Item> result : myObjects) {
                    Item item = result.get();
                    if (item.objectName().contains(".")) {
                        files.add(item.objectName());
                    }
                }
                return files;
            }
        } catch (Exception e) {
            System.err.println("minIO connect error, please try again later");
        }
        return null;
    }

    /**
     * 文件下载（浏览器端下载）
     *
     * @param bucket
     * @param url
     * @param response
     * @throws Exception
     */
    public static void download(String bucket, String url, HttpServletResponse response) throws Exception {
        // 根据文件夹名称和路径找到对应文件对象
        ObjectStat state = minioClient.statObject(StatObjectArgs.builder().bucket(bucket).object(url).build());
        byte[] buffer = new byte[1024];
        int length = (int) state.length();
        try (InputStream inputStream = minioClient.getObject(GetObjectArgs.builder().bucket(bucket).object(url).build());
             ByteArrayOutputStream outputStream = new ByteArrayOutputStream(length)) {
            ByteStreams.copy(inputStream, outputStream);
            buffer = outputStream.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        }
        response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
        response.setHeader("Content-disposition", "attachment; filename=" + new String(url.getBytes("utf-8"), "ISO8859-1"));
        response.getOutputStream().write(buffer);
        response.flushBuffer();
        response.getOutputStream().close();
    }

    /**
     * 文件上传
     *
     * @param file       文件
     * @param bucketName 文件夹名称（minio上对应的bucket相当于文件夹）
     * @return
     * @throws Exception
     */
    public static String uploadFile(MultipartFile file, String bucketName) throws Exception {
        // 判断上传文件是否为空
        if (null == file || 0 == file.getSize()) {
            return null;
        }
        // 判断文件夹是否存在
        boolean bucketExists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        // 如果文件夹不存在则创建
        if (!bucketExists) {
            // 创建
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        }
        //获取当前时间戳
        long l = System.currentTimeMillis();
        // 文件名
        String originalFilename = l + "_" + file.getOriginalFilename();
        // 上传操作
        minioClient.putObject(PutObjectArgs.builder()
                .bucket(bucketName)
                .object(originalFilename)
                .stream(file.getInputStream(), file.getSize(), 0L)
                .build());
        return originalFilename;
    }

    /**
     * 删除文件
     *
     * @param bucketName 文件夹名称
     * @param fileName   文件名称
     * @return
     * @throws Exception
     */
    public static void removeFile(String bucketName, String fileName) throws Exception {
        // 删除文件夹下的对应文件
        minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build());
    }

    public static String getObjectByte(String bucket, String url) throws Exception {
        byte[] buffer = new byte[1024 * 1024];
        StringBuilder sb = new StringBuilder();
        try (InputStream inputStream = minioClient.getObject(GetObjectArgs.builder().bucket(bucket).object(url).build())) {
            int i = 0;
            while ((i = inputStream.read(buffer)) != -1) {
                sb.append(new String(buffer, 0, i));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sb.toString();
    }

    /**
     * 获取文件的浏览路径
     * @author suyanqi
     * @date 2022/7/8 16:33
     * @param bucketName
     * @param fileName
     * @return java.lang.String
     */
    public static String getPreviewFileUrl(String bucketName, String fileName) {
        String previewFileUrl = "";
        try {
            previewFileUrl = minioClient.getPresignedObjectUrl(
                    GetPresignedObjectUrlArgs.builder()
                            .method(Method.GET)
                            .bucket(bucketName)
                            .object(fileName)
                            .build());
        } catch (ErrorResponseException | InsufficientDataException | InternalException
                | InvalidBucketNameException | InvalidExpiresRangeException | InvalidKeyException
                | InvalidResponseException | IOException | NoSuchAlgorithmException
                | XmlParserException | ServerException e) {
            e.printStackTrace();
        }
        return previewFileUrl;
    }
}