devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java实现minio上传、下载、删除文件，支持https访问_minio下载文件

作者：weixin_40725706 | 2024-03-07 01:06:47

赞

踩

minio下载文件

MinIO 是一款高性能、分布式的对象存储系统，Minio是基于Go语言编写的对象存储服务，适合于存储大容量非结构化的数据，例如图片、音频、视频、备份数据等，传统对象存储用例（例如辅助存储，灾难恢复和归档）方面表现出色。

一、配置

导入minio依赖包

  1.         <dependency>
  2.             <groupId>io.minio</groupId>
  3.             <artifactId>minio</artifactId>
  4.             <version>8.0.3</version>
  5.         </dependency>

application.yml配置文件

  1. minio:
  2.   #注意此处是https，由于后续讨论协议问题因此提前修改，不需要的可自行修改为http
  3.   endpoint: https://xxx.xxx.xx:9002 
  4.   accesskey: minioadmin  #你的服务账号
  5.   secretkey: minioadmin  #你的服务密码

配置MinioInfo文件

  1. @Data
  2. @Component
  3. @ConfigurationProperties(prefix = "minio")
  4. public class MinioInfo {
  5.  
  6.     private String endpoint;
  7.  
  8.     private String accesskey;
  9.  
  10.     private String secretkey;
  11. }

配置MinioConfig文件

  1. @Configuration
  2. @EnableConfigurationProperties(MinioInfo.class)
  3. public class MinioConfig {
  4.  
  5.     @Autowired
  6.     private MinioInfo minioInfo;
  7.  
  8.     /**
  9.      * 获取 MinioClient
  10.      */
  11.     @Bean
  12.     public MinioClient minioClient() throws NoSuchAlgorithmException, KeyManagementException {
  13.         return MinioClient.builder().endpoint(minioInfo.getEndpoint())
  14.                 .credentials(minioInfo.getAccesskey(),minioInfo.getSecretkey())
  15.                 .build();
  16.    }
  17. }

二、上传、下载、删除文件

MinioUtils类

  1. import io.minio.*;
  2. import lombok.SneakyThrows;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.apache.commons.lang.StringUtils;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Component;
  7. import org.springframework.web.multipart.MultipartFile;
  8.  
  9. import javax.servlet.http.HttpServletResponse;
  10. import java.io.*;
  11. import java.net.URLEncoder;
  12.  
  13. /**
  14.  * @author: MM
  15.  * @date: 2023-03-09 10:09
  16.  */
  17. @Slf4j
  18. @Component
  19. public class MinioUtils {
  20.  
  21.     @Autowired
  22.     private MinioClient minioClient;
  23.  
  24.     @Autowired
  25.     private MinioInfo minioInfo;
  26.  
  27.  
  28.     /**
  29.      * 上传文件
  30.      * @param file
  31.      * @param bucketName
  32.      * @return
  33.      * @throws Exception
  34.      */
  35.     public String uploadFile(MultipartFile file,String bucketName){
  36.         if (null==file || 0 == file.getSize()){
  37.             log.error("msg","上传文件不能为空");
  38.             return null;
  39.         }
  40.         try {
  41.             //判断是否存在
  42.             createBucket(bucketName);
  43.             //原文件名
  44.             String originalFilename=file.getOriginalFilename();
  45.             minioClient.putObject(
  46.                     PutObjectArgs.builder().bucket(bucketName).object(originalFilename).stream(
  47.                             file.getInputStream(), file.getSize(), -1)
  48.                             .contentType(file.getContentType())
  49.                             .build());
  50.             return minioInfo.getEndpoint()+"/"+bucketName+"/"+originalFilename;
  51.         }catch (Exception e){
  52.             log.error("上传失败：{}",e.getMessage());
  53.         }
  54.         log.error("msg","上传失败");
  55.         return null;
  56.     }
  57.  
  58.    /**
  59.      * 通过字节流上传
  60.      * @param imageFullPath
  61.      * @param bucketName
  62.      * @param imageData
  63.      * @return
  64.      */
  65.     public String uploadImage(String imageFullPath,
  66.                               String bucketName,
  67.                               byte[] imageData){
  68.         ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(imageData);
  69.         try {
  70.             //判断是否存在
  71.             createBucket(bucketName);
  72.             minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(imageFullPath)
  73.                     .stream(byteArrayInputStream,byteArrayInputStream.available(),-1)
  74.                     .contentType(".jpg")
  75.                     .build());
  76.             return minioInfo.getEndpoint()+"/"+bucketName+"/"+imageFullPath;
  77.         }catch (Exception e){
  78.             log.error("上传失败：{}",e.getMessage());
  79.         }
  80.         log.error("msg","上传失败");
  81.         return null;
  82.     }
  83.  
  84.     /**
  85.      * 删除文件
  86.      * @param bucketName
  87.      * @param fileName
  88.      * @return
  89.      */
  90.     public int removeFile(String bucketName,String fileName){
  91.         try {
  92.             //判断桶是否存在
  93.             boolean res=minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
  94.             if (res) {
  95.                 //删除文件
  96.                 minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName)
  97.                         .object(fileName).build());
  98.             }
  99.         } catch (Exception e) {
  100.             System.out.println("删除文件失败");
  101.             e.printStackTrace();
  102.             return 1;
  103.         }
  104.         System.out.println("删除文件成功");
  105.         return 0;
  106.     }
  107.  
  108. /**
  109.      * 下载文件
  110.      * @param fileName
  111.      * @param bucketName
  112.      * @param response
  113.      */
  114.     public void fileDownload(String fileName,
  115.                              String bucketName,
  116.                              HttpServletResponse response) {
  117.  
  118.         InputStream inputStream   = null;
  119.         OutputStream outputStream = null;
  120.         try {
  121.             if (StringUtils.isBlank(fileName)) {
  122.                 response.setHeader("Content-type", "text/html;charset=UTF-8");
  123.                 String data = "文件下载失败";
  124.                 OutputStream ps = response.getOutputStream();
  125.                 ps.write(data.getBytes("UTF-8"));
  126.                 return;
  127.             }
  128.  
  129.             outputStream = response.getOutputStream();
  130.             // 获取文件对象
  131.             inputStream =minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileName).build());
  132.             byte buf[] = new byte[1024];
  133.             int length = 0;
  134.             response.reset();
  135.             response.setHeader("Content-Disposition", "attachment;filename=" +
  136.                     URLEncoder.encode(fileName.substring(fileName.lastIndexOf("/") + 1), "UTF-8"));
  137.             response.setContentType("application/octet-stream");
  138.             response.setCharacterEncoding("UTF-8");
  139.             // 输出文件
  140.             while ((length = inputStream.read(buf)) > 0) {
  141.                 outputStream.write(buf, 0, length);
  142.             }
  143.             System.out.println("下载成功");
  144.             inputStream.close();
  145.         } catch (Throwable ex) {
  146.             response.setHeader("Content-type", "text/html;charset=UTF-8");
  147.             String data = "文件下载失败";
  148.             try {
  149.                 OutputStream ps = response.getOutputStream();
  150.                 ps.write(data.getBytes("UTF-8"));
  151.             }catch (IOException e){
  152.                 e.printStackTrace();
  153.             }
  154.         } finally {
  155.             try {
  156.                 outputStream.close();
  157.                 if (inputStream != null) {
  158.                     inputStream.close();
  159.                 }}catch (IOException e){
  160.                 e.printStackTrace();
  161.             }
  162.         }
  163.     }
  164.  
  165.     @SneakyThrows
  166.     public void createBucket(String bucketName) {
  167.         //如果不存在就创建
  168.         if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
  169.             minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
  170.         }
  171.     }
  172. }

接下来创建个Controller使用就行了

上传

  1. /**
  2.      * 上传文件
  3.      * @param file
  4.      * @return
  5.      */
  6. @PostMapping(value = "/v1/minio/upload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
  7.     @ResponseBody
  8.     public JSONObject uploadByMinio(@RequestParam(name = "file")MultipartFile file) {
  9.         JSONObject jso = new JSONObject();
  10.         //返回存储路径
  11.         String path = minioUtils.uploadFile(file, "musicearphone");
  12.         jso.put("code", 2000);
  13.         jso.put("data", path);
  14.         return jso;
  15.     }

下载

  1. /**
  2.      * 下载文件 根据文件名
  3.      * @param fileName
  4.      * @param response
  5.      */
  6.     @GetMapping("/v1/get/download")
  7.     public void download(@RequestParam(name = "fileName") String fileName,
  8.                          HttpServletResponse response){
  9.         try {
  10.             minioUtils.fileDownload(fileName,"musicearphone",response);
  11.         }catch (Exception e){
  12.             e.printStackTrace();
  13.  
  14.         }
  15.     }

删除

  1. /**
  2.      * 通过文件名删除文件
  3.      * @param fileName
  4.      * @return
  5.      */
  6. @PostMapping("/v1/minio/delete")
  7.     @ResponseBody
  8.     public JSONObject deleteByName(String fileName){
  9.         JSONObject jso = new JSONObject();
  10.         int res = minioUtils.removeFile("musicearphone", fileName);
  11.         if (res!=0){
  12.             jso.put("code",5000);
  13.             jso.put("msg","删除失败");
  14.         }
  15.         jso.put("code",2000);
  16.         jso.put("msg","删除成功");
  17.         return jso;
  18.     }

三、支持https访问

由于公司项目的原因，项目访问的方式是https，开始集成是minio服务器是http，在之前文章把minio开启了https。

文章链接： https://blog.csdn.net/weixin_53799443/article/details/129335521

但在使用minio https服务的过程中发现文件上传报错了

出现了以下的错误

  1. sun.security.validator.ValidatorException: 
  2. PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: 
  3. unable to find valid certification path to requested target

问题原因

源应用程序不信任目标应用程序的证书，因为在源应用程序的JVM信任库中找不到该证书或证书链（简单来说minio服务不信任的证书问题导致）

解决办法

通过java代码取消ssl认证，更新MinioConfig文件

  1. import io.minio.MinioClient;
  2.  
  3. import okhttp3.OkHttpClient;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.boot.context.properties.EnableConfigurationProperties;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8.  
  9. import javax.net.ssl.*;
  10. import java.security.KeyManagementException;
  11. import java.security.NoSuchAlgorithmException;
  12. import java.security.SecureRandom;
  13. import java.security.cert.X509Certificate;
  14.  
  15. /**
  16.  * @author: MM
  17.  * @date: 2023-03-09 10:05
  18.  */
  19. @Configuration
  20. @EnableConfigurationProperties(MinioInfo.class)
  21. public class MinioConfig {
  22.  
  23.     @Autowired
  24.     private MinioInfo minioInfo;
  25.  
  26.     /**
  27.      * 获取 MinioClient
  28.      * 取消ssl认证
  29.      */
  30.     @Bean
  31.     public MinioClient minioClient() throws NoSuchAlgorithmException, KeyManagementException {
  32. //        return MinioClient.builder().endpoint(minioInfo.getEndpoint())
  33. //                .credentials(minioInfo.getAccesskey(),minioInfo.getSecretkey())
  34. //                .build();
  35.         //取消ssl认证
  36.         final TrustManager[] trustAllCerts = new TrustManager[]{
  37.                 new X509TrustManager() {
  38.                     @Override
  39.                     public void checkClientTrusted(X509Certificate[] x509Certificates, String s) {
  40.                     }
  41.                     @Override
  42.                     public void checkServerTrusted(X509Certificate[] x509Certificates, String s) {
  43.                     }
  44.                     @Override
  45.                     public X509Certificate[] getAcceptedIssuers() {
  46.                         return new X509Certificate[]{};
  47.                     }
  48.                 }
  49.         };
  50.  
  51.         X509TrustManager x509TrustManager = (X509TrustManager) trustAllCerts[0];
  52.         final SSLContext sslContext = SSLContext.getInstance("SSL");
  53.         sslContext.init(null, trustAllCerts, new SecureRandom());
  54.         final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
  55.         OkHttpClient.Builder builder = new OkHttpClient.Builder();
  56.         builder.sslSocketFactory(sslSocketFactory,x509TrustManager);
  57.  
  58.         builder.hostnameVerifier((s, sslSession) -> true);
  59.         OkHttpClient okHttpClient = builder.build();
  60.  
  61.         return MinioClient.builder().endpoint(minioInfo.getEndpoint()).httpClient(okHttpClient).region("eu-west-1").credentials(minioInfo.getAccesskey()
  62.                 , minioInfo.getSecretkey()).build();
  63.     }
  64.  
  65. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/202636
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号