springboot使用minio进行文件上传下载

安装minio参考Docker 搭建 MinIO_letterss的博客-CSDN博客 

 pom

    
            io.minio
            minio
            8.2.2
        

minio配置类 

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;


@Data
@ConfigurationProperties(prefix = "minio")
@Component
public class MinioProp {
    private String endpoint;
    private String accesskey;
    private String secretKey;
}

minio客户端配置

import io.minio.MinioClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;


@Configuration
public class MinioConfiguration {
    @Resource
    private MinioProp minioProp;

    @Bean
    public MinioClient minioClient() {
        MinioClient minioClient = MinioClient.builder()
                .endpoint(minioProp.getEndpoint())
                .credentials(minioProp.getAccesskey(), minioProp.getSecretKey())
                .build();
        return minioClient;
    }

}

方法工具类

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.dcqc.common.core.domain.R;
import com.dcqc.common.core.exception.baseException;
import com.dcqc.common.core.utils.IdUtils;
import com.dcqc.common.core.utils.StringUtils;
import com.dcqc.common.security.annotation.InnerAuth;
import com.dcqc.ykm1.manage.model.Ykm1File;
import com.dcqc.ykm1.manage.service.IYkm1FileService;
import io.minio.*;
import io.minio.messages.Bucket;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.net.URLEncoder;
import java.util.*;


@Slf4j
@RestController
@RequestMapping("/file")
@Api(value = "/file", description = "文件服务")
public class YkmFileController {

    @Autowired
    private MinioClient minioClient;

    @Resource
    private IYkm1FileService fileInfoService;

    @ApiOperation("上传文件")
    @PostMapping("/upload")
    public R upload(@RequestParam(name = "file", required = false) MultipartFile[] file, @RequestParam(name = "bucket") String bucket) {
        if (file == null || file.length == 0) {
            return R.fail("上传文件不能为空");
        }
        if (StringUtils.isBlank(bucket)) {
            return R.fail("文件桶不能为空");
        }
        List orgfileNameList = new ArrayList<>(file.length);

        for (MultipartFile multipartFile : file) {
            String orgfileName = multipartFile.getOriginalFilename();
            String fileId = IdUtils.fastSimpleUUID();
            try {
                InputStream in = multipartFile.getInputStream();
                //minioClient.putObject(minioBucket, orgfileName, in, new PutObjectOptions(in.available(), -1));
                ObjectWriteResponse objectWriteResponse = minioClient.putObject(
                        PutObjectArgs.builder()
                                .bucket(bucket)
                                .object(fileId)
                                .stream(in, in.available(), -1)
                                .build());
                in.close();
                boolean save = fileInfoService.save(new Ykm1File(orgfileName, fileId, bucket, new Date()));
                if (!save) {
                    log.error("文件保存数据库失败, bucket: {} fileId: {} fileName: {}", bucket, fileId, orgfileName);
                    return R.fail("文件保存数据库失败");
                }
                orgfileNameList.add(fileId);
            } catch (Exception e) {
                log.error(e.getMessage());
                return R.fail("上传失败");
            }
        }

        Map data = new HashMap();
        data.put("bucketName", bucket);
        data.put("fileName", orgfileNameList);
        return R.ok(data);
    }

    @ApiOperation("列出buckets列表")
    @GetMapping("/listBuckets")
    public R> listBuckets() {
        List bucketList = null;
        try {
            bucketList = minioClient.listBuckets();
        } catch (Exception e) {
            log.error(e.getMessage());
            return R.fail("获取文件桶列表失败");
        }
        ArrayList ret = new ArrayList<>();
        for (Bucket bucket : bucketList) {
            ret.add(bucket.name());
        }
        return R.ok(ret);
    }


    @ApiOperation("获取资源文件")
    @GetMapping(value = {"/download/{fileId}"})
    public void download(HttpServletResponse response, @PathVariable("fileId") String fileId) {
        try {
            QueryWrapper fileInfoQueryWrapper = new QueryWrapper<>();
            HashMap queryMap = new HashMap<>();
            queryMap.put("file_id", fileId);
            Ykm1File fileInfo = fileInfoService.getOne(fileInfoQueryWrapper.allEq(queryMap, false));
            if (fileInfo == null) {
                throw new baseException("资源不存在");
            }
            //response.setContentType(stat.contentType());
            GetObjectResponse getObjectResponse =
                    minioClient.getObject(
                            GetObjectArgs.builder().bucket(fileInfo.getBucket()).object(fileId).build());
            response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileInfo.getFileName(), "UTF-8"));
            IOUtils.copy(getObjectResponse, response.getOutputStream());
        } catch (Exception e) {
            log.error(e.getMessage());
        }
    }

    @ApiOperation("删除资源文件")
    @DeleteMapping(value = {"/del/{bucket}/{fileId}"})
    public R delete(@PathVariable(value = "bucket") String bucket, @PathVariable("fileId") String fileId) {
        try {
            QueryWrapper fileInfoQueryWrapper = new QueryWrapper<>();
            HashMap queryMap = new HashMap<>();
            queryMap.put("file_id", fileId);
            queryMap.put("bucket", bucket);
            fileInfoService.remove(fileInfoQueryWrapper.allEq(queryMap, false));
            minioClient.removeObject(
                    RemoveObjectArgs.builder()
                            .bucket(bucket)
                            .object(fileId)
                            .build()
            );
        } catch (Exception e) {
            log.error(e.getMessage());
            return R.fail("删除失败");
        }
        return R.ok();
    }

    @ApiOperation("根据文件标识获取文件名")
    @PostMapping(value = {"/query"})
    public R> query(@RequestBody List fileIds) {
        List relFileNames = fileInfoService.getRelFileName(fileIds);
        return R.ok(relFileNames);
    }
}