Springboot整合minio实现文件服务的教程详解

        <!--miNIO-->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>3.0.10</version>
        </dependency>

#minio配置
minio:
  endpoint: Http://${minio_host:172.16.10.21}:9000/
  accessKey: ${minio_user:minioadmin}
  secreTKEy: ${minio_pwd:minioadmin}
  bucket: ${minio_space:spacedata}
  http-url: http://${minio_url:172.16.10.21}:9000/
  imgSize: 10485760
  fileSize: 1048576000

import io.minio.messages.Item;
import io.minio.messages.Owner;
import io.swagger.annotations.apiModelProperty;
import lombok.Data;
 
import java.util.Date;
 
@Data
public class MinioItem {
    
    @ApiModelProperty("对象名称")
    private String objectName;
    
    @ApiModelProperty("最后操作时间")
    private Date lastModified;
    private String etag;
    
    @ApiModelProperty("对象大小")
    private String size;
    private String storageClass;
    private Owner owner;
    
    @ApiModelProperty("对象类型：directory（目录）或file（文件）")
    private String type;
 
    public MinioItem(String objectName, Date lastModified, String etag, String size, String storageClass, Owner owner, String type) {
        this.objectName = objectName;
        this.lastModified = lastModified;
        this.etag = etag;
        this.size = size;
        this.storageClass = storageClass;
        this.owner = owner;
        this.type = type;
    }
 
 
    public MinioItem(Item item) {
        this.objectName = item.objectName();
        this.type = item.isDir() ? "directory" : "file";
        this.etag = item.etag();
        long sizeNum = item.objectSize();
        this.size = sizeNum > 0 ? convertFileSize(sizeNum):"0";
        this.storageClass = item.storageClass();
        this.owner = item.owner();
        try {
            this.lastModified = item.lastModified();
        }catch(NullPointerException e){}
    }
 
    public String convertFileSize(long size) {
        long kb = 1024;
        long mb = kb * 1024;
        long gb = mb * 1024;
        if (size >= gb) {
            return String.fORMat("%.1f GB", (float) size / gb);
        } else if (size >= mb) {
            float f = (float) size / mb;
            return String.format(f > 100 ? "%.0f MB" : "%.1f MB", f);
        } else if (size >= kb) {
            float f = (float) size / kb;
            return String.format(f > 100 ? "%.0f KB" : "%.1f KB", f);
        } else{
            return String.format("%d B", size);
        }
    }
}

import com.GIS.spacedata.domain.dto.minio.MinioItem;
import com.Google.common.collect.Lists;
import io.minio.Minioclient;
import io.minio.ObjectStat;
import io.minio.Result;
import io.minio.errors.*;
import io.minio.messages.Bucket;
import io.minio.messages.Item;
import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpHeaders;
import org.springframework.http.httpstatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.util.FileCopyUtils;
import org.xmlpull.v1.XmlPullParserException;
 
import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
 
@Slf4j
@Component
@RequiredArgsConstructor
public class MinioTemplate implements InitializingBean {
 
    
    @Value("${minio.endpoint}")
    private String endpoint;
 
    
    @Value("${minio.accessKey}")
    private String accessKey;
 
    
    @Value("${minio.secretKey}")
    private String secretKey;
 
    
    @Value("${minio.http-url}")
    private String httpUrl;
 
    @Value("${minio.bucket}")
    private String bucket;
 
    private static MinioClient minioClient;
 
    @Override
    public void afterPropertiesSet() throws Exception {
        minioClient = new MinioClient(endpoint, accessKey, secretKey);
    }
 
    @SneakyThrows
    public boolean bucketExists(String bucketName) {
        return minioClient.bucketExists(bucketName);
    }
 
    
    @SneakyThrows
    public void createBucket(String bucketName) {
        if (!bucketExists(bucketName)) {
            minioClient.makeBucket(bucketName);
        }
    }
 
    
    @SneakyThrows
    public List<Bucket> getAllBuckets() {
        return minioClient.listBuckets();
    }
 
    
    @SneakyThrows
    public Optional<Bucket> getBucket(String bucketName) {
        return minioClient.listBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
    }
 
    
    @SneakyThrows
    public void removeBucket(String bucketName) {
        minioClient.removeBucket(bucketName);
    }
 
    
    @SneakyThrows
    public List<MinioItem> getAllObjectsByPrefix(String bucketName, String prefix, boolean recursive) {
        List<MinioItem> objectList = new ArrayList<>();
        Iterable<Result<Item>> objectsIterator = minioClient.listObjects(bucketName, prefix, recursive);
        for (Result<Item> result : objectsIterator) {
            objectList.add(new MinioItem(result.get()));
        }
        return objectList;
    }
 
    
    @SneakyThrows
    public String getObjectURL(String bucketName, String objectName, Integer expires) {
        return minioClient.presignedGetObject(bucketName, objectName, expires);
    }
 
    
    @SneakyThrows
    public String getObjectURL(String bucketName, String objectName) {
        return minioClient.presignedGetObject(bucketName, objectName);
    }
 
    
    @SneakyThrows
    public String getObjectUrl(String bucketName, String objectName) {
        return minioClient.getObjectUrl(bucketName, objectName);
    }
 
    
    @SneakyThrows
    public InputStream getObject(String bucketName, String objectName) {
        return minioClient.getObject(bucketName, objectName);
    }
 
    
    public void putObject(String bucketName, String objectName, InputStream stream) throws Exception {
        String contentType = "application/octet-stream";
        if ("JSON".equals(objectName.split("\\.")[1])) {
            //json格式，c++编译生成文件，需要直接读取
            contentType = "application/json";
        }
        minioClient.putObject(bucketName, objectName, stream, stream.available(), contentType);
    }
 
    
    public void putObject(String bucketName, String objectName, InputStream stream, long size, String contextType) throws Exception {
        minioClient.putObject(bucketName, objectName, stream, size, contextType);
    }
 
    
    public ObjectStat getObjectInfo(String bucketName, String objectName) throws Exception {
        return minioClient.statObject(bucketName, objectName);
    }
 
    
    public void removeObject(String bucketName, String objectName) {
        try {
            if (StringUtils.isNotBlank(objectName)) {
                if (objectName.endsWith(".") || objectName.endsWith("/")) {
                    Iterable<Result<Item>> list = minioClient.listObjects(bucketName, objectName);
                    list.forEach(e -> {
                        try {
                            minioClient.removeObject(bucketName, e.get().objectName());
                        } catch (InvalidBucketNameException invalidBucketNameException) {
                            invalidBucketNameException.printStackTrace();
                        } catch (NoSuchAlgorithmException noSuchAlgorithmException) {
                            noSuchAlgorithmException.printStackTrace();
                        } catch (InsufficientDataException insufficientDataException) {
                            insufficientDataException.printStackTrace();
                        } catch (IOException ioException) {
                            ioException.printStackTrace();
                        } catch (InvalidKeyException invalidKeyException) {
                            invalidKeyException.printStackTrace();
                        } catch (NoResponseException noResponseException) {
                            noResponseException.printStackTrace();
                        } catch (XmlPullParserException xmlPullParserException) {
                            xmlPullParserException.printStackTrace();
                        } catch (ErrorResponseException errorResponseException) {
                            errorResponseException.printStackTrace();
                        } catch (InternalException internalException) {
                            internalException.printStackTrace();
                        }
                    });
                }
            }
        } catch (XmlPullParserException e) {
            e.printStackTrace();
        }
    }
 
    
    public void downloadTargetDir(String bucketName, String objectName, String dirPath) {
        try {
            if (StringUtils.isNotBlank(objectName)) {
                if (objectName.endsWith(".") || objectName.endsWith("/")) {
                    Iterable<Result<Item>> list = minioClient.listObjects(bucketName, objectName);
                    list.forEach(e -> {
                        try {
                            String url = minioClient.getObjectUrl(bucketName, e.get().objectName());
                            getFile(url, dirPath);
                        } catch (InvalidBucketNameException invalidBucketNameException) {
                            invalidBucketNameException.printStackTrace();
                        } catch (NoSuchAlgorithmException noSuchAlgorithmException) {
                            noSuchAlgorithmException.printStackTrace();
                        } catch (InsufficientDataException insufficientDataException) {
                            insufficientDataException.printStackTrace();
                        } catch (IOException ioException) {
                            ioException.printStackTrace();
                        } catch (InvalidKeyException invalidKeyException) {
                            invalidKeyException.printStackTrace();
                        } catch (NoResponseException noResponseException) {
                            noResponseException.printStackTrace();
                        } catch (XmlPullParserException xmlPullParserException) {
                            xmlPullParserException.printStackTrace();
                        } catch (ErrorResponseException errorResponseException) {
                            errorResponseException.printStackTrace();
                        } catch (InternalException internalException) {
                            internalException.printStackTrace();
                        }
                    });
                }
            }
        } catch (XmlPullParserException e) {
            e.printStackTrace();
        }
    }
 
 
    public static void main(String[] args) throws
            NoSuchAlgorithmException, IOException, InvalidKeyException, XmlPullParserException {
        try {
            // 使用MinIO服务的URL，端口，Access key和Secret key创建一个MinioClient对象
            MinioClient minioClient = new MinioClient("http://172.16.10.201:9000/", "minioadmin", "minioadmin");
 
            // 检查存储桶是否已经存在
            boolean isExist = minioClient.bucketExists("spacedata");
            if (isExist) {
                System.out.println("Bucket already exists.");
            } else {
                // 创建一个名为asiatrip的存储桶，用于存储照片的zip文件。
                minioClient.makeBucket("spacedata");
            }
 
            // 使用putObject上传一个文件到存储桶中。
            //  minioClient.putObject("spacedata", "测试.jpg", "C:\\Users\\sundasheng44\\Desktop\\1.png");
 
            //  minioClient.removeObject("spacedata", "20200916/8ca27855ba884d7da1496fb96907a759.dwg");
            Iterable<Result<Item>> list = minioClient.listObjects("spacedata", "CompileResult/");
            List<String> list1 = Lists.newArrayList();
            list.forEach(e -> {
                try {
                    list1.add("1");
                    String url = minioClient.getObjectUrl("spacedata", e.get().objectName());
                    System.out.println(url);
                    //getFile(url, "C:\\Users\\liuya\\Desktop\\" + e.get().objectName());
                    System.out.println(e.get().objectName());
                    //   minioClient.removeObject("spacedata", e.get().objectName());
                } catch (InvalidBucketNameException invalidBucketNameException) {
                    invalidBucketNameException.printStackTrace();
                } catch (NoSuchAlgorithmException noSuchAlgorithmException) {
                    noSuchAlgorithmException.printStackTrace();
                } catch (InsufficientDataException insufficientDataException) {
                    insufficientDataException.printStackTrace();
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                } catch (InvalidKeyException invalidKeyException) {
                    invalidKeyException.printStackTrace();
                } catch (NoResponseException noResponseException) {
                    noResponseException.printStackTrace();
                } catch (XmlPullParserException xmlPullParserException) {
                    xmlPullParserException.printStackTrace();
                } catch (ErrorResponseException errorResponseException) {
                    errorResponseException.printStackTrace();
                } catch (InternalException internalException) {
                    internalException.printStackTrace();
                }
            });
            System.out.println(list1.size());
        } catch (MinioException e) {
            System.out.println("Error occurred: " + e);
        }
    }
 
    
    public ResponseEntity<byte[]> fileDownload(String url, String fileName, HttpServletRequest request) {
        return this.downloadMethod(url, fileName, request);
    }
 
    private File getFile(String url, String fileName) {
        InputStream in = null;
        // 创建文件
        String dirPath = fileName.substring(0, fileName.lastIndexOf("/"));
        File dir = new File(dirPath);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        File file = new File(fileName);
        try {
            URL url1 = new URL(url);
            in = url1.openStream();
            // 输入流转换为字节流
            byte[] buffer = FileCopyUtils.copyToByteArray(in);
            // 字节流写入文件
            FileCopyUtils.copy(buffer, file);
            // 关闭输入流
            in.close();
        } catch (IOException e) {
            log.error("文件获取失败：" + e);
            return null;
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                log.error("", e);
            }
        }
        return file;
    }
 
    public ResponseEntity<byte[]> downloadMethod(String url, String fileName, HttpServletRequest request) {
        HttpHeaders heads = new HttpHeaders();
        heads.add(HttpHeaders.CONTENT_TYPE, "application/octet-stream; charset=utf-8");
        try {
            if (request.getHeader("User-Agent").toLowerCase().indexOf("firefox") > 0) {
                // firefox浏览器
                fileName = new String(fileName.getBytes(StandardCharsets.UTF_8), "ISO8859-1");
            } else if (request.getHeader("User-Agent").toUpperCase().indexOf("MSIE") > 0) {
                // IE浏览器
                fileName = URLEncoder.encode(fileName, "UTF-8");
            } else if (request.getHeader("User-Agent").toUpperCase().indexOf("EDGE") > 0) {
                // WIN10浏览器
                fileName = URLEncoder.encode(fileName, "UTF-8");
            } else if (request.getHeader("User-Agent").toUpperCase().indexOf("CHROME") > 0) {
                // 谷歌
                fileName = new String(fileName.getBytes(StandardCharsets.UTF_8), "ISO8859-1");
            } else {
                //万能乱码问题解决
                fileName = new String(fileName.getBytes(StandardCharsets.UTF_8), StandardCharsets.ISO_8859_1);
            }
        } catch (UnsupportedEncodingException e) {
            // log.error("", e);
        }
        heads.add(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=" + fileName);
        try {
            //InputStream in = new FileInputStream(file);
            URL url1 = new URL(url);
            InputStream in = url1.openStream();
            // 输入流转换为字节流
            byte[] buffer = FileCopyUtils.copyToByteArray(in);
            ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(buffer, heads, HttpStatus.OK);
            //file.delete();
            return responseEntity;
        } catch (Exception e) {
            log.error("", e);
        }
        return null;
    }

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.gis.spacedata.common.constant.response.ResponseCodeConst;
import com.gis.spacedata.common.domain.ResponseDTO;
import com.gis.spacedata.domain.dto.file.vo.UploadVO;
import com.gis.spacedata.domain.dto.minio.MinioItem;
import com.gis.spacedata.domain.entity.file.FileEntity;
import com.gis.spacedata.enums.file.FileServiceTypeEnum;
import com.gis.spacedata.handler.SmartBusinessException;
import com.gis.spacedata.mapper.file.FileDao;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang3.StringUtils;
import org.springblade.core.tool.utils.FileUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.WEB.multipart.MultipartFile;
 
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.UUID;
 
@Service
@Slf4j
public class FilesMinioService extends ServiceImpl<FileDao, FileEntity> {
 
    @Autowired
    private MinioTemplate minioTemplate;
 
    @Resource
    private ThreadPoolTaskExecutor taskExecutor;
 
    
    @Value("#{${minio.imgSize}}")
    private Long imgSize;
 
    
    @Value("#{${minio.fileSize}}")
    private Long fileSize;
 
    @Value("${minio.bucket}")
    private String bucket;
 
    
    @Value("${minio.http-url}")
    private String httpUrl;
 
    
    private boolean isImage(String fileName) {
        //设置允许上传文件类型
        String suffixList = "jpg,gif,png,ico,bmp,jpeg";
        // 获取文件后缀
        String suffix = fileName.substring(fileName.lastIndexOf(".")
                + 1);
        return suffixList.contains(suffix.trim().toLowerCase());
    }
 
    
    private void fileCheck(MultipartFile upfile, String fileName) throws Exception {
        Long size = upfile.getSize();
        if (isImage(fileName)) {
            if (size > imgSize) {
                throw new Exception("上传对图片大于：" + (imgSize / 1024 / 1024) + "M限制");
            }
        } else {
            if (size > fileSize) {
                throw new Exception("上传对文件大于：" + (fileSize / 1024 / 1024) + "M限制");
            }
        }
    }
 
    
    public ResponseDTO<UploadVO> fileUpload(MultipartFile upfile) throws IOException {
        String originalFileName = upfile.getOriginalFilename();
        try {
            fileCheck(upfile, originalFileName);
        } catch (Exception e) {
            return ResponseDTO.wrap(ResponseCodeConst.ERROR, e.getMessage());
        }
        if (StringUtils.isBlank(originalFileName)) {
            return ResponseDTO.wrap(ResponseCodeConst.ERROR_PARAM, "文件名称不能为空");
        }
        UploadVO vo = new UploadVO();
        String url;
        //获取文件md5，查找数据库，如果有，则不需要上传了
        String md5 = DigestUtils.md5Hex(upfile.getInputStream());
        QueryWrapper<FileEntity> query = new QueryWrapper<>();
        query.lambda().eq(FileEntity::getMd5, md5);
        query.lambda().eq(FileEntity::getStorageType, FileServiceTypeEnum.MINIO_OSS.getLocationType());
        FileEntity fileEntity = baseMapper.selectOne(query);
        if (null != fileEntity) {
            //url = minioTemplate.getObjectURL(bucket,fileEntity.getFileName());
            vo.setId(fileEntity.getId());
            vo.setFileName(originalFileName);
            vo.setUrl(httpUrl + fileEntity.getFileUrl());
            vo.setNewFileName(fileEntity.getFileName());
            vo.setFileSize(upfile.getSize());
            vo.setFileLocationType(FileServiceTypeEnum.MINIO_OSS.getLocationType());
            log.info("文件已上传，直接获取");
            return ResponseDTO.succData(vo);
        }
        //拼接文件名
        String fileName = generateFileName(originalFileName);
        try {
            // 检查存储桶是否已经存在
            boolean isExist = minioTemplate.bucketExists(bucket);
            if (isExist) {
                log.info("Bucket already exists.");
            } else {
                // 创建一个名为asiatrip的存储桶，用于存储照片的zip文件。
                minioTemplate.createBucket(bucket);
            }
            // 使用putObject上传一个文件到存储桶中。
            minioTemplate.putObject(bucket, fileName, upfile.getInputStream());
            log.info("上传成功.");
            //生成一个外部链接
            //url = minioTemplate.getObjectURL(bucket,fileName);
            //已经设置永久链接，直接获取
            url = httpUrl + bucket + "/" + fileName;
            fileEntity = new FileEntity();
            fileEntity.setStorageType(FileServiceTypeEnum.MINIO_OSS.getLocationType());
            fileEntity.setFileName(fileName);
            fileEntity.setOriginalFileName(originalFileName);
            fileEntity.setFileUrl(bucket + "/" + fileName);
            fileEntity.setFileSize(upfile.getSize());
            fileEntity.setMd5(md5);
            baseMapper.insert(fileEntity);
        } catch (Exception e) {
            return ResponseDTO.wrap(ResponseCodeConst.ERROR, "上传失败！");
        }
        vo.setFileName(originalFileName);
        vo.setId(fileEntity.getId());
        vo.setUrl(url);
        vo.setNewFileName(fileName);
        vo.setFileSize(upfile.getSize());
        vo.setFileLocationType(FileServiceTypeEnum.MINIO_OSS.getLocationType());
 
        return ResponseDTO.succData(vo);
    }
 
    
    private String generateFileName(String originalFileName) {
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
        String uuid = UUID.randomUUID().toString().replaceAll("-", "");
        String fileType = originalFileName.substring(originalFileName.lastIndexOf("."));
        return time + "/" + uuid + fileType;
    }
 
    
    public ResponseDTO<UploadVO> fileUploadRep(MultipartFile upfile) throws IOException {
        String originalFileName = upfile.getOriginalFilename();
        try {
            fileCheck(upfile, originalFileName);
        } catch (Exception e) {
            return ResponseDTO.wrap(ResponseCodeConst.ERROR, e.getMessage());
        }
        if (StringUtils.isBlank(originalFileName)) {
            return ResponseDTO.wrap(ResponseCodeConst.ERROR_PARAM, "文件名称不能为空");
        }
        UploadVO vo = new UploadVO();
        String url;
        //获取文件md5
        FileEntity fileEntity = new FileEntity();
        //拼接文件名
        String fileName = generateFileName(originalFileName);
        try {
            // 检查存储桶是否已经存在
            boolean isExist = minioTemplate.bucketExists(bucket);
            if (isExist) {
                log.info("Bucket already exists.");
            } else {
                // 创建一个名为asiatrip的存储桶，用于存储照片的zip文件。
                minioTemplate.createBucket(bucket);
            }
            // 使用putObject上传一个文件到存储桶中。
            minioTemplate.putObject(bucket, fileName, upfile.getInputStream());
            log.info("上传成功.");
            //生成一个外部链接
            //url = minioTemplate.getObjectURL(bucket,fileName);
            //已经设置永久链接，直接获取
            url = httpUrl + bucket + "/" + fileName;
            fileEntity.setStorageType(FileServiceTypeEnum.MINIO_OSS.getLocationType());
            fileEntity.setFileName(fileName);
            fileEntity.setOriginalFileName(originalFileName);
            fileEntity.setFileUrl(bucket + "/" + fileName);
            fileEntity.setFileSize(upfile.getSize());
            baseMapper.insert(fileEntity);
        } catch (Exception e) {
            return ResponseDTO.wrap(ResponseCodeConst.ERROR, "上传失败！");
        }
        vo.setFileName(originalFileName);
        vo.setId(fileEntity.getId());
        vo.setUrl(url);
        vo.setNewFileName(fileName);
        vo.setFileSize(upfile.getSize());
        vo.setFileLocationType(FileServiceTypeEnum.MINIO_OSS.getLocationType());
 
        return ResponseDTO.succData(vo);
    }
 
    
    public ResponseDTO<UploadVO> uploadStream(InputStream inputStream, String originalFileName) {
        UploadVO vo = new UploadVO();
        String url;
        //文件名
        String fileName = originalFileName;
        try {
            // 检查存储桶是否已经存在
            boolean isExist = minioTemplate.bucketExists(bucket);
            if (isExist) {
                log.info("Bucket already exists.");
            } else {
                // 创建一个名为asiatrip的存储桶，用于存储照片的zip文件。
                minioTemplate.createBucket(bucket);
            }
            // 使用putObject上传一个文件到存储桶中。
            minioTemplate.putObject(bucket, fileName, inputStream);
            log.info("上传成功.");
            //生成一个外部链接
            //url = minioTemplate.getObjectURL(bucket,fileName);
            //已经设置永久链接，直接获取
            url = httpUrl + bucket + "/" + fileName;
        } catch (Exception e) {
            return ResponseDTO.wrap(ResponseCodeConst.ERROR, "上传失败！");
        }
        vo.setFileName(originalFileName);
        vo.setUrl(url);
        vo.setNewFileName(fileName);
        vo.setFileLocationType(FileServiceTypeEnum.MINIO_OSS.getLocationType());
 
        return ResponseDTO.succData(vo);
    }
 
    private String generateFileNameTwo(String originalFileName) {
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
        return time + "/" + originalFileName;
    }
 
    
    public ResponseDTO<UploadVO> findFileById(Long id) {
        FileEntity fileEntity = baseMapper.selectById(id);
        if (null == fileEntity) {
            return ResponseDTO.wrap(ResponseCodeConst.ERROR_PARAM, "文件不存在");
        }
        UploadVO vo = new UploadVO();
        
        vo.setFileName(fileEntity.getOriginalFileName());
        vo.setUrl(httpUrl + fileEntity.getFileUrl());
        vo.setNewFileName(fileEntity.getFileName());
        vo.setFileSize(fileEntity.getFileSize());
        vo.setFileLocationType(FileServiceTypeEnum.MINIO_OSS.getLocationType());
        return ResponseDTO.succData(vo);
    }
 
 
    
    public ResponseEntity<byte[]> downLoadFile(Long id, HttpServletRequest request) {
        FileEntity fileEntity = baseMapper.selectById(id);
        if (null == fileEntity) {
            throw new SmartBusinessException("文件信息不存在");
        }
        if (StringUtils.isEmpty(fileEntity.getFileUrl())) {
            throw new SmartBusinessException("文件url为空");
        }
        ResponseEntity<byte[]> stream = minioTemplate.fileDownload(httpUrl + fileEntity.getFileUrl(), fileEntity.getOriginalFileName(), request);
        return stream;
    }
 
    
    public ResponseDTO<String> deleteFiles(List<String> fileNames) {
        try {
            for (String fileName : fileNames) {
                minioTemplate.removeObject(bucket, fileName);
            }
        } catch (Exception e) {
            return ResponseDTO.wrap(ResponseCodeConst.ERROR, e.getMessage());
        }
        return ResponseDTO.succ();
    }
 
    
    public ResponseDTO<String> downloadTargetDir(String objectName, String dirPath) {
        minioTemplate.downloadTargetDir(bucket, objectName, dirPath);
        return ResponseDTO.succ();
    }
 
    
    public Boolean downloadCompile(String dirPath) {
        if (!minioTemplate.bucketExists(bucket)) {
            log.info("Bucket not exists.");
            return true;
        }
 
        List<MinioItem> list = minioTemplate.getAllObjectsByPrefix(bucket, "CompileResult/", true);
        list.forEach(e -> {
            String url = minioTemplate.getObjectUrl(bucket, e.getObjectName());
            InputStream minioStream = minioTemplate.getObject(bucket, e.getObjectName());
            File file = new File(dirPath + url.substring(url.indexOf("CompileResult")-1));
            if (!file.getParentFile().exists()) {
                file.getParentFile().mkdirs();
            }
            FileUtil.toFile(minioStream, file);
        });
 
        log.info("downloadCompile complete.");
        return true;
    }

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.gis.spacedata.common.anno.NoNeedLogin;
import com.gis.spacedata.common.domain.ResponseDTO;
import com.gis.spacedata.domain.dto.file.vo.UploadVO;
import com.gis.spacedata.service.file.FilesMinioService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
 
import javax.servlet.http.HttpServletRequest;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.List;
 
@Api(tags = {"minio文件服务"})
@RestController
public class FilesMinioController {
 
    @Autowired
    private FilesMinioService filesMinioService;
 
 
    @ApiOperation(value = "文件上传(md5去重上传) by sunboqiang")
    @PostMapping("/minio/uploadFile/md5")
    @NoNeedLogin
    public ResponseDTO<UploadVO> uploadFile(MultipartFile file) throws IOException {
        return filesMinioService.fileUpload(file);
    }
 
    @ApiOperation(value = "文件上传(不做重复校验) by sunboqiang")
    @PostMapping("/minio/uploadFile/noRepeatCheck")
    public ResponseDTO<UploadVO> fileUploadRep(MultipartFile file) throws IOException {
        return filesMinioService.fileUploadRep(file);
    }
 
    @ApiOperation(value = "文件流上传 by sunboqiang")
    @PostMapping("/minio/uploadFile/stream/{fileName}")
    public ResponseDTO<UploadVO> uploadStream(InputStream inputStream, @PathVariable("fileName") String fileName) throws IOException {
        return filesMinioService.uploadStream(inputStream, fileName);
    }
 
    @ApiOperation(value = "文件查询（永久链接） by sunboqiang")
    @GetMapping("/minio/getFileUrl/{id}")
    public ResponseDTO<UploadVO> findFileById(@PathVariable("id") Long id) {
        return filesMinioService.findFileById(id);
    }
 
    @ApiOperation(value = "文件流式下载 by sunboqiang")
    @GetMapping("/minio/downloadFile/stream")
    public ResponseEntity<byte[]> downLoadFile(@RequestParam Long id, HttpServletRequest request) {
        return filesMinioService.downLoadFile(id, request);
    }
 
    @ApiOperation(value = "文件删除(通过文件名) by sunboqiang")
    @PostMapping("/minio/deleteFiles")
    public ResponseDTO<String> deleteFiles(@RequestBody List<String> fileNames) {
        return filesMinioService.deleteFiles(fileNames);
    }
}