封装MinIO为starter

「工具类」https://www.aliyundrive.com/s/KY19YRm71jE
内有MinIO starter

3.5.1 创建模块heima-file-starter

导入依赖

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-autoconfigure</artifactId>
  5.     </dependency>
  6.     <dependency>
  7.         <groupId>io.minio</groupId>
  8.         <artifactId>minio</artifactId>
  9.         <version>7.1.0</version>
  10.     </dependency>
  11.     <dependency>
  12.         <groupId>org.springframework.boot</groupId>
  13.         <artifactId>spring-boot-starter</artifactId>
  14.     </dependency>
  15.     <dependency>
  16.         <groupId>org.springframework.boot</groupId>
  17.         <artifactId>spring-boot-configuration-processor</artifactId>
  18.         <optional>true</optional>
  19.     </dependency>
  20.     <dependency>
  21.         <groupId>org.springframework.boot</groupId>
  22.         <artifactId>spring-boot-starter-actuator</artifactId>
  23.     </dependency>
  24. </dependencies>

3.5.2 配置类

MinIOConfigProperties

  1. package com.heima.file.config;
  4. import lombok.Data;
  5. import org.springframework.boot.context.properties.ConfigurationProperties;
  7. import java.io.Serializable;
  9. @Data
  10. @ConfigurationProperties(prefix = "minio")  // 文件上传 配置前缀file.oss
  11. public class MinIOConfigProperties implements Serializable {
  13.     private String accessKey;
  14.     private String secretKey;
  15.     private String bucket;
  16.     private String endpoint;
  17.     private String readPath;
  18. }

MinIOConfig

  1. package com.heima.file.config;
  3. import com.heima.file.service.FileStorageService;
  4. import io.minio.MinioClient;
  5. import lombok.Data;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
  8. import org.springframework.boot.context.properties.EnableConfigurationProperties;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  13. @Data
  14. @Configuration
  15. @EnableConfigurationProperties({MinIOConfigProperties.class})
  16. //当引入FileStorageService接口时
  17. @ConditionalOnClass(FileStorageService.class)
  18. public class MinIOConfig {
  20.    @Autowired
  21.    private MinIOConfigProperties minIOConfigProperties;
  23.     @Bean
  24.     public MinioClient buildMinioClient(){
  25.         return MinioClient
  26.                 .builder()
  27.                 .credentials(minIOConfigProperties.getAccessKey(), minIOConfigProperties.getSecretKey())
  28.                 .endpoint(minIOConfigProperties.getEndpoint())
  29.                 .build();
  30.     }
  31. }

3.5.3 封装操作minIO类

FileStorageService

  1. package com.heima.file.service;
  3. import java.io.InputStream;
  5. /**
  6.  * @author itheima
  7.  */
  8. public interface FileStorageService {
  11.     /**
  12.      *  上传图片文件
  13.      * @param prefix  文件前缀
  14.      * @param filename  文件名
  15.      * @param inputStream 文件流
  16.      * @return  文件全路径
  17.      */
  18.     public String uploadImgFile(String prefix, String filename,InputStream inputStream);
  20.     /**
  21.      *  上传html文件
  22.      * @param prefix  文件前缀
  23.      * @param filename   文件名
  24.      * @param inputStream  文件流
  25.      * @return  文件全路径
  26.      */
  27.     public String uploadHtmlFile(String prefix, String filename,InputStream inputStream);
  29.     /**
  30.      * 删除文件
  31.      * @param pathUrl  文件全路径
  32.      */
  33.     public void delete(String pathUrl);
  35.     /**
  36.      * 下载文件
  37.      * @param pathUrl  文件全路径
  38.      * @return
  39.      *
  40.      */
  41.     public byte[]  downLoadFile(String pathUrl);
  43. }

MinIOFileStorageService

  1. package com.heima.file.service.impl;
  4. import com.heima.file.config.MinIOConfig;
  5. import com.heima.file.config.MinIOConfigProperties;
  6. import com.heima.file.service.FileStorageService;
  7. import io.minio.GetObjectArgs;
  8. import io.minio.MinioClient;
  9. import io.minio.PutObjectArgs;
  10. import io.minio.RemoveObjectArgs;
  11. import lombok.extern.slf4j.Slf4j;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.boot.context.properties.EnableConfigurationProperties;
  14. import org.springframework.context.annotation.Import;
  15. import org.springframework.util.StringUtils;
  17. import java.io.ByteArrayOutputStream;
  18. import java.io.IOException;
  19. import java.io.InputStream;
  20. import java.text.SimpleDateFormat;
  21. import java.util.Date;
  23. @Slf4j
  24. @EnableConfigurationProperties(MinIOConfigProperties.class)
  25. @Import(MinIOConfig.class)
  26. public class MinIOFileStorageService implements FileStorageService {
  28.     @Autowired
  29.     private MinioClient minioClient;
  31.     @Autowired
  32.     private MinIOConfigProperties minIOConfigProperties;
  34.     private final static String separator = "/";
  36.     /**
  37.      * @param dirPath
  38.      * @param filename  yyyy/mm/dd/file.jpg
  39.      * @return
  40.      */
  41.     public String builderFilePath(String dirPath,String filename) {
  42.         StringBuilder stringBuilder = new StringBuilder(50);
  43.         if(!StringUtils.isEmpty(dirPath)){
  44.             stringBuilder.append(dirPath).append(separator);
  45.         }
  46.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
  47.         String todayStr = sdf.format(new Date());
  48.         stringBuilder.append(todayStr).append(separator);
  49.         stringBuilder.append(filename);
  50.         return stringBuilder.toString();
  51.     }
  53.     /**
  54.      *  上传图片文件
  55.      * @param prefix  文件前缀
  56.      * @param filename  文件名
  57.      * @param inputStream 文件流
  58.      * @return  文件全路径
  59.      */
  60.     @Override
  61.     public String uploadImgFile(String prefix, String filename,InputStream inputStream) {
  62.         String filePath = builderFilePath(prefix, filename);
  63.         try {
  64.             PutObjectArgs putObjectArgs = PutObjectArgs.builder()
  65.                     .object(filePath)
  66.                     .contentType("image/jpg")
  67.                     .bucket(minIOConfigProperties.getBucket()).stream(inputStream,inputStream.available(),-1)
  68.                     .build();
  69.             minioClient.putObject(putObjectArgs);
  70.             StringBuilder urlPath = new StringBuilder(minIOConfigProperties.getReadPath());
  71.             urlPath.append(separator+minIOConfigProperties.getBucket());
  72.             urlPath.append(separator);
  73.             urlPath.append(filePath);
  74.             return urlPath.toString();
  75.         }catch (Exception ex){
  76.             log.error("minio put file error.",ex);
  77.             throw new RuntimeException("上传文件失败");
  78.         }
  79.     }
  81.     /**
  82.      *  上传html文件
  83.      * @param prefix  文件前缀
  84.      * @param filename   文件名
  85.      * @param inputStream  文件流
  86.      * @return  文件全路径
  87.      */
  88.     @Override
  89.     public String uploadHtmlFile(String prefix, String filename,InputStream inputStream) {
  90.         String filePath = builderFilePath(prefix, filename);
  91.         try {
  92.             PutObjectArgs putObjectArgs = PutObjectArgs.builder()
  93.                     .object(filePath)
  94.                     .contentType("text/html")
  95.                     .bucket(minIOConfigProperties.getBucket()).stream(inputStream,inputStream.available(),-1)
  96.                     .build();
  97.             minioClient.putObject(putObjectArgs);
  98.             StringBuilder urlPath = new StringBuilder(minIOConfigProperties.getReadPath());
  99.             urlPath.append(separator+minIOConfigProperties.getBucket());
  100.             urlPath.append(separator);
  101.             urlPath.append(filePath);
  102.             return urlPath.toString();
  103.         }catch (Exception ex){
  104.             log.error("minio put file error.",ex);
  105.             ex.printStackTrace();
  106.             throw new RuntimeException("上传文件失败");
  107.         }
  108.     }
  110.     /**
  111.      * 删除文件
  112.      * @param pathUrl  文件全路径
  113.      */
  114.     @Override
  115.     public void delete(String pathUrl) {
  116.         String key = pathUrl.replace(minIOConfigProperties.getEndpoint()+"/","");
  117.         int index = key.indexOf(separator);
  118.         String bucket = key.substring(0,index);
  119.         String filePath = key.substring(index+1);
  120.         // 删除Objects
  121.         RemoveObjectArgs removeObjectArgs = RemoveObjectArgs.builder().bucket(bucket).object(filePath).build();
  122.         try {
  123.             minioClient.removeObject(removeObjectArgs);
  124.         } catch (Exception e) {
  125.             log.error("minio remove file error.  pathUrl:{}",pathUrl);
  126.             e.printStackTrace();
  127.         }
  128.     }
  131.     /**
  132.      * 下载文件
  133.      * @param pathUrl  文件全路径
  134.      * @return  文件流
  135.      *
  136.      */
  137.     @Override
  138.     public byte[] downLoadFile(String pathUrl)  {
  139.         String key = pathUrl.replace(minIOConfigProperties.getEndpoint()+"/","");
  140.         int index = key.indexOf(separator);
  141.         String bucket = key.substring(0,index);
  142.         String filePath = key.substring(index+1);
  143.         InputStream inputStream = null;
  144.         try {
  145.             inputStream = minioClient.getObject(GetObjectArgs.builder().bucket(minIOConfigProperties.getBucket()).object(filePath).build());
  146.         } catch (Exception e) {
  147.             log.error("minio down file error.  pathUrl:{}",pathUrl);
  148.             e.printStackTrace();
  149.         }
  151.         ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
  152.         byte[] buff = new byte[100];
  153.         int rc = 0;
  154.         while (true) {
  155.             try {
  156.                 if (!((rc = inputStream.read(buff, 0, 100)) > 0)) break;
  157.             } catch (IOException e) {
  158.                 e.printStackTrace();
  159.             }
  160.             byteArrayOutputStream.write(buff, 0, rc);
  161.         }
  162.         return byteArrayOutputStream.toByteArray();
  163.     }
  164. }

3.5.4 对外加入自动配置

在resources中新建META-INF/spring.factories

  1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  2.   com.heima.file.service.impl.MinIOFileStorageService

3.5.5 其他微服务使用

第一，导入heima-file-starter的依赖

第二，在微服务中添加minio所需要的配置

  1. minio:
  2.   accessKey: minio
  3.   secretKey: minio123
  4.   bucket: leadnews
  5.   endpoint: http://192.168.200.130:9000
  6.   readPath: http://192.168.200.130:9000

第三，在对应使用的业务类中注入FileStorageService，样例如下：

  1. package com.heima.minio.test;
  4. import com.heima.file.service.FileStorageService;
  5. import com.heima.minio.MinioApplication;
  6. import org.junit.Test;
  7. import org.junit.runner.RunWith;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.boot.test.context.SpringBootTest;
  10. import org.springframework.test.context.junit4.SpringRunner;
  12. import java.io.FileInputStream;
  13. import java.io.FileNotFoundException;
  15. @SpringBootTest(classes = MinioApplication.class)
  16. @RunWith(SpringRunner.class)
  17. public class MinioTest {
  19.     @Autowired
  20.     private FileStorageService fileStorageService;
  22.     @Test
  23.     public void testUpdateImgFile() {
  24.         try {
  25.             FileInputStream fileInputStream = new FileInputStream("E:\\tmp\\ak47.jpg");
  26.             String filePath = fileStorageService.uploadImgFile("", "ak47.jpg", fileInputStream);
  27.             System.out.println(filePath);
  28.         } catch (FileNotFoundException e) {
  29.             e.printStackTrace();
  30.         }
  31.     }
  32. }