增加依赖：

  1. <properties>
  2.   <minio.version>4.0.0</minio.version>
  3. </properties>
  4. <dependency>
  5.   <groupId>io.minio</groupId>
  6.   <artifactId>minio</artifactId>
  7.   <version>${minio.version}</version>
  8. </dependency>

增加工具类

  1. public class MinioClientUtils {
  3.     private static final Logger LOGGER = LoggerFactory.getLogger(MinioClientUtils.class);
  5.     private static MinioClientUtils minioClientUtils;
  7.     private MinioClient minioClient;
  9.     private static int RETRY_NUM = 3;
  11.     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\":\"\"}]}";
  13.     public static MinioClientUtils getInstance() {
  14.         if (null != minioClientUtils) {
  15.             return minioClientUtils;
  16.         }
  17.         synchronized (MinioClientUtils.class) {
  18.             if (null == minioClientUtils) {
  19.                 minioClientUtils = new MinioClientUtils();
  20.             }
  21.         }
  22.         return minioClientUtils;
  23.     }
  26.     private MinioClientUtils() {
  27.         init();
  28.     }
  30.     private void init() {
  31.         final Configuration configuration = initConfiguration();
  32.         String url = configuration.getString("minio.url", StringUtils.EMPTY);
  33.         String username = configuration.getString("minio.name", StringUtils.EMPTY);
  34.         String password = configuration.getString("minio.password", StringUtils.EMPTY);
  35.         String region = configuration.getString("minio.region", StringUtils.EMPTY);
  36.         try {
  37.             if (StringUtils.isNotEmpty(url) && StringUtils.isNotEmpty(username) && StringUtils.isNotEmpty(password)) {
  38.                 minioClient = new MinioClient(url, username, password, false);
  39.             }
  40.         } catch (Exception e) {
  41.             LOGGER.error("restClient.close occur error", e);
  42.         }
  44.     }
  46.     public boolean createBucketPublic(String bucketName) {
  47.         boolean isCreated;
  48.         try {
  49. //            if (minioClient.bucketExists(bucketName)) {
  50. //                isCreated = false;
  51. //            }
  52.             minioClient.makeBucket("buzi");
  53.             //minioClient.setBucketPolicy(bucketName, bucketPublicPolicy);
  54.             isCreated = true;
  55.         } catch (Exception e) {
  56.             isCreated = false;
  57.             LOGGER.error("createBucketPublic", e);
  58.             e.printStackTrace();
  59.         }
  60.         return isCreated;
  61.     }
  63.     public String uploadJpegFile(String bucketName, String minioPath, String jpgFilePath) {
  64.         return uploadFile(bucketName, minioPath, jpgFilePath, MediaType.IMAGE_JPEG_VALUE);
  65.     }
  67.     public String uploadJpegStream(String bucketName, String minioPath, InputStream inputStream) {
  68.         return uploadStream(bucketName, minioPath, inputStream, MediaType.IMAGE_JPEG_VALUE);
  69.     }
  71.     public String uploadStream(String bucketName, String minioFilePath, InputStream inputStream, String mediaType) {
  72.         LOGGER.info("uploadStream for bucketName={} minioFilePath={} inputStream.getclass={}, mediaType={}", bucketName,
  73.                 minioFilePath, inputStream.getClass(), mediaType);
  74.         if (StringUtils.isBlank(mediaType)) {
  75.             mediaType = MediaType.APPLICATION_OCTET_STREAM_VALUE;
  76.         }
  77.         try {
  78.             putObjectWithRetry(bucketName, minioFilePath, inputStream, mediaType);
  79.             return cleanUrlByRemoveIp(minioClient.getObjectUrl(bucketName, minioFilePath));
  80.         } catch (Exception e) {
  81.             LOGGER.error("uploadStream occur error:", e);
  82.             throw new RuntimeException(e);
  83.         }
  84.     }
  86.     public String uploadFile(String bucketName, String minioFilePath, String localFile, String mediaType) {
  87.         LOGGER.info("uploadFile for bucketName={} minioFilePath={} localFile={}, mediaType={}", bucketName,
  88.                 minioFilePath, localFile, mediaType);
  89.         if (StringUtils.isBlank(mediaType)) {
  90.             mediaType = MediaType.APPLICATION_OCTET_STREAM_VALUE;
  91.         }
  92.         try {
  93.             putObjectWithRetry(bucketName, minioFilePath, localFile, mediaType);
  94.             return cleanUrlByRemoveIp(minioClient.getObjectUrl(bucketName, minioFilePath));
  95.         } catch (Exception e) {
  96.             LOGGER.error("uploadFile occur error:", e);
  97.             throw new RuntimeException(e);
  98.         }
  99.     }
  101.     public List<MinioEntity> listFilesSwap(String bucketName, String prefix, boolean recursive) {
  102.         LOGGER.info("list files for bucketName={} prefix={} recursive={}", bucketName, prefix, recursive);
  103.         return swapResultToEntityList(minioClient.listObjects(bucketName, prefix, recursive));
  104.     }
  106.     public Iterable<Result<Item>> listFiles(String bucketName, String prefix, boolean recursive) {
  107.         LOGGER.info("list files for bucketName={} prefix={} recursive={}", bucketName, prefix, recursive);
  108.         return minioClient.listObjects(bucketName, prefix, recursive);
  109.     }
  112.     public List<MinioEntity> listFilesByBucketNameSwap(String bucketName) {
  113.         LOGGER.info("listFilesByBucketName for bucketName={}", bucketName);
  114.         return swapResultToEntityList(minioClient.listObjects(bucketName, null, true));
  115.     }
  117.     public Iterable<Result<Item>> listFilesByBucketName(String bucketName) {
  118.         LOGGER.info("listFilesByBucketName for bucketName={}", bucketName);
  119.         return minioClient.listObjects(bucketName, null, true);
  120.     }
  122.     public Iterable<Result<Item>> listFilesByBucketAndPrefix(String bucketName, String prefix) {
  123.         LOGGER.info("listFilesByBucketAndPrefix for bucketName={} and prefix={}", bucketName, prefix);
  124.         return minioClient.listObjects(bucketName, prefix, true);
  125.     }
  127.     public List<MinioEntity> listFilesByBucketAndPrefixSwap(String bucketName, String prefix) {
  128.         LOGGER.info("listFilesByBucketAndPrefix for bucketName={} and prefix={}", bucketName, prefix);
  129.         return swapResultToEntityList(minioClient.listObjects(bucketName, prefix, true));
  130.     }
  132.     private Configuration initConfiguration() {
  133.         ClassLoader classLoader = MinioClientUtils.class.getClassLoader();
  134.         if (null == classLoader) {
  135.             classLoader = Thread.currentThread().getContextClassLoader();
  136.         }
  138.         Configuration configuration = null;
  139.         URL resource = classLoader.getResource("minio.properties");
  140.         if (null == resource) {
  141.             LOGGER.error("can not find minio.properties");
  142.             throw new RuntimeException("can not find minio.properties");
  143.         }
  144.         try {
  145.             configuration = new PropertiesConfiguration(resource);
  146.         } catch (ConfigurationException e) {
  147.             LOGGER.error("load properties from url={} occur error", resource.toString());
  148.             throw new RuntimeException("load properties from url=" + resource.toString() + " occur error", e);
  149.         }
  150.         return configuration;
  151.     }
  153.     private MinioEntity swapResultToEntity(Result<Item> result) {
  154.         MinioEntity minioEntity = new MinioEntity();
  155.         try {
  156.             if (result.get() != null) {
  157.                 Item item = result.get();
  158.                 minioEntity.setObjectName(cleanUrlByRemoveIp(item.objectName()));
  159.                 minioEntity.setDir(item.isDir());
  160.                 minioEntity.setEtag(item.etag());
  161.                 minioEntity.setLastModified(item.lastModified());
  162.                 minioEntity.setSize(item.size());
  163.                 minioEntity.setStorageClass(item.storageClass());
  164.             }
  165.         } catch (Exception e) {
  166.             LOGGER.error("UrlUtils error, e={}", e.getMessage());
  167.         }
  168.         return minioEntity;
  169.     }
  171.     private List<MinioEntity> swapResultToEntityList(Iterable<Result<Item>> results) {
  172.         List<MinioEntity> minioEntities = new ArrayList<>();
  173.         for (Result<Item> result : results) {
  174.             minioEntities.add(swapResultToEntity(result));
  175.         }
  176.         return minioEntities;
  177.     }
  179.     public void putObjectWithRetry(String bucketName, String objectName, InputStream stream, String contentType) throws IOException, InvalidKeyException, NoSuchAlgorithmException, InsufficientDataException, InvalidArgumentException, NoResponseException, InvalidBucketNameException, XmlPullParserException, InternalException {
  180.         int current = 0;
  181.         boolean isSuccess = false;
  182.         while (!isSuccess && current < RETRY_NUM) {
  183.             try {
  184.                 minioClient.putObject(bucketName, objectName, stream, contentType);
  185.                 isSuccess = true;
  186.             } catch (ErrorResponseException e) {
  187.                 LOGGER.warn("[minio] putObject stream, ErrorResponseException occur for time =" + current, e);
  188.                 current++;
  189.             }
  190.         }
  191.         if (current == RETRY_NUM) {
  192.             LOGGER.error("[minio] putObject, backetName={}, objectName={}, failed finally!");
  193.         }
  194.     }
  196.     public void putObjectWithRetry(String bucketName, String objectName, String fileName, String contentType) throws InvalidBucketNameException, NoSuchAlgorithmException, InsufficientDataException, IOException, InvalidKeyException, NoResponseException, XmlPullParserException, ErrorResponseException, InternalException, InvalidArgumentException, InsufficientDataException {
  197.         int current = 0;
  198.         boolean isSuccess = false;
  199.         while (!isSuccess && current < RETRY_NUM) {
  200.             try {
  201.                 minioClient.putObject(bucketName, objectName, fileName, contentType);
  202.                 isSuccess = true;
  203.             } catch (ErrorResponseException e) {
  204.                 current++;
  205.                 LOGGER.debug("[minio] putObject file, ErrorResponseException occur!");
  206.             }
  207.         }
  208.         if (current == RETRY_NUM) {
  209.             LOGGER.error("[minio] putObject, backetName={}, objectName={}, failed finally!");
  210.         }
  211.     }
  213.     public static void main(String[] args) {
  214.         MinioClientUtils.getInstance().createBucketPublic("helo");
  215.     }
  217. }
  220. }

文件上传

  1. public void upload(@RequestParam("file") MulipartFile data,String bucketName,String path){
  2. String fileName = data.getOriginalFilename();
  3. String filePath = path+"/"+fileName;
  4. String contentType = data.getContentType();
  5. InputStream inputStram = data.getInputStream();
  6. MinioClientUtils minioClientUtils = MinioCLinetUtils.getInstance();
  7. minioClientUtils.uploadStream(
  8. bucketName,
  9. filePath,
  10. inputStream,
  11. contentType
  12. );
  14. }