MinIO 文件服务器使用笔记
官网SDK没更新，真坑啊，都是不能用和过期的
看的大佬的文章，讲的特别清楚：https://www.jianshu.com/p/913a069e755a
根据自己需求简单处理记录
配置文件
spring:
application:
name: aaa
minio:
configs:
#你搭建的MinIO服务器地址
minIOUrl: http://22.22.22.22:8080
#你搭建的MinIO服务器账号
accessKey: M9999
#你搭建的MinIO服务器密码
secretKey: 123456
#文件大小 单位M
maxFileSize: 10
#签名有效时间 单位秒
expires: 36000
#后端接口地址
serviceUrl: https://zheshihaowangzhan.org.cn
gateway:
httpUrl: http://192.168.1.13:10004
配置文件映射实体类
@Data
@Component
@ConfigurationProperties(prefix = "spring.minio.configs")
public class MinIoFileProperties {
private String minIOUrl;
private String accessKey;
private String secretKey;
private Integer maxFileSize;
private Integer expires;
private String serviceUrl;
}
封装工具类
public class MinIoFileUtil {
private static final Logger logger = LoggerFactory.getLogger(Threads.class);
private static final String NAME_HEAD = "J";
private static final String CONTENT_TYPE = "image/jpeg";
//MinIO服务的URL
private String minIOUrl;
//Access key
private String accessKey;
//Secret key
private String secretKey;
//存储桶名称
private String bucketName;
//文件大小（最大）
private Integer maxFileSize = 10;
//签名有效时间 单位秒
private Integer expires;
private MinioClient client;
/**
* 桶占位符
*/
private static final String BUCKET_PARAM = "${bucket}";
/**
* bucket权限-读写
*/
private static final String READ_WRITE = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:GetBucketLocation\",\"s3:ListBucket\",\"s3:ListBucketMultipartUploads\"],\"Resource\":[\"arn:aws:s3:::" + BUCKET_PARAM + "\"]},{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:DeleteObject\",\"s3:GetObject\",\"s3:ListMultipartUploadParts\",\"s3:PutObject\",\"s3:AbortMultipartUpload\"],\"Resource\":[\"arn:aws:s3:::" + BUCKET_PARAM + "/*\"]}]}";
public MinIoFileUtil() {
this.client = getMinioClient();
}
public MinIoFileUtil(String bucketName, MinIoFileProperties minIoFileProperties) {
this.minIOUrl = minIoFileProperties.getMinIOUrl();
this.accessKey = minIoFileProperties.getAccessKey();
this.secretKey = minIoFileProperties.getSecretKey();
this.bucketName = bucketName;
this.maxFileSize = minIoFileProperties.getMaxFileSize();
this.expires = minIoFileProperties.getExpires();
this.client = getMinioClient();
}
private MinioClient getMinioClient() {
return MinioClient.builder().endpoint(this.minIOUrl).credentials(this.accessKey, this.secretKey).build();
}
/**
* 获取文件签名url
*
* @param fileName 文件名称
* @return 文件签名地址
*/
public String getSignedUrl(String fileName) throws Exception {
if (StringUtils.isBlank(fileName)) {
throw new CustomException("文件名称不能为空");
}
MinioClient client = MinioClient.builder().endpoint(this.minIOUrl).credentials(accessKey, secretKey).build();
return client.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().method(Method.GET).bucket(bucketName).object(getFileName(fileName)).expiry(expires).build());
}
/**
* 根据图片路径
*
* @param response
* @param imgUrl 网络（服务器）图片路径
*/
public void getFileIO(HttpServletResponse response, String imgUrl) throws IOException {
OutputStream out = null;
InputStream inputStream = null;
try {
HttpURLConnection connection = (HttpURLConnection) new URL(imgUrl).openConnection();
connection.setReadTimeout(5000);
connection.setConnectTimeout(5000);
connection.setRequestMethod("GET");
if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
inputStream = connection.getInputStream();
response.setContentType("image/jpeg");
out = response.getOutputStream();
//读取文件流
int len = 0;
byte[] buffer = new byte[1024 * 10];
while ((len = inputStream.read(buffer)) != -1) {
out.write(buffer, 0, len);
}
out.flush();
}
} catch (IOException e) {
System.out.println("获取图片出现异常，图片路径为：" + imgUrl);
e.printStackTrace();
} finally {
if (null != out) {
out.close();
}
if (null != inputStream) {
inputStream.close();
}
}
}
/**
* 返回文件URL
*
* @return
*/
public String setFile(MultipartFile multipartFile) throws Exception {
return uploadFiles(setFileName(null, multipartFile), fileVerify(multipartFile));
}
/**
* 返回文件名称
*
* @return
*/
public String upFile(MultipartFile multipartFile) throws Exception {
String fileName = setFileName(null, multipartFile);
uploadFiles(fileName, fileVerify(multipartFile));
return fileName;
}
/**
* 返回文件URL
*
* @param fileName 图片名称
* @param inputStream
* @return
*/
public String setFile(String fileName, InputStream inputStream) throws Exception {
if (StringUtils.isBlank(fileName)) {
throw new CustomException("文件名称不能为空");
}
return uploadFiles(fileName, inputStream);
}
/**
* 返回文件URL
*
* @param fileName 图片名称
* @param multipartFile 文件
* @return 文件路径字符串（不可直接访问）
* @throws IOException
*/
public String setFile(String fileName, MultipartFile multipartFile) throws Exception {
return uploadFiles(setFileName(fileName, multipartFile), fileVerify(multipartFile));
}
/**
* 文件校验
*/
private InputStream fileVerify(MultipartFile multipartFile) throws IOException {
if (null == multipartFile) {
throw new CustomException("请选择文件");
}
// 文件不大于10M
if (!checkFileSize(multipartFile.getSize(), this.maxFileSize, "M")) {
throw new CustomException("文件大小超限制");
}
return multipartFile.getInputStream();
}
/**
* 上传文件 (流的形式)
*
* @return
*/
private String uploadFiles(String fileName, InputStream inputStream) throws Exception {
makeBucket(client, this.bucketName);
//设置桶的读写权限
client.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(READ_WRITE.replace(BUCKET_PARAM, bucketName)).build());
client.putObject(PutObjectArgs.builder().bucket(this.bucketName).object(fileName).stream(inputStream, inputStream.available(), -1)
.contentType(CONTENT_TYPE).build());
return getObjectPrefixUrl(this.bucketName) + fileName;
}
/**
* 校验创建桶
*
* @param bucketName 桶
*/
private static void makeBucket(MinioClient minioClient, String bucketName) throws Exception {
// 判断桶是否存在
boolean isExist = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
if (!isExist) {
logger.info("存储桶{}不存在", bucketName);
// 新建桶
minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
logger.info("新建存储桶{}", bucketName);
}
}
/**
* 删除文件
*
* @param fileNames
* @return
*/
public boolean deleteFile(String... fileNames) {
return this.deleteToAll(Arrays.asList(fileNames));
}
public boolean deleteFile(List<String> fileNames) {
return this.deleteToAll(fileNames);
}
private Boolean deleteToAll(List<String> fileNames) {
List<DeleteObject> deleteObjects = new ArrayList<>(fileNames.size());
for (String fileName : fileNames) {
String name = getFileName(fileName);
deleteObjects.add(new DeleteObject(name));
}
Iterable<Result<DeleteError>> results = client.removeObjects(
RemoveObjectsArgs.builder()
.bucket(bucketName)
.objects(deleteObjects)
.build()
);
for (Result<DeleteError> result : results) {
DeleteError error = null;
try {
error = result.get();
} catch (ErrorResponseException e) {
e.printStackTrace();
} catch (InsufficientDataException e) {
e.printStackTrace();
} catch (InternalException e) {
e.printStackTrace();
} catch (InvalidBucketNameException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (InvalidResponseException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (ServerException e) {
e.printStackTrace();
} catch (XmlParserException e) {
e.printStackTrace();
}
logger.error(
"Error in deleting object " + error.objectName() + "; " + error.message());
}
return !results.iterator().hasNext();
}
/**
* 文件url前半段
*
* @param bucket 桶
* @return 前半段
*/
private String getObjectPrefixUrl(String bucket) {
return String.format("%s/%s/", this.minIOUrl, bucket);
}
private static String setFileName(String fileName, MultipartFile multipartFile) {
if (StringUtils.isNotBlank(fileName)) {
return fileName;
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
String[] originalFilename = multipartFile.getOriginalFilename().split("\\.");
return NAME_HEAD + simpleDateFormat.format(new Date()) + getRandom() + "." + originalFilename[originalFilename.length - 1];
}
private static int getRandom() {
double ran = Math.random() * 9000 + 1000;
return (int) ran;
}
/**
* 判断文件大小
*
* @param len 文件长度
* @param size 限制大小
* @param unit 限制单位（B,K,M,G）
* @return
*/
public static boolean checkFileSize(Long len, int size, String unit) {
// long len = file.length();
double fileSize = 0;
if ("B".equals(unit.toUpperCase())) {
fileSize = (double) len;
} else if ("K".equals(unit.toUpperCase())) {
fileSize = (double) len / 1024;
} else if ("M".equals(unit.toUpperCase())) {
fileSize = (double) len / 1048576;
} else if ("G".equals(unit.toUpperCase())) {
fileSize = (double) len / 1073741824;
}
if (fileSize > size) {
return false;
}
return true;
}
/**
* 处理文件名称（当fileName 不是文件名称为文件存储路径地址时）
*
* @return
*/
public static String getFileName(String fileName) {
if (fileName.contains("/")) {
String[] split = fileName.split("/");
return split[split.length - 1];
} else {
return fileName;
}
}
}
调用
@Slf4j
@RestController
@RequestMapping("/digitization/minIoFile")
@Api(value = "Web - MinioFileDisposeController", tags = {"获取、查看文件"})
public class MinioFileDisposeController extends BaseController {
public final static String SERVICE_UTL = "/digitization/minIoFile/getFile/io/";
@Autowired
private MinIoFileProperties minIoFileProperties;
@PostMapping("/getFileUrl")
@ApiOperation(value = "获取访问路径")
public AjaxResult getFileUrl(@RequestBody MinIoFileDto minIoFileDto) throws Exception {
log.info("getFileUrl获取图片访问路径 minIoFileDto={}", JSON.toJSONString(minIoFileDto));
MinIoFileUtil minIoFileUtil = new MinIoFileUtil(minIoFileProperties.getBucketName(), minIoFileProperties);
String imgUrl = minIoFileUtil.getSignedUrl(minIoFileDto.getFileNameOrUrl());
logger.info(" 图片路径为{}", imgUrl);
return AjaxResult.success("", imgUrl);
}
/**
* 上传图片/文件
*/
@ApiOperation(value = "上传图片/文件")
@PostMapping(value = "/setFile")
public AjaxResult getInfo(MultipartFile file) throws Exception {
log.info(" setFile上传图片 ");
MinIoFileUtil minIoFileUtil = new MinIoFileUtil(minIoFileProperties.getBucketName(), minIoFileProperties);
// return AjaxResult.success("", httpUrl + IMG_UTL + minIoFileUtil.upFile(file));
System.out.println(minIoFileProperties.getServiceUrl());
System.out.println(SERVICE_UTL);
String s = minIoFileUtil.upFile(file);
System.out.println(s);
System.out.println(minIoFileProperties.getServiceUrl() + SERVICE_UTL + s);
return AjaxResult.success("", minIoFileProperties.getServiceUrl() + SERVICE_UTL + s);
}
/**
* 根据图片名称返回图片流
*
* @param fileName
* @return
* @throws Exception
*/
@GetMapping(value = "/getFile/io/{fileName}")
@ApiOperation(value = "根据图片/文件名称返回流")
public void getFile(@PathVariable String fileName, HttpServletResponse response) throws Exception {
log.info(" getFileIO 根据图片名称返回图片流，名称{}", fileName);
MinIoFileUtil minIoFileUtil = new MinIoFileUtil(minIoFileProperties.getBucketName(), minIoFileProperties);
String imgUrl = minIoFileUtil.getSignedUrl(fileName);
minIoFileUtil.getFileIO(response, imgUrl);
}
/**
* 根据图片名称返回图片流
*
* @param fileName
* @return
* @throws Exception
*/
@GetMapping(value = "/deleteFile")
@ApiOperation(value = "删除图片/文件")
public AjaxResult delete(@RequestParam("fileName") String fileName) throws Exception {
log.info(" deleteFile 删除图片/文件，名称{}", fileName);
MinIoFileUtil minIoFileUtil = new MinIoFileUtil(minIoFileProperties.getBucketName(), minIoFileProperties);
boolean flag = minIoFileUtil.deleteFile(fileName);
return AjaxResult.success(flag);
}
}