springboot整合minio使用

docker部署minio
cd /usr/local/docker/minio 下创建
docker-compose.yaml
version版本3.7太高改成3.1

version: '3.1'
# starts 4 docker containers running minio server instances. Each
# minio server's web interface will be accessible on the host at port
# 9001 through 9004.
services:
  minio1:
    image: minio/minio:RELEASE.2020-03-25T07-03-04Z
    volumes:
      - data1-1:/data1
      - data1-2:/data2
    ports:
      - "9001:9000"
    environment:
      MINIO_ACCESS_KEY: minio
      MINIO_SECRET_KEY: minio123
    command: server http://minio{1...4}/data{1...2}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3
  minio2:
    image: minio/minio:RELEASE.2020-03-25T07-03-04Z
    volumes:
      - data2-1:/data1
      - data2-2:/data2
    ports:
      - "9002:9000"
    environment:
      MINIO_ACCESS_KEY: minio
      MINIO_SECRET_KEY: minio123
    command: server http://minio{1...4}/data{1...2}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3
  minio3:
    image: minio/minio:RELEASE.2020-03-25T07-03-04Z
    volumes:
      - data3-1:/data1
      - data3-2:/data2
    ports:
      - "9003:9000"
    environment:
      MINIO_ACCESS_KEY: minio
      MINIO_SECRET_KEY: minio123
    command: server http://minio{1...4}/data{1...2}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3
  minio4:
    image: minio/minio:RELEASE.2020-03-25T07-03-04Z
    volumes:
      - data4-1:/data1
      - data4-2:/data2
    ports:
      - "9004:9000"
    environment:
      MINIO_ACCESS_KEY: minio
      MINIO_SECRET_KEY: minio123
    command: server http://minio{1...4}/data{1...2}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3
## By default this config uses default local driver,
## For custom volumes replace with volume driver configuration.
volumes:
  data1-1:
  data1-2:
  data2-1:
  data2-2:
  data3-1:
  data3-2:
  data4-1:
  data4-2:

部署后 执行下面语句就ok 登录本地127.0.0.1:9001 -9004
Linux

docker-compose pull
docker-compose up

登录账号:
minio
密码;
minio123
这样简单的就可以使用java操作了
依赖

<properties>
    <minio.version>4.0.0</minio.version>
</properties>
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>${minio.version}</version>
</dependency>

快速入门操作

package com.example.demo1.controller;
import io.minio.MinioClient;
public class MinioDemo {
    public static void main(String[] args) {
        try {
            // 参数为：minio服务器路径，账号，密码
            MinioClient minioClient = new MinioClient("http://118.190.111.100:9001", "minio", "minio123");
            // 检查文件夹是否已经存在
            boolean isExist = minioClient.bucketExists("managertest");
            if(isExist) {
                System.out.println("文件夹已经存在了");
            }
            else {
                // 创建一个名为managertest的文件夹
                System.out.println("文件夹还没存在");
                minioClient.makeBucket("managertest");
            }
            // 使用putObject上传一个文件到文件夹中。
            //参数为：managertest:文件夹，1.png:文件存储的名字;要存的文件路径
            minioClient.putObject("managertest","1.png", "E:\\文档\\doc\\111.png");
            System.out.println("成功了");
            //使用getObject获取一个文件
            // 调用statObject()来判断对象是否存在。
            minioClient.statObject("managertest", "1.png");
            // 获取1.png的流并保存到photo.png文件中。
            //参数为：文件夹，要获得的文件，要写入的文件
            minioClient.getObject("managertest", "1.png", "E:/2.png");
        }catch (Exception e){
          e.printStackTrace();
        }
    }
}

已经上传到服务器了,而且下载也是成功的

MinioUtils工具类

public class MinioClientUtils {
 
    private static final Logger LOGGER = LoggerFactory.getLogger(MinioClientUtils.class);
 
    private static MinioClientUtils minioClientUtils;
 
    private MinioClient minioClient;
 
    private static int RETRY_NUM = 3;
 
    private static final String bucketPublicPolicy = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Action\":[\"s3:GetBucketLocation\",\"s3:ListBucket\",\"s3:ListBucketMultipartUploads\"],\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Resource\":[\"arn:aws:s3:::test\"],\"Sid\":\"\"},{\"Action\":[\"s3:AbortMultipartUpload\",\"s3:DeleteObject\",\"s3:GetObject\",\"s3:ListMultipartUploadParts\",\"s3:PutObject\"],\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Resource\":[\"arn:aws:s3:::test/*\"],\"Sid\":\"\"}]}";
 
    public static MinioClientUtils getInstance() {
        if (null != minioClientUtils) {
            return minioClientUtils;
        }
        synchronized (MinioClientUtils.class) {
            if (null == minioClientUtils) {
                minioClientUtils = new MinioClientUtils();
            }
        }
        return minioClientUtils;
    }
 
 
    private MinioClientUtils() {
        init();
    }
 
    private void init() {
        final Configuration configuration = initConfiguration();
        String url = configuration.getString("minio.url", StringUtils.EMPTY);
        String username = configuration.getString("minio.name", StringUtils.EMPTY);
        String password = configuration.getString("minio.password", StringUtils.EMPTY);
        String region = configuration.getString("minio.region", StringUtils.EMPTY);
        try {
            if (StringUtils.isNotEmpty(url) && StringUtils.isNotEmpty(username) && StringUtils.isNotEmpty(password)) {
                minioClient = new MinioClient(url, username, password, false);
            }
        } catch (Exception e) {
            LOGGER.error("restClient.close occur error", e);
        }
 
    }
 
    public boolean createBucketPublic(String bucketName) {
        boolean isCreated;
        try {
//            if (minioClient.bucketExists(bucketName)) {
//                isCreated = false;
//            }
            minioClient.makeBucket("buzi");
            //minioClient.setBucketPolicy(bucketName, bucketPublicPolicy);
            isCreated = true;
        } catch (Exception e) {
            isCreated = false;
            LOGGER.error("createBucketPublic", e);
            e.printStackTrace();
        }
        return isCreated;
    }
 
    public String uploadJpegFile(String bucketName, String minioPath, String jpgFilePath) {
        return uploadFile(bucketName, minioPath, jpgFilePath, MediaType.IMAGE_JPEG_VALUE);
    }
 
    public String uploadJpegStream(String bucketName, String minioPath, InputStream inputStream) {
        return uploadStream(bucketName, minioPath, inputStream, MediaType.IMAGE_JPEG_VALUE);
    }
 
    public String uploadStream(String bucketName, String minioFilePath, InputStream inputStream, String mediaType) {
        LOGGER.info("uploadStream for bucketName={} minioFilePath={} inputStream.getclass={}, mediaType={}", bucketName,
                minioFilePath, inputStream.getClass(), mediaType);
        if (StringUtils.isBlank(mediaType)) {
            mediaType = MediaType.APPLICATION_OCTET_STREAM_VALUE;
        }
        try {
            putObjectWithRetry(bucketName, minioFilePath, inputStream, mediaType);
            return cleanUrlByRemoveIp(minioClient.getObjectUrl(bucketName, minioFilePath));
        } catch (Exception e) {
            LOGGER.error("uploadStream occur error:", e);
            throw new RuntimeException(e);
        }
    }
 
    public String uploadFile(String bucketName, String minioFilePath, String localFile, String mediaType) {
        LOGGER.info("uploadFile for bucketName={} minioFilePath={} localFile={}, mediaType={}", bucketName,
                minioFilePath, localFile, mediaType);
        if (StringUtils.isBlank(mediaType)) {
            mediaType = MediaType.APPLICATION_OCTET_STREAM_VALUE;
        }
        try {
            putObjectWithRetry(bucketName, minioFilePath, localFile, mediaType);
            return cleanUrlByRemoveIp(minioClient.getObjectUrl(bucketName, minioFilePath));
        } catch (Exception e) {
            LOGGER.error("uploadFile occur error:", e);
            throw new RuntimeException(e);
        }
    }
 
    public List<MinioEntity> listFilesSwap(String bucketName, String prefix, boolean recursive) {
        LOGGER.info("list files for bucketName={} prefix={} recursive={}", bucketName, prefix, recursive);
        return swapResultToEntityList(minioClient.listObjects(bucketName, prefix, recursive));
    }
 
    public Iterable<Result<Item>> listFiles(String bucketName, String prefix, boolean recursive) {
        LOGGER.info("list files for bucketName={} prefix={} recursive={}", bucketName, prefix, recursive);
        return minioClient.listObjects(bucketName, prefix, recursive);
    }
 
 
    public List<MinioEntity> listFilesByBucketNameSwap(String bucketName) {
        LOGGER.info("listFilesByBucketName for bucketName={}", bucketName);
        return swapResultToEntityList(minioClient.listObjects(bucketName, null, true));
    }
 
    public Iterable<Result<Item>> listFilesByBucketName(String bucketName) {
        LOGGER.info("listFilesByBucketName for bucketName={}", bucketName);
        return minioClient.listObjects(bucketName, null, true);
    }
 
    public Iterable<Result<Item>> listFilesByBucketAndPrefix(String bucketName, String prefix) {
        LOGGER.info("listFilesByBucketAndPrefix for bucketName={} and prefix={}", bucketName, prefix);
        return minioClient.listObjects(bucketName, prefix, true);
    }
 
    public List<MinioEntity> listFilesByBucketAndPrefixSwap(String bucketName, String prefix) {
        LOGGER.info("listFilesByBucketAndPrefix for bucketName={} and prefix={}", bucketName, prefix);
        return swapResultToEntityList(minioClient.listObjects(bucketName, prefix, true));
    }
 
    private Configuration initConfiguration() {
        ClassLoader classLoader = MinioClientUtils.class.getClassLoader();
        if (null == classLoader) {
            classLoader = Thread.currentThread().getContextClassLoader();
        }
 
        Configuration configuration = null;
        URL resource = classLoader.getResource("minio.properties");
        if (null == resource) {
            LOGGER.error("can not find minio.properties");
            throw new RuntimeException("can not find minio.properties");
        }
        try {
            configuration = new PropertiesConfiguration(resource);
        } catch (ConfigurationException e) {
            LOGGER.error("load properties from url={} occur error", resource.toString());
            throw new RuntimeException("load properties from url=" + resource.toString() + " occur error", e);
        }
        return configuration;
    }
 
    private MinioEntity swapResultToEntity(Result<Item> result) {
        MinioEntity minioEntity = new MinioEntity();
        try {
            if (result.get() != null) {
                Item item = result.get();
                minioEntity.setObjectName(cleanUrlByRemoveIp(item.objectName()));
                minioEntity.setDir(item.isDir());
                minioEntity.setEtag(item.etag());
                minioEntity.setLastModified(item.lastModified());
                minioEntity.setSize(item.size());
                minioEntity.setStorageClass(item.storageClass());
            }
        } catch (Exception e) {
            LOGGER.error("UrlUtils error, e={}", e.getMessage());
        }
        return minioEntity;
    }
 
    private List<MinioEntity> swapResultToEntityList(Iterable<Result<Item>> results) {
        List<MinioEntity> minioEntities = new ArrayList<>();
        for (Result<Item> result : results) {
            minioEntities.add(swapResultToEntity(result));
        }
        return minioEntities;
    }
 
    public void putObjectWithRetry(String bucketName, String objectName, InputStream stream, String contentType) throws IOException, InvalidKeyException, NoSuchAlgorithmException, InsufficientDataException, InvalidArgumentException, NoResponseException, InvalidBucketNameException, XmlPullParserException, InternalException {
        int current = 0;
        boolean isSuccess = false;
        while (!isSuccess && current < RETRY_NUM) {
            try {
                minioClient.putObject(bucketName, objectName, stream, contentType);
                isSuccess = true;
            } catch (ErrorResponseException e) {
                LOGGER.warn("[minio] putObject stream, ErrorResponseException occur for time =" + current, e);
                current++;
            }
        }
        if (current == RETRY_NUM) {
            LOGGER.error("[minio] putObject, backetName={}, objectName={}, failed finally!");
        }
    }
 
    public void putObjectWithRetry(String bucketName, String objectName, String fileName, String contentType) throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException, InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException, InternalException, InvalidArgumentException, InsufficientDataException {
        int current = 0;
        boolean isSuccess = false;
        while (!isSuccess && current < RETRY_NUM) {
            try {
                minioClient.putObject(bucketName, objectName, fileName, contentType);
                isSuccess = true;
            } catch (ErrorResponseException e) {
                current++;
                LOGGER.debug("[minio] putObject file, ErrorResponseException occur!");
            }
        }
        if (current == RETRY_NUM) {
            LOGGER.error("[minio] putObject, backetName={}, objectName={}, failed finally!");
        }
    }
 
    public static void main(String[] args) {
        MinioClientUtils.getInstance().createBucketPublic("helo");
    }
 
}
 }

controller

public void upload(@RequestParam("file") MulipartFile data,String bucketName,String path){
String fileName = data.getOriginalFilename();
String filePath = path+"/"+fileName;
String contentType = data.getContentType();
InputStream inputStram = data.getInputStream();
MinioClientUtils minioClientUtils = MinioCLinetUtils.getInstance();
minioClientUtils.uploadStream(
bucketName,
filePath,
inputStream,
contentType
);
 
}

这样就可以简单的crud了. 复杂的还需要看文档哦.