Springboot整合 Minio

最新推荐文章于 2024-08-07 16:31:51 发布

浮々若年·华

最新推荐文章于 2024-08-07 16:31:51 发布

阅读量759

点赞数 1

本文链接：https://blog.csdn.net/qq_45597391/article/details/124895438

版权

文章目录

前言
下载 [官网地址](https://min.io/)
依赖
配置类（application.yml）
MinioConfig
MinIoProperties
MinioUtils
使用（MinIoController）

前言

对象存储服务OSS（Object Storage Service）是一种海量、安全、低成本、高可靠的云存储服务，适合存放任意类型的文件。容量和处理能力弹性扩展，多种存储类型供选择，全面优化存储成本。

下载官网地址

下载完成后，启动minio
运行 .\minio.exe server E:\MinIOPic E:\MinIOPic:上传地址
在这里插入图片描述

依赖


 <!-- minio文件分布式 -->
  <dependency>
      <groupId>io.minio</groupId>
      <artifactId>minio</artifactId>
      <version>8.3.7</version>
  </dependency>

配置类（application.yml）


minio:
  bucketName: file # minio 桶名称
  url: http://127.0.0.1:9000 # minio 服务地址
  accesskey: minioadmin # minio Access key就像用户ID，可以唯一标识你的账户
  secretKey: minioadmin # minio Secret key是你账户的密码

MinioConfig


@Configuration
public class MinioConfig {
    @Autowired
    private MinIoProperties minioProperties;
    @Bean
    public MinioClient minioClient(){
        MinioClient minioClient =
                MinioClient.builder()
                        .endpoint(minioProperties.getUrl())
                        .credentials(minioProperties.getAccessKey(),
                                minioProperties.getSecretKey())
                        .build();
        return minioClient;
    }
}

MinIoProperties

@Data
@Component
@ConfigurationProperties(prefix = "minio")
public class MinIoProperties {
    /**
     * minio地址+端口号
     */
    private String url;

    /**
     * minio用户名
     */
    private String accessKey;

    /**
     * minio密码
     */
    private String secretKey;

    /**
     * 文件桶的名称
     */
    private String bucketName;


}

MinioUtils


@Component
@Slf4j
public class MinioUtils {
    @Autowired
    private MinioClient minioClient;

    /**
     * TODO 创建存储桶
     *
     * @param bucketName 存储桶名称
     * @return
     */
    public String makeBucket(String bucketName) throws Exception {
        //判断 存储桶存不存在
        boolean bucketExists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        if (bucketExists) {
            log.info("Minio 桶已经存在了:{}", bucketName);
        } else {
            //创建桶
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            log.info("Minio 桶创建成功：{}", bucketName);
        }
        return bucketName;
    }

    /**
     * TODO 查询全部存储桶信息
     *
     * @return
     * @throws Exception
     */
    public List<Bucket> listBuckets() throws Exception {
        List<Bucket> listBuckets = minioClient.listBuckets();
        log.info("全部存储桶信息：{}", listBuckets);
        return listBuckets;
    }

    /**
     * TODO 查询单个储桶中的所有对象。
     *
     * @param bucketName 存储桶名称
     * @throws Exception
     */
    public List<Object> listObjects(String bucketName) throws Exception {
        Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName).build());
        Iterator<Result<Item>> iterator = results.iterator();
        List<Object> items = new ArrayList<>();
        String format = "{'fileName':'%s','fileSize':'%s'}";
        while (iterator.hasNext()) {
            Item item = iterator.next().get();
            items.add(JSON.parse(String.format(format, item.objectName(),
                    formatFileSize(item.size()))));
        }
        log.info("查询单个储桶中的所有对象信息：{}", items);
        return items;
    }

    /**
     * TODO 删除一个存储桶
     *
     * @param bucketName 存储桶名称
     * @throws Exception
     */
    public void removeBucket(String bucketName) throws Exception {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
        log.info("删除一个存储桶成功");
    }

    /**
     * TODO 获取对象的元数据
     * @param bucketName 存储桶名称。
     * @param objectName 存储桶里的对象名称
     * @return
     * @throws Exception
     */
    public StatObjectResponse statObject(String bucketName,String objectName) throws Exception {
        StatObjectResponse statObjectResponse = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
        return statObjectResponse;
    }

    /**
     * TODO 上传文件
     * @param file 文件
     * @param bucketName 存储桶名称
     */
    public List<String>  putObject(MultipartFile[] file,String bucketName){
        List<String> path =new ArrayList<>();
        for (MultipartFile multipartFile : file) {
            //获取文件名
            String orgfileName = multipartFile.getOriginalFilename();
            path.add(bucketName+"/"+orgfileName);
            try {
                //文件上传
                InputStream in = multipartFile.getInputStream();
                minioClient.putObject(
                        PutObjectArgs.builder().bucket(bucketName).object(orgfileName).stream(
                                in, multipartFile.getSize(), -1)
                                .contentType(multipartFile.getContentType())
                                .build());
                in.close();
            } catch (Exception e) {
                log.error(e.getMessage());
            }
        }
        return path;
    }

    /**
     * TODO 将对象的数据下载到文件中
     * @param bucketName 存储桶名称
     * @param objectName 文件名称
     * @param fileName   文件名称
     * @throws Exception
     */
    public void downloadObject(String bucketName, String objectName, String fileName)throws Exception {
        log.info("bucketName = {}",bucketName);
        log.info("objectName = {}",objectName);
        log.info("fileName = {}",fileName);
        minioClient.downloadObject(DownloadObjectArgs.builder().bucket(bucketName).object(objectName).filename(fileName).build());
    }


    /**
     * TODO 删除文件
     * @param bucketName 存储桶名称
     * @param objectName 文件名称
     * @throws Exception
     */
    public void  removeObject(String bucketName, String objectName)throws Exception {
        minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
    }
    /**
     * TODO 生成一个给HTTP GET请求用的presigned URL。
     *      浏览器/移动端的客户端可以用这个URL进行下载，
     *      即使其所在的存储桶是私有的。
     *      这个presigned URL可以设置一个失效时间，默认值是7天
     *
     * @param bucketName 存储桶名称
     * @param objectName 文件名称
     * @param expiry     失效时间(单位小时)
     * @return
     */
    public String getPresignedObjectUrl(String bucketName, String objectName, Integer expiry)throws Exception {
        log.info("bucketName = {}",bucketName);
        log.info("objectName = {}",objectName);
        log.info("expiry = {}",expiry);
        String presignedObjectUrl = minioClient.getPresignedObjectUrl(
                GetPresignedObjectUrlArgs
                        .builder()
                        .method(Method.GET)
                        .bucket(bucketName)
                        .object(objectName)
                        .expiry(expiry, TimeUnit.HOURS)
                        .build());
        log.info("生成http 下载信息：{}",presignedObjectUrl);
        return presignedObjectUrl;
    }


    public static String formatFileSize(long fileS) {
        DecimalFormat df = new DecimalFormat("#.00");
        String fileSizeString = "";
        String wrongSize = "0B";
        if (fileS == 0) {
            return wrongSize;
        }
        if (fileS < 1024) {
            fileSizeString = df.format((double) fileS) + " B";
        } else if (fileS < 1048576) {
            fileSizeString = df.format((double) fileS / 1024) + " KB";
        } else if (fileS < 1073741824) {
            fileSizeString = df.format((double) fileS / 1048576) + " MB";
        } else {
            fileSizeString = df.format((double) fileS / 1073741824) + " GB";
        }
        return fileSizeString;
    }

}

使用（MinIoController）

@RestController
@RequestMapping("/api/minio")
@Slf4j
public class MinIoController {

    @Autowired
    private MinioClient minioClient;
    @Autowired
    private MinioUtils minioUtils;

    @Value("${minio.bucketName}")
    private String bucketName;

    @GetMapping("/getPresignedObjectUrl")
    public String getPresignedObjectUrl() throws Exception{
         minioUtils.downloadObject(bucketName, "233.mp4", "0116.mp4");
        return "ok";
    }

    @GetMapping("/list")
    public List<Object> list() throws Exception {
        //获取bucket列表
        Iterable<Result<Item>> myObjects = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).build());
        Iterator<Result<Item>> iterator = myObjects.iterator();
        List<Object> items = new ArrayList<>();
        String format = "{'fileName':'%s','fileSize':'%s'}";
        while (iterator.hasNext()) {
            Item item = iterator.next().get();
            items.add(JSON.parse(String.format(format, item.objectName(),
                    minioUtils.formatFileSize(item.size()))));
        }
        return items;
    }

    @PostMapping("/upload")
    public ServerResponse upload(@RequestParam(name = "file", required = false)
                                         MultipartFile[] file) {
        if (file == null || file.length == 0) {
            return ServerResponse.createByErrorMessage("上传文件不能为空");
        }
        List<String> stringList = minioUtils.putObject(file, bucketName);
        Map<String, Object> data = new HashMap<String, Object>();
        data.put("bucketName", bucketName);
        data.put("fileName", stringList);
        return ServerResponse.createBySuccess("上传成功", data);
    }

    @RequestMapping("/download/{fileName}")
    public void download(HttpServletResponse response, @PathVariable("fileName")
            String fileName) {
        InputStream in = null;
        try {
// 获取对象信息
            StatObjectResponse stat = minioClient.statObject(
                    StatObjectArgs.builder().bucket(bucketName).object(fileName).build());
            response.setContentType(stat.contentType());
            response.setHeader("Content-Disposition", "attachment;filename=" +
                    URLEncoder.encode(fileName, "UTF-8"));
//文件下载
            in = minioClient.getObject(
                    GetObjectArgs.builder()
                            .bucket(bucketName)
                            .object(fileName)
                            .build());
            IOUtils.copy(in, response.getOutputStream());
        } catch (Exception e) {
            log.error(e.getMessage());
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    log.error(e.getMessage());
                }
            }
        }
    }

    @DeleteMapping("/delete/{fileName}")
    public ServerResponse delete(@PathVariable("fileName") String fileName) {
        try {
            minioClient.removeObject(
                    RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build());
        } catch (Exception e) {
            log.error(e.getMessage());
            return ServerResponse.createByErrorMessage("删除失败");
        }
        return ServerResponse.createBySuccess("删除成功", null);
    }


}