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

文件存储MinIO读写工具类_objectwriteresponse

作者：小丑西瓜9 | 2024-02-18 22:24:14

赞

踩

objectwriteresponse

内容读工具类MinioReadUtils

  1. package com.assoft.fmc.common.utils;
  2.  
  3. import com.assoft.fmc.common.form.ItemData;
  4. import io.minio.*;
  5. import io.minio.http.Method;
  6. import io.minio.messages.Bucket;
  7. import io.minio.messages.Item;
  8.  
  9. import java.io.BufferedInputStream;
  10. import java.io.InputStream;
  11. import java.io.OutputStream;
  12. import java.net.URLEncoder;
  13. import java.time.ZonedDateTime;
  14. import java.time.format.DateTimeFormatter;
  15. import java.util.ArrayList;
  16. import java.util.List;
  17. import java.util.concurrent.TimeUnit;
  18.  
  19. import javax.servlet.http.HttpServletResponse;
  20.  
  21.  
  22. import com.assoft.fmc.common.constant.MinioConstants;
  23. import org.springframework.util.StringUtils;
  24.  
  25. public class MinioReadUtils {
  26. 	private static MinioClient minioClient;
  27. 	public static List<String> docList;
  28. 	static {
  29. 		initMinioClientInstance();
  30. 	}
  31.  
  32. 	private static synchronized void initMinioClientInstance() {
  33. 		if (minioClient == null) {
  34. 			minioClient = MinioClient.builder()
  35. 					.endpoint(MinioConstants.FLOW_MINIO_IP, MinioConstants.FLOW_MINIO_PORT, false) // https or not
  36. 					.credentials(MinioConstants.FLOW_ACCESS_KEY_WRITE, MinioConstants.FLOW_SECRET_KEY_WRITE).build();
  37. 		}
  38. 	}
  39.  
  40. 	/**
  41. 	 * 从bucket获取指定对象的输入流，后续可使用输入流读取对象 getObject与minio server连接默认保持5分钟， 每隔15s由minio
  42. 	 * server向客户端发送keep-alive check，5分钟后由客户端主动发起关闭连接
  43. 	 */
  44. 	public static InputStream getObject(String bucketName, String objectName) throws Exception {
  45. 		GetObjectArgs args = GetObjectArgs.builder().bucket(bucketName).object(objectName).build();
  46. 		return minioClient.getObject(args);
  47. 	}
  48. 	/**
  49. 	 * 判断文件是否存在，不能判断文件夹
  50. 	 * @param bucketName
  51. 	 * @param objectName
  52. 	 * @return
  53. 	 * @throws Exception
  54. 	 */
  55. 	public static boolean checkFileExist(String bucketName, String objectName) {
  56. 		try {
  57. 			StatObjectArgs args = StatObjectArgs.builder().bucket(bucketName).object(objectName).build();
  58. 			 minioClient.statObject(args);
  59. 			 return true;
  60. 		} catch (Exception e) {
  61. 			 return false;
  62. 		}
  63. 		
  64. 	}
  65. 	/**
  66. 	 * 获取对象的临时访问url，有效期5分钟
  67. 	 */
  68. 	public static String getObjectURL(String bucketName, String objectName) throws Exception {
  69. 		GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder().bucket(bucketName).object(objectName)
  70. 				.expiry(5, TimeUnit.MINUTES).method(Method.GET).build();
  71. 		return minioClient.getPresignedObjectUrl(args);
  72. 	}
  73.  
  74. 	
  75. 	/**
  76. 	 * 从minio下载文件，直接通过response传输
  77. 	 */
  78. 	public static void downloadFile(String bucketName, String objectName, HttpServletResponse response) throws Exception {
  79. 		String[] objList=objectName.split("/");
  80. 		String	fileName=objList[objList.length-1];
  81. 		try (InputStream is = getObject(bucketName, objectName);
  82. 				BufferedInputStream bis = new BufferedInputStream(is);
  83. 				OutputStream os = response.getOutputStream()) {
  84. 			// try {
  85. 			/*
  86. 			 * InputStream is = getObject(bucketName, filePath); BufferedInputStream bis =
  87. 			 * new BufferedInputStream(is); OutputStream os = response.getOutputStream();
  88. 			 */
  89. 			response.setContentType("application/force-download;charset=utf-8");// 设置强制下载而不是直接打开
  90. 			response.addHeader("Content-Disposition", "attachment;fileName=" + URLEncoder.encode(fileName, "UTF-8"));// 设置文件名
  91.  
  92. 			byte[] buffer = new byte[1024 * 1024 * 1024]; // buffer 1M
  93. 			int offset = bis.read(buffer);
  94. 			while (offset != -1) {
  95. 				os.write(buffer, 0, offset);
  96. 				offset = bis.read(buffer);
  97. 			}
  98. 			os.flush();
  99. 		} catch (Exception e) {
  100. 			throw new RuntimeException("下载文件失败", e);
  101. 		}
  102. 	}
  103.  
  104. 	public static List<Bucket> getAllBuckets() {
  105. 		try {
  106. 			List<Bucket> buckets = minioClient.listBuckets();
  107. 			return buckets;
  108. 		} catch (Exception e) {
  109. 			e.printStackTrace();
  110. 		}
  111. 		return null;
  112. 	}
  113.  
  114. //	遍历找到桶下所有路径
  115. 	public static void listDocs(String bucketName,String prefix){
  116. 		Iterable<Result<Item>> listObjects=new ArrayList<>();
  117. 		if(StringUtils.hasLength(prefix)){
  118. 			listObjects = minioClient.listObjects(ListObjectsArgs.builder()
  119. 					.bucket(bucketName)
  120. 					.prefix(prefix)
  121. 					.build());
  122. 		}else {
  123. 			listObjects = minioClient.listObjects(ListObjectsArgs.builder()
  124. 					.bucket(bucketName)
  125. 					.build());
  126. 		}
  127. 		try{
  128. 		for (Result<Item> result : listObjects) {
  129. 			Item item = result.get();
  130. 			if(item.isDir()){
  131. 				docList.add(item.objectName());
  132. 				listDocs(bucketName,item.objectName());
  133. 			}
  134. 		}
  135. 		}catch (Exception e){
  136.  
  137. 		}
  138. 	}
  139.  
  140. 	public static Iterable<Result<Item>> listObjects(String bucketName,String prefix,String title,boolean recursive){
  141. 		try {
  142. 			Iterable<Result<Item>> listObjects=new ArrayList<>();
  143. 			if(StringUtils.hasLength(title)){
  144. 				listObjects = minioClient.listObjects(ListObjectsArgs.builder()
  145. 						.bucket(bucketName)
  146. 						.prefix(prefix)
  147. 						.startAfter(title)
  148. 						.build());
  149. 			}
  150. 			else if(StringUtils.hasLength(prefix)){
  151. 				listObjects = minioClient.listObjects(ListObjectsArgs.builder()
  152. 						.bucket(bucketName)
  153. 						.prefix(prefix)
  154. 						.recursive(recursive) // 递归
  155. 						.build());
  156. 			}else {
  157. 				listObjects = minioClient.listObjects(ListObjectsArgs.builder()
  158. 						.bucket(bucketName)
  159. 						.recursive(recursive) // 递归
  160. 						.build());
  161. 			}
  162. 			return listObjects;
  163. 		} catch (Exception e) {
  164. 			System.out.println("Error occurred: " + e);
  165. 			return null;
  166. 		}
  167. 	}
  168.  
  169. }

内容写工具类MinioWriteUtils

  1. package com.assoft.fmc.common.utils;
  2.  
  3. import io.minio.BucketExistsArgs;
  4. import io.minio.MakeBucketArgs;
  5. import io.minio.MinioClient;
  6. import io.minio.ObjectWriteResponse;
  7. import io.minio.PutObjectArgs;
  8. import io.minio.RemoveObjectArgs;
  9. import io.minio.SnowballObject;
  10. import io.minio.UploadObjectArgs;
  11. import io.minio.UploadSnowballObjectsArgs;
  12. import io.minio.errors.ErrorResponseException;
  13. import io.minio.errors.InsufficientDataException;
  14. import io.minio.errors.InternalException;
  15. import io.minio.errors.InvalidResponseException;
  16. import io.minio.errors.ServerException;
  17. import io.minio.errors.XmlParserException;
  18.  
  19. import java.io.ByteArrayInputStream;
  20. import java.io.ByteArrayOutputStream;
  21. import java.io.FileInputStream;
  22. import java.io.FileNotFoundException;
  23. import java.io.IOException;
  24. import java.io.InputStream;
  25. import java.security.InvalidKeyException;
  26. import java.security.NoSuchAlgorithmException;
  27. import java.time.ZonedDateTime;
  28. import java.util.ArrayList;
  29. import java.util.List;
  30. import java.util.Objects;
  31.  
  32. import org.apache.commons.lang3.StringUtils;
  33. import org.springframework.web.multipart.MultipartFile;
  34.  
  35. import com.assoft.fmc.common.constant.MinioConstants;
  36.  
  37. public class MinioWriteUtils {
  38. 	private static MinioClient minioClient;
  39. 	static {
  40. 		initMinioClientInstance();
  41. 	}
  42. 	private static synchronized void initMinioClientInstance() {
  43. 		if (minioClient == null) {
  44. 			minioClient = MinioClient.builder().endpoint("http://"+MinioConstants.FLOW_MINIO_IP+":"+MinioConstants.FLOW_MINIO_PORT)
  45. 					.credentials(MinioConstants.FLOW_ACCESS_KEY_WRITE, MinioConstants.FLOW_SECRET_KEY_WRITE).build();
  46. 		}
  47. 	}
  48.  
  49. 	private static void createBucket(String bucketName) throws InvalidKeyException, ErrorResponseException,
  50. 			InsufficientDataException, InternalException, InvalidResponseException, NoSuchAlgorithmException,
  51. 			ServerException, XmlParserException, IllegalArgumentException, IOException {
  52. 		BucketExistsArgs bucketExistsArgs = BucketExistsArgs.builder().bucket(bucketName).build();
  53. 		if (!minioClient.bucketExists(bucketExistsArgs)) {
  54. 			MakeBucketArgs makeArgs = MakeBucketArgs.builder().bucket(bucketName).build();
  55. 			minioClient.makeBucket(makeArgs);
  56. 		}
  57. 	}
  58. 	/**
  59. 	 * 删除对象
  60. 	 */
  61. 	public static void removeObject(String bucketName, String objectName) throws Exception {
  62. 		RemoveObjectArgs args = RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build();
  63. 		minioClient.removeObject(args);
  64. 	}
  65.  
  66. 	/**
  67. 	 * 从给定输入流中传输对象并放入bucket
  68. 	 */
  69. 	public static ObjectWriteResponse putObject(String bucketName, String objectName, InputStream stream, long objectSize,
  70. 			String contentType) throws Exception {
  71. 		if (StringUtils.isBlank(bucketName)) {
  72. 			throw new RuntimeException("bucketName不能为空！");
  73. 		}
  74. 		createBucket(bucketName);
  75. 		long partSize = -1; // objectSize已知，partSize设为-1意为自动设置
  76. 		PutObjectArgs putArgs = PutObjectArgs.builder().bucket(bucketName).object(objectName)
  77. 				.stream(stream, objectSize, partSize).contentType(contentType).build();
  78. 		ObjectWriteResponse response = minioClient.putObject(putArgs);
  79. 		return response;
  80. 	}
  81. 	   /**
  82.      * 上传MultipartFile
  83.      * @param bucketName 文件存放的bucket
  84.      * @param filePath 文件在bucket里的全目录
  85.      * */
  86.     public ObjectWriteResponse uploadFile(String bucketName, String filePath, MultipartFile file) throws Exception{
  87.     	return putObject(bucketName, filePath, file.getInputStream(), file.getSize(), file.getContentType());
  88.     }
  89.     public static ObjectWriteResponse uploadFile(String bucketName, String objectName, String fileName) throws InvalidKeyException, ErrorResponseException, InsufficientDataException, InternalException, InvalidResponseException, NoSuchAlgorithmException, ServerException, XmlParserException, IOException {
  90.     	createBucket(bucketName);
  91.     	UploadObjectArgs uploadObjectArgs = UploadObjectArgs.builder().bucket(bucketName).object(objectName).filename(fileName).build();
  92.     	ObjectWriteResponse response = minioClient.uploadObject(uploadObjectArgs);
  93.     	
  94.     	return response;
  95.     }
  96.     public static boolean uploadFiles(String bucketName, String basePath, List<String> fileNames) throws InvalidKeyException, ErrorResponseException, InsufficientDataException, InternalException, InvalidResponseException, NoSuchAlgorithmException, ServerException, XmlParserException, IllegalArgumentException, IOException  {
  97.     	createBucket(bucketName);
  98.     	List<SnowballObject> objects = new ArrayList<SnowballObject>();
  99.     	for (String fileName : fileNames) {
  100. //    		File fiel  = new File(basePath+fileName);
  101. //    		
  102. //    		objects.add(new SnowballObject(fileName, new f, bytes.length, ZonedDateTime.now()));
  103.     		byte[] bytes = fileToBytes(basePath+fileName);
  104.     	    objects.add(new SnowballObject(fileName, new ByteArrayInputStream(bytes), bytes.length, ZonedDateTime.now()));
  105. 		}
  106.     	try {
  107.             minioClient.uploadSnowballObjects(
  108.                      UploadSnowballObjectsArgs.builder().bucket(bucketName).objects(objects).build());
  109.              return true;
  110.          } catch (Exception e) {
  111.              e.printStackTrace();
  112.              return false;
  113.          }
  114.     }
  115.     /**
  116.      * Description 文件转字节数组
  117.      * Create By Mr.Fang
  118.      *
  119.      * @param path 文件路径
  120.      * @return byte[] 字节数组
  121.      * @time 2022/7/10 10:55
  122.      **/
  123.     public static byte[] fileToBytes(String path) {
  124.         FileInputStream fis = null;
  125.         ByteArrayOutputStream bos = null;
  126.         try {
  127.             bos = new ByteArrayOutputStream();
  128.             fis = new FileInputStream(path);
  129.             int temp;
  130.             byte[] bt = new byte[1024 * 10];
  131.             while ((temp = fis.read(bt)) != -1) {
  132.                 bos.write(bt, 0, temp);
  133.             }
  134.             bos.flush();
  135.         } catch (FileNotFoundException e) {
  136.             e.printStackTrace();
  137.         } catch (IOException e) {
  138.             e.printStackTrace();
  139.         } finally {
  140.             try {
  141.                 if (Objects.nonNull(fis)) {
  142.                     fis.close();
  143.                 }
  144.             } catch (IOException e) {
  145.                 e.printStackTrace();
  146.             }
  147.         }
  148.         return bos.toByteArray();
  149.     }
  150.    /* List<SnowballObject> objects = new ArrayList<SnowballObject>();
  151.     objects.add(
  152.         new SnowballObject(
  153.             "my-object-one",
  154.             new ByteArrayInputStream("hello".getBytes(StandardCharsets.UTF_8)),
  155.             5,
  156.             null));
  157.     objects.add(
  158.         new SnowballObject(
  159.             "my-object-two",
  160.             new ByteArrayInputStream("java".getBytes(StandardCharsets.UTF_8)),
  161.             4,
  162.             null));
  163.     minioClient.uploadSnowballObjects(
  164.         UploadSnowballObjectsArgs.builder().bucket("my-bucketname").objects(objects).build());*/
  165. }

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

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

  

闽ICP备14008679号