• springboot整合minio


    原文:
    https://blog.csdn.net/Ting1king/article/details/121973201
    http://www.manongjc.com/detail/24-nlqwfvkleeelyvn.html
    https://www.cnblogs.com/zgwjava/p/13652164.html

    1. 什么是minio

    MinIO 是一款高性能、分布式的对象存储系统。
    中文网站:http://docs.minio.org.cn/docs/
    API文档:http://docs.minio.org.cn/docs/master/java-client-api-reference



    2. springboot整合minio

    1. 添加依赖
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.0.3</version>
        </dependency>
    

    1. 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
    

    1. 创建配置类
    
    // 注册minio客户端,以便在代码中使用客户端上传文件。
    
    @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();
        }
    
    }
    

    1. 整个工具类
      // 实体类
    
      @Data
      public class ObjectItem {
          private String objectName;
          private Long size;
      }
    
    /**
     * @description: minio工具类
     * @version:3.0
     */
    @Component
    public class MinioUtilS {
        @Autowired
        private MinioClient minioClient;
    
        @Value("${minio.bucketName}")
        private String bucketName;
        /**
         * description: 判断bucket是否存在,不存在则创建
         *
         * @return: void
         */
        public void existBucket(String name) {
            try {
                boolean exists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(name).build());
                if (!exists) {
                    minioClient.makeBucket(MakeBucketArgs.builder().bucket(name).build());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 创建存储bucket
         * @param bucketName 存储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
         * @param bucketName 存储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;
        }
        /**
         * description: 上传文件
         *
         * @param multipartFile
         * @return: java.lang.String
    
         */
        public List<String> upload(MultipartFile[] multipartFile) {
            List<String> names = new ArrayList<>(multipartFile.length);
            for (MultipartFile file : multipartFile) {
                String fileName = file.getOriginalFilename();
                String[] split = fileName.split("\\.");
                if (split.length > 1) {
                    fileName = split[0] + "_" + System.currentTimeMillis() + "." + split[1];
                } else {
                    fileName = fileName + System.currentTimeMillis();
                }
                InputStream in = null;
                try {
                    in = file.getInputStream();
                    minioClient.putObject(PutObjectArgs.builder()
                            .bucket(bucketName)
                            .object(fileName)
                            .stream(in, in.available(), -1)
                            .contentType(file.getContentType())
                            .build()
                    );
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    if (in != null) {
                        try {
                            in.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
                names.add(fileName);
            }
            return names;
        }
    
        /**
         * description: 下载文件
         *
         * @param fileName
         * @return: org.springframework.http.ResponseEntity<byte [ ]>
         */
        public ResponseEntity<byte[]> download(String fileName) {
            ResponseEntity<byte[]> responseEntity = null;
            InputStream in = null;
            ByteArrayOutputStream out = null;
            try {
                in = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileName).build());
                out = new ByteArrayOutputStream();
                IOUtils.copy(in, out);
                //封装返回值
                byte[] bytes = out.toByteArray();
                HttpHeaders headers = new HttpHeaders();
                try {
                    headers.add("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                headers.setContentLength(bytes.length);
                headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
                headers.setAccessControlExposeHeaders(Arrays.asList("*"));
                responseEntity = new ResponseEntity<byte[]>(bytes, headers, HttpStatus.OK);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if (in != null) {
                        try {
                            in.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    if (out != null) {
                        out.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return responseEntity;
        }
    
        /**
         * 查看文件对象
         * @param bucketName 存储bucket名称
         * @return 存储bucket内文件对象信息
         */
        public List<ObjectItem> listObjects(String bucketName) {
            Iterable<Result<Item>> results = minioClient.listObjects(
                    ListObjectsArgs.builder().bucket(bucketName).build());
            List<ObjectItem> objectItems = new ArrayList<>();
            try {
                for (Result<Item> result : results) {
                    Item item = result.get();
                    ObjectItem objectItem = new ObjectItem();
                    objectItem.setObjectName(item.objectName());
                    objectItem.setSize(item.size());
                    objectItems.add(objectItem);
                }
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
            return objectItems;
        }
    
        /**
         * 批量删除文件对象
         * @param bucketName 存储bucket名称
         * @param objects 对象名称集合
         */
        public Iterable<Result<DeleteError>> removeObjects(String bucketName, List<String> objects) {
            List<DeleteObject> dos = objects.stream().map(e -> new DeleteObject(e)).collect(Collectors.toList());
            Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(dos).build());
            return results;
        }
    
    
    }
    
    @RestController
    @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);
        }
    
    }
    
  • 相关阅读:
    Enhancing State-of-the-art Classifiers with API Semantics to Detect Evolved Android Malware论文阅读笔记
    this和super的总结
    软件工程结对WordCount项目
    软工个人作业 数独
    问题
    自我介绍
    shuduku
    access to DeepLearning
    自我介绍
    学习软工基目标
  • 原文地址:https://www.cnblogs.com/itlihao/p/16196386.html
Copyright © 2020-2023  润新知