spring boot 集成MinIO上传图片

maven

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

yml

# MinIO配置
minio:
  url: http://192.168.0.184:9000
  accessKey: minioadmin
  secretKey: minioadmin
  bucketName: xrkc
  previewExpiry: 24

config

package com.xrkc.file.config;

import io.minio.MinioClient;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Description:
 * @Auther: wangjiao
 * @Date: 2021-07-12 11:28
 */
@Configuration
@ConfigurationProperties(prefix = "minio")
public class MinIOConfig {
    /**
     * 服务地址
     */
    private String url;

    /**
     * 用户名
     */
    private String accessKey;

    /**
     * 密码
     */
    private String secretKey;

    /**
     * 存储桶名称
     */
    private String bucketName;

    /**
     * 预览到期时间（小时）
     */
    private Integer previewExpiry;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getAccessKey() {
        return accessKey;
    }

    public void setAccessKey(String accessKey) {
        this.accessKey = accessKey;
    }

    public String getSecretKey() {
        return secretKey;
    }

    public void setSecretKey(String secretKey) {
        this.secretKey = secretKey;
    }

    public String getBucketName() {
        return bucketName;
    }

    public void setBucketName(String bucketName) {
        this.bucketName = bucketName;
    }

    public Integer getPreviewExpiry() {
        return previewExpiry;
    }

    public void setPreviewExpiry(Integer previewExpiry) {
        this.previewExpiry = previewExpiry;
    }

    @Bean
    public MinioClient getMinIOClient()
    {
        return MinioClient.builder().endpoint(url).credentials(accessKey, secretKey).build();
    }
}

domain

package com.xrkc.file.domain;

import java.io.Serializable;

/**
 * @Description:
 * @Auther: wangjiao
 * @Date: 2021-07-12 16:41
 */
public class FileVo implements Serializable {
    private String fileName;
    private String previewUrl;
    /**
     * 所属模块（转换为"桶"）
     */
    private String module;

    public String getFileName() {
        return fileName;
    }

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public String getPreviewUrl() {
        return previewUrl;
    }

    public void setPreviewUrl(String previewUrl) {
        this.previewUrl = previewUrl;
    }

    public String getModule() {
        return module;
    }

    public void setModule(String module) {
        this.module = module;
    }
}

package com.xrkc.file.domain;

import org.springframework.web.multipart.MultipartFile;

import java.io.Serializable;

/**
 * @Description:
 * @Auther: wangjiao
 * @Date: 2021-07-12 16:41
 */
public class FileUploadBody implements Serializable {
    /**
     * 多文件
     */
    private MultipartFile[] files;
    /**
     * 所属模块（转换为"桶"）
     */
    private String module;

    public MultipartFile[] getFiles() {
        return files;
    }

    public void setFiles(MultipartFile[] files) {
        this.files = files;
    }

    public String getModule() {
        return module;
    }

    public void setModule(String module) {
        this.module = module;
    }
}

controller

    @Autowired
    private IFileService fileService;

    @PostMapping("/upload")
    public JsonResult upload(FileUploadBody body) {
        List<FileVo> list;
        try {
            list = fileService.uploadFile(body);
        } catch (Exception e) {
            return JsonResult.error("上传失败，请刷新后重试");
        }
        return CollectionUtils.isEmpty(list)?JsonResult.error("要上传的文件不能为空"):JsonResult.success(list);
    }

service

package com.xrkc.file.service;

import com.xrkc.file.domain.FileUploadBody;
import com.xrkc.file.domain.FileVo;

import javax.servlet.http.HttpServletResponse;
import java.util.List;

/**
 * @Description:
 * @Auther: wangjiao
 * @Date: 2021-07-12 11:33
 */
public interface IFileService {
    List<FileVo> uploadFile(FileUploadBody body);

    String getPreviewUrl(String fileName, String bucketName);

    void downloadFile(HttpServletResponse response, String fileName, String bucketName);

    String delFile(String fileName, String bucketName);
}

package com.xrkc.file.service.impl;

import com.alibaba.nacos.common.utils.StringUtils;
import com.xrkc.file.domain.FileUploadBody;
import com.xrkc.file.config.MinIOConfig;
import com.xrkc.file.domain.FileVo;
import com.xrkc.file.service.IFileService;
import io.minio.*;
import io.minio.http.Method;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import org.apache.commons.io.IOUtils;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.net.URLEncoder;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @Description:
 * @Auther: wangjiao
 * @Date: 2021-07-12 11:34
 */
@Service
public class MinIOFileServiceImpl implements IFileService {
    private static final Logger log = LoggerFactory.getLogger(LocalFileServiceImpl.class);
    @Autowired
    private MinIOConfig minIOConfig;
    @Autowired
    private MinioClient minioClient;

    @Override
    public List<FileVo> uploadFile(FileUploadBody body){
        MultipartFile[] files=body.getFiles();
        if (Objects.nonNull(files) && files.length > 0) {
            String bucketName = StringUtils.isNotBlank(body.getModule()) ? body.getModule().replaceAll(",", "") : minIOConfig.getBucketName();
            List<FileVo> resultList = new ArrayList<>();
            for (MultipartFile file : files) {
                try {
                    if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
                        minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
                    }
                    String fileName = file.getOriginalFilename();
                    StringBuffer fileNameSB = new StringBuffer();
                    fileNameSB.append(System.currentTimeMillis()).append("_").append(bucketName).append("_").append(fileName.replaceAll(",", ""));
                    fileName = fileNameSB.toString();
                    PutObjectArgs args = PutObjectArgs.builder()
                            .bucket(bucketName)
                            .object(fileName)
                            .stream(file.getInputStream(), file.getSize(), -1)
                            .contentType(file.getContentType())
                            .build();
                    minioClient.putObject(args);
                    FileVo fileVo=new FileVo();
                    fileVo.setFileName(fileName);
                    fileVo.setModule(bucketName);
                    fileVo.setPreviewUrl(getPreviewUrl(fileName,bucketName));
                    resultList.add(fileVo);
                }catch (Exception e){
                    log.info("上传图片失败：",e.getMessage());
                }
            }
            return resultList;
        }
        return null;
    }

    @Override
    public String getPreviewUrl(String fileName, String bucketName) {
        if (StringUtils.isNotBlank(fileName)) {
            bucketName = StringUtils.isNotBlank(bucketName) ? bucketName : minIOConfig.getBucketName();
            try {
                minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(fileName).build());
                return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().method(Method.GET).bucket(bucketName).object(fileName).expiry(minIOConfig.getPreviewExpiry(), TimeUnit.HOURS).build());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    @Override
    public void downloadFile(HttpServletResponse response, String fileName, String bucketName) {
        if (StringUtils.isNotBlank(fileName)) {
            bucketName = StringUtils.isNotBlank(bucketName) ? bucketName : minIOConfig.getBucketName();
            try {
                StatObjectResponse statObjectResponse = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(fileName).build());
                response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
                response.setContentType(statObjectResponse.contentType());
                response.setCharacterEncoding("UTF-8");
                InputStream inputStream = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileName).build());
                IOUtils.copy(inputStream, response.getOutputStream());
            } catch (Exception e) {
            }
        }
    }

    @Override
    public String delFile(String fileName, String bucketName) {
        if (StringUtils.isNotBlank(fileName)) {
            bucketName = StringUtils.isNotBlank(bucketName) ? bucketName : minIOConfig.getBucketName();
            try {
                minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build());
                return "success";
            }catch (Exception e) {
                return "删除文件失败，请刷新后重试";
                }
        }
        return "文件不能为空";
    }
}