SpringBoot：整合 Minio 文件上传操作

刺骨的言语ヽ痛彻心扉 2023-10-12 20:26 11阅读 0赞

### 简介 ###

*  对象存储服务OSS（Object Storage Service）是一种海量、安全、低成本、高可靠的云存储服务，适合存放任意类型的文件。容量和处理能力弹性扩展，多种存储类型供选择，全面优化存储成本，今天我这里主要讲解SpringBoot如何集成MinIO。

### 引入依赖 ###

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

### yml文件配置 ###

spring:
      # 配置文件上传大小限制
      servlet:
        multipart:
          max-file-size: 200MB
          max-request-size: 200MB
    minio:
      endpoint: http://127.0.0.1:9000
      accessKey: minioadmin
      secretKey: minioadmin
      bucketName: test

### 编写配置类 ###

@Data
    @Component
    public class MinIoClientConfig {
        
        @Value("${minio.endpoint}")
        private String endpoint;
        @Value("${minio.accessKey}")
        private String accessKey;
        @Value("${minio.secretKey}")
        private String secretKey;
     
        /**
         * 注入minio 客户端
         * @return
         */
        @Bean
        public MinioClient minioClient(){
        
     
            return MinioClient.builder()
                    .endpoint(endpoint)
                    .credentials(accessKey, secretKey)
                    .build();
        }
     
    }

### 编写工具类 ###

@Data
    public class ObjectItem {
        
        private String objectName;
        private Long size;
    }
    
    /**
     * @description:
     */
    @Component
    @Slf4j
    @RequiredArgsConstructor
    public class MinioUtil {
        
        final MinIoClientConfig prop;
    
        final MinioClient minioClient;
    
        /**
         * 查看存储bucket是否存在
         * @return boolean
         */
        public Boolean bucketExists(String bucketName) {
        
            Boolean found;
            try {
        
                found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
            return found;
        }
    
        /**
         * 创建存储bucket
         * @return Boolean
         */
        public Boolean makeBucket(String bucketName) {
        
            try {
        
                minioClient.makeBucket(MakeBucketArgs.builder()
                        .bucket(bucketName)
                        .build());
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
            return true;
        }
        /**
         * 删除存储bucket
         * @return Boolean
         */
        public Boolean removeBucket(String bucketName) {
        
            try {
        
                minioClient.removeBucket(RemoveBucketArgs.builder()
                        .bucket(bucketName)
                        .build());
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
            return true;
        }
        /**
         * 获取全部bucket
         */
        public List<Bucket> getAllBuckets() {
        
            try {
        
                List<Bucket> buckets = minioClient.listBuckets();
                return buckets;
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 文件上传
         *
         * @param file 文件
         * @return Boolean
         */
        public String upload(MultipartFile file) {
        
            String originalFilename = file.getOriginalFilename();
            if (StringUtils.isBlank(originalFilename)){
        
                throw new RuntimeException();
            }
            String fileName = UuidUtils.generateUuid() + originalFilename.substring(originalFilename.lastIndexOf("."));
            String objectName = DateUtils.getDayStr() + "/" + fileName;
            try {
        
                PutObjectArgs objectArgs = PutObjectArgs.builder().bucket(prop.getBucketName()).object(objectName)
                        .stream(file.getInputStream(), file.getSize(), -1).contentType(file.getContentType()).build();
                //文件名称相同会覆盖
                minioClient.putObject(objectArgs);
            } catch (Exception e) {
        
                e.printStackTrace();
                return null;
            }
            return objectName;
        }
    
        /**
         * 预览
         * @param fileName
         * @return
         */
        public String preview(String fileName){
        
            // 查看文件地址
            GetPresignedObjectUrlArgs build = new GetPresignedObjectUrlArgs().builder().bucket(prop.getBucketName()).object(fileName).method(Method.GET).build();
            try {
        
                String url = minioClient.getPresignedObjectUrl(build);
                return url;
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 文件下载
         * @param fileName 文件名称
         * @param res response
         * @return Boolean
         */
        public void download(String fileName, HttpServletResponse res) {
        
            GetObjectArgs objectArgs = GetObjectArgs.builder().bucket(prop.getBucketName())
                    .object(fileName).build();
            try (GetObjectResponse response = minioClient.getObject(objectArgs)){
        
                byte[] buf = new byte[1024];
                int len;
                try (FastByteArrayOutputStream os = new FastByteArrayOutputStream()){
        
                    while ((len=response.read(buf))!=-1){
        
                        os.write(buf,0,len);
                    }
                    os.flush();
                    byte[] bytes = os.toByteArray();
                    res.setCharacterEncoding("utf-8");
                    // 设置强制下载不打开
                    // res.setContentType("application/force-download");
                    res.addHeader("Content-Disposition", "attachment;fileName=" + fileName);
                    try (ServletOutputStream stream = res.getOutputStream()){
        
                        stream.write(bytes);
                        stream.flush();
                    }
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    
        /**
         * 查看文件对象
         * @return 存储bucket内文件对象信息
         */
        public List<Item> listObjects() {
        
            Iterable<Result<Item>> results = minioClient.listObjects(
                    ListObjectsArgs.builder().bucket(prop.getBucketName()).build());
            List<Item> items = new ArrayList<>();
            try {
        
                for (Result<Item> result : results) {
        
                    items.add(result.get());
                }
            } catch (Exception e) {
        
                e.printStackTrace();
                return null;
            }
            return items;
        }
    
        /**
         * 删除
         * @param fileName
         * @return
         * @throws Exception
         */
        public boolean remove(String fileName){
        
            try {
        
                minioClient.removeObject( RemoveObjectArgs.builder().bucket(prop.getBucketName()).object(fileName).build());
            }catch (Exception e){
        
                return false;
            }
            return true;
        }
    }

### 编写控制器 ###

@RestController
    @RequestMapping("/minio")
    @Api(tags = "minio测试")
    @RequiredArgsConstructor
    @Slf4j
    public class MinioController {
        
        @Autowired
        private MinIoUtil minIoUtil;
        @Autowired
        private MinioUtilS minioUtilS;
        @Value("${minio.endpoint}")
        private String address;
        @Value("${minio.bucketName}")
        private String bucketName;
     
        @PostMapping("/upload")
        public Object upload(MultipartFile file) {
        
            
            List<String> upload = minioUtilS.upload(new MultipartFile[]{
        file});
     
            return address+"/"+bucketName+"/"+upload.get(0);
        }
     
    }

![format_png][]

### 总结 ###

*  springboot 集成 minio 非常简单，通过封装 minioclient，可增加代码的灵活性可扩展性，隔离底层存储接口，后续入要更换其他的存储，经过简单的适配即可实现，通过REST提供存储的基础能力接口，可非常简单的被使用。

### 声明 ###

*  原文链接：https://www.jianshu.com/p/6de1acde167d

[format_png]: https://img-blog.csdnimg.cn/img_convert/6ec5a6ae8c9c815f82af46df4db5734b.webp?x-oss-process=image/format,png