分布式文件服务

<!-- minio support -->
<dependency>
  <groupId>io.minio</groupId>
  <artifactId>minio</artifactId>
  <version>${minio.version}</version> <!-- 6.0.8 -->
  <exclusions>
    <exclusion>
      <groupId>com.squareup.okhttp3</groupId>
      <artifactId>okhttp</artifactId>
    </exclusion>
  </exclusions>
</dependency>
<!-- 解决版本冲突问题，如果不主动覆盖，默认引入3.8.1会报错 -->
<dependency>
  <groupId>com.squareup.okhttp3</groupId>
  <artifactId>okhttp</artifactId>
  <version>3.13.1</version><!--$NO-MVN-MAN-VER$-->
</dependency>
复制

@Configuration
@ConfigurationProperties(ignoreInvalidFields=true, ignoreUnknownFields=true, prefix="minio")
@Data
public class MinioConfig {
  // 地址
    private String endpoint;
    private String accessKey;
    private String secretKey;
}
复制

/**
 * minio 交互类
 *
 * @author zhangwy
 */
@Component
@Repository
public class MinioTemplate implements InitializingBean {
    @Autowired
    MinioConfig minioConfig;
    @Autowired
    private FileService fileService;


    private MinioClient client;


    @Override
    public void afterPropertiesSet() throws Exception {
        this.client = new MinioClient(minioConfig.getEndpoint(), minioConfig.getAccessKey(), minioConfig.getSecretKey());
    }
    /**
     * 判断bucket是否存在
     * 
     * @param bucketName
     * @return boolean
     * */
    @SneakyThrows
    public boolean bucketExists(String bucketName) {
        return client.bucketExists(bucketName);
    }


    /**
     * 创建bucket
     *
     * @param bucketName
     */
    @SneakyThrows
    public void createBucket(String bucketName) {
        if (!bucketExists(bucketName)) {
            client.makeBucket(bucketName);
        }
    }


    /**
     * 获取全部bucket
     * 
     * @return List<Bucket>
     */
    @SneakyThrows
    public List<Bucket> getAllBuckets() {
        return client.listBuckets();
    }


    /**
     * 获取所有bucket的Object
     * 
     * @param bucketName
     * @return List<MinioItem>
     * */
    @SneakyThrows
    public List<MinioItem> getAllObjects(String bucketName) {
        List<MinioItem> objectList = new ArrayList<>();
        if(this.bucketExists(bucketName)) {
            Iterable<Result<Item>> objectsIterator = client.listObjects(bucketName);
            while (objectsIterator.iterator().hasNext()) {
                objectList.add(new MinioItem(objectsIterator.iterator().next().get()));
            }
        }
        return objectList;
    } 


    /**
     * 根据文件前缀查询文件
     *
     * @param bucketName
     * @param prefix
     * @param recursive 是否递归查询
     * @return List<MinioItem>
     */
    @SneakyThrows
    public List<MinioItem> getAllObjectsByPrefix(String bucketName, String prefix, boolean recursive) {
        List<MinioItem> objectList = new ArrayList<>();
        if(this.bucketExists(bucketName)) {
            Iterable<Result<Item>> objectsIterator = client.listObjects(bucketName, prefix, recursive);
            while (objectsIterator.iterator().hasNext()) {
                objectList.add(new MinioItem(objectsIterator.iterator().next().get()));
            }
        }
        return objectList;
    }


    /**
     * 根据名称查找bucket
     * 
     * @param bucketName
     * @return Optional<Bucket>
     */
    @SneakyThrows
    public Optional<Bucket> getBucket(String bucketName) {
        return client.listBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
    }


    /**
     * 根据bucket名称移除bucket
     * 
     * @param bucketName
     */
    @SneakyThrows
    public void removeBucket(String bucketName) {
        if(bucketExists(bucketName)) {
            client.removeBucket(bucketName);
        }
    }


    /**
     * 查询未完成的上传
     * 
     * @param bucketName
     * @return List<MinioUpload>
     */
    @SneakyThrows
    public List<MinioUpload> getIncompleteUploads(String bucketName) {
        List<MinioUpload> uploadList = new ArrayList<>();
        if(bucketExists(bucketName)) {
            Iterable<Result<Upload>> uploadIterator = client.listIncompleteUploads(bucketName);
            while (uploadIterator.iterator().hasNext()) {
                uploadList.add(new MinioUpload(uploadIterator.iterator().next().get()));
            }
        }
        return uploadList;
    }


    /**
     * 删除未完成的上传
     * 
     * @param bucketName
     * @param objectName
     */
    @SneakyThrows
    public void removeIncompleteUploads(String bucketName, String objectName) {
        client.removeIncompleteUpload(bucketName, objectName);
    }


    /**
     * 上传文件
     *
     * @param bucketName 桶名 
     * @param objectName 对象名
     * @param stream 文件流
     * @throws Exception
     */
    @SneakyThrows
    public void putObject(String bucketName, String objectName, InputStream stream) throws IOException {
        putObject(bucketName, objectName, stream, Long.valueOf(stream.available()), null, null, "application/octet-stream");
    }
    @SneakyThrows
    public String putObject(String bucketName, MultipartFile mFile) {
        //判断桶名是否存在,不存在则创建
        createBucket(bucketName);
        SimpleDateFormat sdfOne = new SimpleDateFormat("yyyyMMdd");
        //生成日期+随机+原始文件名
        String ymd = sdfOne.format(new Date());
        String uuid = UUID.randomUUID().toString();
        String name = mFile.getOriginalFilename();
        String minIoName = ymd+"/"+uuid+"/"+name;
        putObject(bucketName, minIoName , mFile.getInputStream(), mFile.getSize(), null, null, mFile.getContentType());
        //保存在数据库里
        File file = new File();
        file.setBucket(bucketName);
        file.setDir(ymd);
        file.setUuid(uuid);
        file.setName(name);
        file.setType(name.substring(name.lastIndexOf(".")+1));
        file.setSize(mFile.getSize());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String nowTime = sdf.format(new Date());
        Date gmtCreate = null;
        try {
            gmtCreate = new java.sql.Date(sdf.parse(nowTime).getTime());
        } catch (ParseException e1) {
            e1.printStackTrace();
        }
        file.setGmtCreate(gmtCreate);
        User user = UserContext.getUser();
        int userId = 0;
        if (user != null) {
            userId = user.getId();
        }
        file.setCreator(userId);
        fileService.save(file);
        return file.getId().toString();
    }
    @SneakyThrows
    public String getUrl(int id) {
        File file = fileService.getOne(id);
        String name = file.getDir()+"/"+file.getUuid()+"/"+file.getName();
        String bucketName = file.getBucket();
        String objectURL = getObjectURL(bucketName, name);
        return objectURL;
    }


    @SneakyThrows
    public List<Map<String, Object>> getUrls(String ids) {
        List<Integer> idList= Util.string2IntList(ids);
        List<Map<String, Object>> maps = new ArrayList<Map<String,Object>>();
        for (int i = 0; i < idList.size(); i++) {
            int id = idList.get(i);
            File file = fileService.getOne(id);
            String url = getUrl(id);
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("id", file.getId());
            map.put("fileName", file.getName());
            map.put("url", url);
            maps.add(map);
        }
        return maps;
    }


    @SneakyThrows
    public String putObjects(String bucketName, MultipartFile[] files) {
        //判断桶名是否存在
        createBucket(bucketName);
        List<String> list = new ArrayList<String>();
        if (files.length != 0) {
            for (int i = 0; i < files.length; i++) {
                if (!files[i].isEmpty() ) {
                    String id = putObject(bucketName, files[i]);
                    list.add(id);
                }
            }
        }
        String ids = Util.list2String(list);
        return ids;
    }
    @SneakyThrows
    public void putObject(String bucketName,String objectName, MultipartFile file) {
        putObject(bucketName, objectName, file.getInputStream(), file.getSize(), null, null, file.getContentType());
    }
    @SneakyThrows
    public void putObject(String bucketName, String objectName, InputStream stream, String contentType) {
        putObject(bucketName, objectName, stream, Long.valueOf(stream.available()), null, null, contentType);
    }
    @SneakyThrows
    public void putObject(String bucketName, String objectName, InputStream stream, long size, Map<String,String> headerMap, ServerSideEncryption sse, String contentType) throws IOException {
        if("".equals(StringUtil.null2String(contentType))) {
            contentType = "application/octet-stream";
        }
        if(size == 0) {
            size = Long.valueOf(stream.available());
        }
        client.putObject(bucketName, objectName, stream, size, headerMap, sse, contentType);
    }


    /**
     * KMS加密
     *  Map<String,String> myContext = new HashMap<>();
     *  myContext.put("key1","value1");
     *  ServerSideEncryption sse = ServerSideEncryption.withManagedKeys("Key-Id", myContext);
     * S3加密
     *  ServerSideEncryption sse = ServerSideEncryption.atRest();
     * AES加密
     *  KeyGenerator keyGen = KeyGenerator.getInstance("AES");
     *  keyGen.init(256);
     *  ServerSideEncryption sse = ServerSideEncryption.withCustomerKey(keyGen.generateKey());
     * */
    @SneakyThrows
    public void putObjectEncrypted(String bucketName, String objectName, InputStream stream, ServerSideEncryption sse) {
        putObject(bucketName, objectName, stream,Long.valueOf(stream.available()), null, sse, "application/octet-stream");
    }
    /**
     * 示例
     * // Create metadata map
     * Map<String, String> headerMap = new HashMap<>();
     * // Add custom metadata
     * headerMap.put("CustomMeta", "TEST");
     * // Add custom content type
     * headerMap.put("Content-Type", "application/octet-stream");
     * // Add storage class
     * headerMap.put("X-Amz-Storage-Class", "REDUCED_REDUNDANCY");
     * */
    @SneakyThrows
    public void putObjectWithHeader(String bucketName, String objectName, InputStream stream, Map<String,String> headerMap) throws Exception {
        putObject(bucketName, objectName, stream,Long.valueOf(stream.available()), headerMap, null, "application/octet-stream");
    }


    public boolean objectExists(String bucketName, String objectName) {
        try {
            client.statObject(bucketName, objectName);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    /**
     * 复制对象
     * 
     * @param sourceBucketName
     * @param sourceObjectName
     * @param targetBucketName
     * @param targetObjectName
     * */
    @SneakyThrows
    public void copyObject(String sourceBucketName, String sourceObjectName, String targetBucketName, String targetObjectName) {
        if(objectExists(sourceBucketName,sourceObjectName)) {
            client.copyObject(sourceBucketName, sourceObjectName, targetBucketName, targetObjectName);
        }
    }


    /**
     * 获取文件信息
     *
     * @param bucketName
     * @param objectName
     * @return ObjectStat
     */
    @SneakyThrows
    public ObjectStat getObjectInfo(String bucketName, String objectName) {
        if (objectExists(bucketName,objectName)) {
            return client.statObject(bucketName, objectName);
        } else {
            return null;
        }
    }


    /**
     * 获取多文件信息
     *
     * @param fileIds
     * @param bucketName
     * @return ObjectStat
     */
    @SneakyThrows
    public List<MinioObject> getObjectInfos(String fileIds, String bucketName) {
        List<Integer> ids = Util.string2IntList(fileIds);
        List<MinioObject> listFile = new ArrayList<MinioObject>();
        String objectName = "";
        File file = new File();
        for (int i = 0; i < ids.size(); i++) {
            file = fileService.getOne(ids.get(i));
            objectName = file.getDir()+"/"+file.getUuid()+"/"+file.getName();
            ObjectStat objectInfo = getObjectInfo(bucketName, objectName);
            MinioObject minioObject = new MinioObject(objectInfo);
            listFile.add(minioObject);
        }
        return listFile;
    }


    /**
     * 获取文件
     *
     * @param bucketName
     * @param objectName
     * @return InputStream
     */
    @SneakyThrows
    public InputStream getObject(String bucketName, String objectName) {
        if (objectExists(bucketName,objectName)) {
            return client.getObject(bucketName, objectName);
        } else {
            return null;
        }
    }


    /**
     * 下载文件保存到本地
     *
     * @param bucketName
     * @param objectName
     * @param fileName
     */
    @SneakyThrows
    public void getObject(String bucketName, String objectName, String fileName) {
        if (objectExists(bucketName,objectName)) {
            client.getObject(bucketName, objectName, fileName);
        }
    }


    /**
     * 删除单个文件
     *
     * @param bucketName
     * @param objectName
     */
    @SneakyThrows
    public void removeObject(String bucketName, String objectName) {
        if(objectExists(bucketName,objectName)) {
            client.removeObject(bucketName, objectName);
        }
    }
    /**
     * 删除多个文件
     *
     * @param bucketName
     * @param objectNames
     */
    @SneakyThrows
    public void removeObjects(String bucketName, List<String> objectNames) {
        client.removeObjects(bucketName, objectNames);
    }
    /**
     * 获取文件外链,默认过期时间为七天
     *
     * @param bucketName
     * @param objectName
     * @return url
     */
    @SneakyThrows
    public String getObjectURL(String bucketName, String objectName) {
        return getObjectURL(bucketName, objectName, 7 * 24 * 3600);
    }


    /**
     * 获取文件外链
     *
     * @author zhuhui
     * @date 2019-07-09
     * @param bucketName
     * @param objectName
     * @param expires
     * @return
     */
    @SneakyThrows
    public String getObjectURL(String bucketName, String objectName,Integer expires) {
        if(objectExists(bucketName,objectName)) {
            return client.presignedGetObject(bucketName, objectName, expires);
        } else {
            return "";
        }
    }
    /**
     * 单文件上传返回ID
     *
     * @author zhuhui
     * @date 2019-07-08
     * @param file
     * @param bucketName
     * @return id
     */
    public String fileUpload(MultipartFile file, String bucketName) {
        return putObject(bucketName, file);
    }


    /**
     * 通过spring的多文件上传
     *
     * @author zhuhui
     * @date 2019-07-09
     * @param multipartRequest
     * @param bucketName
     * @return ids
     */
    public Map<String, String> fileUploads(DefaultMultipartHttpServletRequest multipartRequest, String bucketName) {
        //判断桶名是否存在,不存在则创建
        createBucket(bucketName);
        String ids = "";
        if (multipartRequest != null) {
            List<String> list = new ArrayList<String>();
            Iterator<String> iterator = multipartRequest.getFileNames();
            while (iterator.hasNext()) {
                ////单文件上传 。
                //MultipartFile file = multipartRequest.getFile(iterator.next());//一次传一个文件
                //if (StringUtils.hasText(file.getOriginalFilename())) {
                //    file.transferTo(new File("E:/upload_" + file.getOriginalFilename()));
                //}


                // 多文件上传
                List<MultipartFile> fileList = multipartRequest.getFiles(iterator.next());
                for (MultipartFile file : fileList) {
                    if (StringUtils.hasText(file.getOriginalFilename())) {
                        String id = putObject(bucketName, file);
                        list.add(id);
                    }
                }
            }
            ids = Util.list2String(list);
        }
        Map<String, String> map = new HashMap<String, String>();
        map.put("ids", ids);
        return map;
    }


    public void updateFile(int contactId, String ids) {
        fileService.updateFile(contactId, ids);
    }
    public String fileUploadsByIo(String files, String bucketName) throws IOException {
        String ids = "";
        List<String> list = new ArrayList<String>();
        JSONObject object = JSONObject.fromObject(files);
        Map<String, Object> map =  object;
        for (String fileName : map.keySet()) {
            String base64 = map.get(fileName).toString();
            ByteArrayInputStream stream =new Base64Convert().base64ToIo(base64);   //将字符串转换为byte数组
            //判断桶名是否存在,不存在则创建
            createBucket(bucketName);
            SimpleDateFormat sdfOne = new SimpleDateFormat("yyyyMMdd");
            //生成日期+随机+原始文件名
            String ymd = sdfOne.format(new Date());
            String uuid = UUID.randomUUID().toString();
            String minIoName = ymd+"/"+uuid+"/"+fileName;
            putObject(bucketName, minIoName, stream);
          //保存在数据库里
            File file = new File();
            file.setBucket(bucketName);
            file.setDir(ymd);
            file.setUuid(uuid);
            file.setName(fileName);
            file.setType(fileName.substring(fileName.lastIndexOf(".")+1));
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String nowTime = sdf.format(new Date());
            Date gmtCreate = null;
            try {
                gmtCreate = new java.sql.Date(sdf.parse(nowTime).getTime());
            } catch (ParseException e1) {
                e1.printStackTrace();
            }
            file.setGmtCreate(gmtCreate);
            User user = UserContext.getUser();
            int userId = 0;
            if (user != null) {
                userId = user.getId();
            }
            file.setCreator(userId);
            fileService.save(file);
            list.add(file.getId().toString());
        }
        ids = Util.list2String(list);
        return ids;
    }


    /**
     * 多文件上传返回ID
     *
     * @author zhuhui
     * @date 2019-07-05
     * @param userName
     * @param files
     * @param bucketName
     */
    /*
    public String fileUploads(MultipartFile[] files, String bucketName) {
        return putObjects(bucketName, files);
    }
    */
}
复制

minIoName = ymd+"/"+uuid+"/"+fileName;
复制