content: package com.genshin.ojquestion.utils;
  
  import com.genshin.ojcommon.domain.dto.minio.ObjectItem;
  import io.minio.*;
  import io.minio.errors.*;
  import io.minio.http.Method;
  import io.minio.messages.DeleteError;
  import io.minio.messages.DeleteObject;
  import io.minio.messages.Item;
  import org.apache.tomcat.util.http.fileupload.IOUtils;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.http.HttpHeaders;
  import org.springframework.http.HttpStatus;
  import org.springframework.http.MediaType;
  import org.springframework.http.ResponseEntity;
  import org.springframework.stereotype.Component;
  import org.springframework.web.multipart.MultipartFile;
  
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.UnsupportedEncodingException;
  import java.net.URLEncoder;
  import java.security.InvalidKeyException;
  import java.security.NoSuchAlgorithmException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  import java.util.concurrent.TimeUnit;
  import java.util.stream.Collectors;
  
  /**
   * @description： minio工具类
   * @version：1.0
   */
  @Component
  public class MinioUtils {
      @Autowired
      public 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;
      }
      public void removeObject( String objectsing){
          try {
              minioClient.removeObject(
                      RemoveObjectArgs.builder().bucket(bucketName).object(objectsing).build()
              );
          } catch (ErrorResponseException e) {
              throw new RuntimeException(e);
          } catch (InsufficientDataException e) {
              throw new RuntimeException(e);
          } catch (InternalException e) {
              throw new RuntimeException(e);
          } catch (InvalidKeyException e) {
              throw new RuntimeException(e);
          } catch (InvalidResponseException e) {
              throw new RuntimeException(e);
          } catch (IOException e) {
              throw new RuntimeException(e);
          } catch (NoSuchAlgorithmException e) {
              throw new RuntimeException(e);
          } catch (ServerException e) {
              throw new RuntimeException(e);
          } catch (XmlParserException e) {
              throw new RuntimeException(e);
          }
      }
      /**
       * 批量删除文件对象
       *
       * @param bucketNames 存储bucket名称
       * @param objects    对象名称集合
       */
      public Iterable<Result<DeleteError>> removeObjects(String bucketNames, List<String> objects) {
          List<DeleteObject> dos = objects.stream().map(e -> new DeleteObject(e)).collect(Collectors.toList());
          for (String object : objects) {
              System.out.println(object);
          }
          System.out.println(bucketNames);
          Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketNames).objects(dos).build());
          for (Result<DeleteError> result : results) {
              DeleteError error = null;
              try {
                  error = result.get();
              } catch (ErrorResponseException e) {
                  throw new RuntimeException(e);
              } catch (InsufficientDataException e) {
                  throw new RuntimeException(e);
              } catch (InternalException e) {
                  throw new RuntimeException(e);
              } catch (InvalidKeyException e) {
                  throw new RuntimeException(e);
              } catch (InvalidResponseException e) {
                  throw new RuntimeException(e);
              } catch (IOException e) {
                  throw new RuntimeException(e);
              } catch (NoSuchAlgorithmException e) {
                  throw new RuntimeException(e);
              } catch (ServerException e) {
                  throw new RuntimeException(e);
              } catch (XmlParserException e) {
                  throw new RuntimeException(e);
              }
              System.out.println(
                      "Error in deleting object " + error.objectName() + "; " + error.message());
          }
          return results;
      }
      public String getPreviewFileUrl(String bucketNameWe, String fileName) {
          try {
              String url = minioClient.getPresignedObjectUrl(
                      GetPresignedObjectUrlArgs.builder()
                              .method(Method.GET)
                              .bucket(bucketNameWe)
                              .expiry(7, TimeUnit.DAYS)
                              .object(fileName)
                              .build()
              );
              return url;
          }catch (Exception e){
              e.printStackTrace();
              return "";
          }
      }
  }
  
  
  