MinIO 文件服务器使用笔记

朴灿烈づ我的快乐病毒、 2022-11-22 12:46 317阅读 0赞

官网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
      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;
    }

## 封装工具类 ##

package com.ruoyi.common.utils;
    
    import com.ruoyi.common.config.MinIoFileProperties;
    import com.ruoyi.common.exception.CustomException;
    import io.minio.*;
    import io.minio.errors.*;
    import io.minio.http.Method;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.multipart.MultipartFile;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    /** * minio 图片服务器 */
    @Slf4j
    public class MinIoFileUtil { 
        private static final String NAME_HEAD = "J";
        private static final String CONTENT_TYPE = "image/jpeg";
        //MinIO服务的URL
        private static String minIOUrl;
        //Access key
        private static String accessKey;
        //Secret key
        private static String secretKey;
        //存储桶名称
        private static String bucketName;
        //文件大小（最大）
        private static Integer maxFileSize = 10;
        //签名有效时间 单位秒
        private static Integer expires;
    
    
     /** * 桶占位符 */
        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() { 
        }
    
    
        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();
        }
    
        /** * 获取文件签名url * * @param fileName 文件名称 * @return 文件签名地址 */
        public static String getSignedUrl(String fileName) throws Exception { 
            if (StringUtils.isBlank(fileName)) { 
                throw new CustomException("文件名称不能为空");
            }
            MinioClient client = MinioClient.builder().endpoint(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 static 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 static String setFile(MultipartFile multipartFile) throws IOException { 
            return uploadFiles(setFileName(null, multipartFile), fileVerify(multipartFile));
        }
    
    
        /** * 返回文件名称 * * @return */
        public static String upFile(MultipartFile multipartFile) throws IOException { 
            String fileName = setFileName(null, multipartFile);
            uploadFiles(fileName, fileVerify(multipartFile));
            return fileName;
        }
    
    
        /** * 返回文件URL * * @param fileName 图片名称 * @param inputStream * @return */
        public static String setFile(String fileName, InputStream inputStream) { 
            if (StringUtils.isBlank(fileName)) { 
                throw new CustomException("文件名称不能为空");
            }
            return uploadFiles(fileName, inputStream);
        }
    
        /** * 返回文件URL * * @param fileName 图片名称 * @param multipartFile 文件 * @return 文件路径字符串（不可直接访问） * @throws IOException */
        public static String setFile(String fileName, MultipartFile multipartFile) throws IOException { 
            return uploadFiles(setFileName(fileName, multipartFile), fileVerify(multipartFile));
        }
    
    
        /** * 文件校验 */
        private static InputStream fileVerify(MultipartFile multipartFile) throws IOException { 
            if (null == multipartFile) { 
                throw new CustomException("请选择文件");
            }
            // 文件不大于10M
            if (!checkFileSize(multipartFile.getSize(), maxFileSize, "M")) { 
                throw new CustomException("文件大小超限制");
            }
            return multipartFile.getInputStream();
        }
    
    
        /** * 上传文件 (流的形式) * * @return */
        private static String uploadFiles(String fileName, InputStream inputStream) { 
                MinioClient client = MinioClient.builder().endpoint(minIOUrl).credentials(accessKey, secretKey).build();
                makeBucket(client, bucketName);
                //设置桶的读写权限
            client.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(READ_WRITE.replace(BUCKET_PARAM, bucketName)).build());
                client.putObject(PutObjectArgs.builder().bucket(bucketName).object(fileName).stream(inputStream, inputStream.available(), -1).contentType(CONTENT_TYPE).build());
                return getObjectPrefixUrl(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) { 
                log.info("存储桶{}不存在", bucketName);
                // 新建桶
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
                log.info("新建存储桶{}", bucketName);
            }
        }
    
    
        /** * 文件url前半段 * * @param bucket 桶 * @return 前半段 */
        private static String getObjectPrefixUrl(String bucket) { 
            return String.format("%s/%s/", 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 */
        private static String getFileName(String fileName) { 
            if (fileName.contains("/")) { 
                String[] split = fileName.split("/");
                return split[split.length - 1];
            } else { 
                return fileName;
            }
        }
    }

## 调用 ##

/** * 获取、查看文件 */
    @RestController
    @RequestMapping(value = "/minIoFile", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @Api(value = "Web - MinIoFileController", tags = { "获取、查看文件"}, produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    public class YmzcMinIoFileController extends BaseController { 
    
        public final static String IMG_UTL = "/ymzc/minIoFile/auth/getFileIO?fileName=";
    
        @Autowired
        private MinIoFileProperties minIoFileProperties;
    
        @Value("${spring.gateway.httpUrl}")
        private String httpUrl;
    
        /** * 获取图片访问路径 * * @param minIoFileDto minIoFileDto.getFileNameOrUrl() 文件的名称或者全路径 如（http:22.22.22.22:8080/...） * @return * @throws Exception */
        @PostMapping("/getFileUrl")
        @ApiOperation(httpMethod = "Post", value = "获取图片访问路径")
        public Wrapper getFileUrl(@RequestBody MinIoFileDto minIoFileDto) throws Exception { 
            logger.info(" getFileUrl获取图片访问路径 minIoFileDto={}", minIoFileDto);
            MinIoFileUtil minIoFileUtil = new MinIoFileUtil(CommonConstant.BUCKET_NAME, minIoFileProperties);
            String imgUrl = minIoFileUtil.getSignedUrl(minIoFileDto.getFileNameOrUrl());
            logger.info(" 图片路径为{}", imgUrl);
            return super.handleResult(imgUrl);
        }
    
    
        /** * 上传图片 * * @param file * @return * @throws IOException */
        @PostMapping(value = "/setFile", consumes = "multipart/form-data")
        @ApiOperation(httpMethod = "Post", value = "上传图片")
        public Wrapper setFile(MultipartFile file, HttpServletRequest request) throws IOException { 
            logger.info(" setFile上传图片 ");
            MinIoFileUtil minIoFileUtil = new MinIoFileUtil(CommonConstant.BUCKET_NAME, minIoFileProperties);
            return super.handleResult(httpUrl + IMG_UTL + minIoFileUtil.upFile(file));
        }
    
        /** * 根据图片名称返回图片流 * * @param fileName * @return * @throws IOException */
        @GetMapping(value = "/auth/getFileIO")
        @ApiOperation(httpMethod = "Get", value = "根据图片名称返回图片流")
        public void setFile(@RequestParam("fileName") String fileName, HttpServletResponse response) throws Exception { 
            logger.info(" getFileIO 根据图片名称返回图片流 ");
            MinIoFileUtil minIoFileUtil = new MinIoFileUtil(CommonConstant.BUCKET_NAME, minIoFileProperties);
            String imgUrl = minIoFileUtil.getSignedUrl(fileName);
            minIoFileUtil.getFileIO(response, imgUrl);
        }
    
    }