• springboot整合minio上传文件

    1.安装minio

    这里采用docker进行安装。

    搜索该镜像：docker search minio

    找到了镜像：minio/minio

    拉取镜像：docker pull minio/minio

    启动镜像：

    docker run --name minio -p 9090:9000 -p 9999:9999 -d \
    --restart=always -e \
    "MINIO_ROOT_USER=minioadmin" \
    -e "MINIO_ROOT_PASSWORD=minioadmin123?" \
    -v /home/minio/data:/data \
    -v /home/minio/config:/root/.minio minio/minio server /data --console-address '0.0.0.0:9999'
     

    浏览器访问minio的控制台：

    http://ip:port

    访问到网页如下： 

    2.配置minio

    1.创建一个放图片的目录

    登录网页进去：

    点击左侧Buckets页面，然后点击右边的 Create Bucket 去创建一个目录，这个目录，如下，我创建了一个imgs，这个目录用来放上传的图片，需要记住这个目录，代码里面需要用

     

    2.创建上传文件需要的key

     需要把这两个key复制出来，代码里面需要用，就相当于账户密码之类的

    3.springboot整合minio

    1. 导入maven

    1.         
    2.         <dependency>
    3.             <groupId>io.miniogroupId>
    4.             <artifactId>minioartifactId>
    5.             <version>8.2.1version>
    6.         dependency>

    2.配置yml文件

    # minio文件系统配置
minio:
  # minio配置的地址，端口9090
  url: http://xxx.xx.xx.xx:9090
  # 账号
  accessKey: RKGZKAUGHKDY0XVN
  # 密码
  secretKey: HmTlAJoll7V0OjfBoyKmsIGF
  # MinIO桶名字
  bucketName: imgs

    3.代码部分

    MinioUtil.java
    1. package com.tn.humanenv.common.utils;
    2.  
    3. import io.minio.*;
    4. import io.minio.messages.DeleteError;
    5. import io.minio.messages.DeleteObject;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.stereotype.Component;
    8. import org.springframework.util.FastByteArrayOutputStream;
    9. import org.springframework.web.multipart.MultipartFile;
    10.  
    11. import javax.servlet.ServletOutputStream;
    12. import javax.servlet.http.HttpServletResponse;
    13. import java.util.List;
    14. import java.util.stream.Collectors;
    15.  
    16. /**
    17.  * minio存储
    18.  */
    19. @Component
    20. public class MinioUtil {
    21.     
    22.     @Autowired
    23.     private MinioClient minioClient;
    24.  
    25.  
    26.     /**
    27.      * @author xhw
    28.      * @生成文件名
    29.      * @param fileName
    30.      * @return
    31.      */
    32.     public String getUUIDFileName(String fileName) {
    33.         int idx = fileName.lastIndexOf(".");
    34.         String extention = fileName.substring(idx);
    35.         String newFileName = DateUtils.getDateTo_().replace("-","")+UUID.randomUUID().toString().replace("-","")+extention;
    36.         return newFileName;
    37.     }
    38.  
    39.  
    40.  
    41.     /**
    42.      * 查看存储bucket是否存在
    43.      *
    44.      * @param bucketName 存储bucket
    45.      * @return boolean
    46.      */
    47.     public Boolean bucketExists(String bucketName) {
    48.         Boolean found;
    49.         try {
    50.             found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
    51.         } catch (Exception e) {
    52.             e.printStackTrace();
    53.             return false;
    54.         }
    55.         return found;
    56.     }
    57.  
    58.     /**
    59.      * 创建存储bucket
    60.      *
    61.      * @param bucketName 存储bucket名称
    62.      * @return Boolean
    63.      */
    64.     public Boolean makeBucket(String bucketName) {
    65.         try {
    66.             minioClient.makeBucket(MakeBucketArgs.builder()
    67.                     .bucket(bucketName)
    68.                     .build());
    69.         } catch (Exception e) {
    70.             e.printStackTrace();
    71.             return false;
    72.         }
    73.         return true;
    74.     }
    75.  
    76.     /**
    77.      * 删除存储bucket
    78.      *
    79.      * @param bucketName 存储bucket名称
    80.      * @return Boolean
    81.      */
    82.     public Boolean removeBucket(String bucketName) {
    83.         try {
    84.             minioClient.removeBucket(RemoveBucketArgs.builder()
    85.                     .bucket(bucketName)
    86.                     .build());
    87.         } catch (Exception e) {
    88.             e.printStackTrace();
    89.             return false;
    90.         }
    91.         return true;
    92.     }
    93.  
    94.     /**
    95.      * 文件上传
    96.      *
    97.      * @param file       文件
    98.      * @param bucketName 存储bucket
    99.      * @return Boolean
    100.      */
    101.     public Boolean upload(MultipartFile file, String fileName, String bucketName) {
    102.         try {
    103.             PutObjectArgs objectArgs = PutObjectArgs.builder().bucket(bucketName).object(fileName)
    104.                     .stream(file.getInputStream(), file.getSize(), -1).contentType(file.getContentType()).build();
    105.             //文件名称相同会覆盖
    106.             minioClient.putObject(objectArgs);
    107.         } catch (Exception e) {
    108.             e.printStackTrace();
    109.             return false;
    110.         }
    111.         return true;
    112.     }
    113.  
    114.     /**
    115.      * 文件下载
    116.      *
    117.      * @param bucketName 存储bucket名称
    118.      * @param fileName   文件名称
    119.      * @param res        response
    120.      * @return Boolean
    121.      */
    122.     public void download(String bucketName, String fileName, HttpServletResponse res) {
    123.         GetObjectArgs objectArgs = GetObjectArgs.builder().bucket(bucketName)
    124.                 .object(fileName).build();
    125.         try (GetObjectResponse response = minioClient.getObject(objectArgs)) {
    126.             byte[] buf = new byte[1024];
    127.             int len;
    128.             try (FastByteArrayOutputStream os = new FastByteArrayOutputStream()) {
    129.                 while ((len = response.read(buf)) != -1) {
    130.                     os.write(buf, 0, len);
    131.                 }
    132.                 os.flush();
    133.                 byte[] bytes = os.toByteArray();
    134.                 res.setCharacterEncoding("utf-8");
    135.                 //设置强制下载不打开
    136.                 res.setContentType("application/force-download");
    137.                 res.addHeader("Content-Disposition", "attachment;fileName=" + fileName);
    138.                 try (ServletOutputStream stream = res.getOutputStream()) {
    139.                     stream.write(bytes);
    140.                     stream.flush();
    141.                 }
    142.             }
    143.         } catch (Exception e) {
    144.             e.printStackTrace();
    145.         }
    146.     }
    147.  
    148.     /**
    149.      * 查看文件对象
    150.      *
    151.      * @param bucketName 存储bucket名称
    152.      * @return 存储bucket内文件对象信息
    153.      */
    154. /*    public List listObjects(String bucketName) {
    155.         Iterable> results = minioClient.listObjects(
    156.                 ListObjectsArgs.builder().bucket(bucketName).build());
    157.         List objectItems = new ArrayList<>();
    158.         try {
    159.             for (Result result : results) {
    160.                 Item item = result.get();
    161.                 ObjectItem objectItem = new ObjectItem();
    162.                 objectItem.setObjectName(item.objectName());
    163.                 objectItem.setSize(item.size());
    164.                 objectItems.add(objectItem);
    165.             }
    166.         } catch (Exception e) {
    167.             e.printStackTrace();
    168.             return null;
    169.         }
    170.         return objectItems;
    171.     }*/
    172.  
    173.     /**
    174.      * 批量删除文件对象
    175.      *
    176.      * @param bucketName 存储bucket名称
    177.      * @param objects    对象名称集合
    178.      */
    179.     public Iterable> removeObjects(String bucketName, List objects) {
    180.         List dos = objects.stream().map(e -> new DeleteObject(e)).collect(Collectors.toList());
    181.         Iterable> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(dos).build());
    182.         return results;
    183.     }
    184. }
    SysFileController.java
    1. package com.tn.humanenv.controller;
    2.  
    3. import com.tn.humanenv.common.controller.BaseController;
    4. import com.tn.humanenv.common.domain.AjaxResult;
    5. import com.tn.humanenv.common.utils.StringUtils;
    6. import com.tn.humanenv.service.SysFileService;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.web.bind.annotation.RequestMapping;
    9. import org.springframework.web.bind.annotation.RequestMethod;
    10. import org.springframework.web.bind.annotation.RestController;
    11. import org.springframework.web.multipart.MultipartFile;
    12.  
    13. import java.util.Map;
    14.  
    15. /**
    16.  * @author xhw
    17.  * @desc 文件上传
    18.  * @date 2022/09/04
    19.  */
    20. @RestController
    21. @RequestMapping("/file")
    22. public class SysFileController extends BaseController {
    23.  
    24.     @Autowired
    25.     private SysFileService sysFileService;
    26.  
    27.     /**
    28.      * 图片上传minio
    29.      *
    30.      * @param file 图片文件
    31.      * @return 返回
    32.      */
    33.     @RequestMapping(value = "/upload", method = RequestMethod.POST)
    34.     public AjaxResult uploadFileMinio(MultipartFile file) {
    35.         Map map = sysFileService.uploadFileMinio(file);
    36.         if (StringUtils.isNotNull(map)) {
    37.             return AjaxResult.success(map);
    38.         }
    39.         return error("上传失败");
    40.     }
    41.  
    42. }

    SysFileServiceImpl.java
    1. package com.tn.humanenv.service.Impl;
    2.  
    3. import com.tn.humanenv.common.config.MinioConfig;
    4. import com.tn.humanenv.common.utils.MinioUtil;
    5. import com.tn.humanenv.service.SysFileService;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.stereotype.Service;
    8. import org.springframework.web.multipart.MultipartFile;
    9.  
    10. import java.util.HashMap;
    11. import java.util.Map;
    12.  
    13. @Service
    14. public class SysFileServiceImpl implements SysFileService {
    15.  
    16.     @Autowired
    17.     private MinioConfig minioConfig;
    18.  
    19.     @Autowired
    20.     private MinioUtil minioUtil;
    21.  
    22.     @Override
    23.     public Map uploadFileMinio(MultipartFile file) {
    24.         boolean flag = false;
    25.         if (file.isEmpty()) {
    26.             throw new RuntimeException("文件不存在！");
    27.         }
    28.         // 判断存储桶是否存在
    29.         if (!minioUtil.bucketExists(minioConfig.getBucketName())) {
    30.             minioUtil.makeBucket(minioConfig.getBucketName());
    31.         }
    32.         // 生成文件名
    33.         String newFileName = minioUtil.getUUIDFileName(file.getOriginalFilename());
    34.         try {
    35.             // 上传文件
    36.             flag = minioUtil.upload(file, newFileName, minioConfig.getBucketName());
    37.         } catch (Exception e) {
    38.             return null;
    39.         }
    40.         // 判断是否上传成功，成功就返回url，不成功就返回null
    41.         Map map = new HashMap<>();
    42.         map.put("url",minioConfig.getUrl() + "/" + minioConfig.getBucketName() + "/" + newFileName);
    43.         map.put("fileName",newFileName);
    44.         if (flag){
    45.             return map;
    46.         }
    47.         return null;
    48.     }
    49. }
    SysFileService.java
    1. package com.tn.humanenv.service;
    2.  
    3. import org.springframework.web.multipart.MultipartFile;
    4.  
    5. import java.util.Map;
    6.  
    7. public interface SysFileService {
    8.     public Map uploadFileMinio(MultipartFile file);
    9. }
    MinioConfig.java
    1. package com.tn.humanenv.common.config;
    2.  
    3. import io.minio.MinioClient;
    4. import org.springframework.boot.context.properties.ConfigurationProperties;
    5. import org.springframework.context.annotation.Bean;
    6. import org.springframework.context.annotation.Configuration;
    7.  
    8. @Configuration
    9. @ConfigurationProperties(prefix = "minio")
    10. public class MinioConfig {
    11.     /**
    12.      * 服务地址
    13.      */
    14.     public String url;
    15.  
    16.     /**
    17.      * 用户名
    18.      */
    19.     public String accessKey;
    20.  
    21.     /**
    22.      * 密码
    23.      */
    24.     public String secretKey;
    25.  
    26.     /**
    27.      * 存储桶名称
    28.      */
    29.     public String bucketName;
    30.  
    31.     // "如果是true，则用的是https而不是http,默认值是true"
    32.     public static Boolean secure = false;
    33.  
    34.     public String getUrl() {
    35.         return url;
    36.     }
    37.  
    38.     public void setUrl(String url) {
    39.         this.url = url;
    40.     }
    41.  
    42.     public String getAccessKey() {
    43.         return accessKey;
    44.     }
    45.  
    46.     public void setAccessKey(String accessKey) {
    47.         this.accessKey = accessKey;
    48.     }
    49.  
    50.     public String getSecretKey() {
    51.         return secretKey;
    52.     }
    53.  
    54.     public void setSecretKey(String secretKey) {
    55.         this.secretKey = secretKey;
    56.     }
    57.  
    58.     public String getBucketName() {
    59.         return bucketName;
    60.     }
    61.  
    62.     public void setBucketName(String bucketName) {
    63.         this.bucketName = bucketName;
    64.     }
    65.  
    66.     public static Boolean getSecure() {
    67.         return secure;
    68.     }
    69.  
    70.     public static void setSecure(Boolean secure) {
    71.         MinioConfig.secure = secure;
    72.     }
    73.  
    74.     @Bean
    75.     public MinioClient getMinioClient() {
    76.         return MinioClient.builder().endpoint(url).credentials(accessKey, secretKey).build();
    77.     }
    78. }

    4.测试上传图片

    调用接口如下： 

     

    把链接拿出来浏览器访问如下：

    上传excel文件如下： 

    访问该地址，直接就下载了这个excel文件：

     

    如上。

     

  • 相关阅读:
    含文档+PPT+源码等]javaweb企业员工信息管理系统的设计与实现薪酬|请假|薪资|工资
    Nginx安装
    时序预测 | MATLAB实现BiLSTM时间序列未来多步预测
    Spring Boot项目中使用jdbctemplate 操作MYSQL数据库
    内存优化总结: ptmalloc、tcmalloc 和 jemalloc
    小米软开一面
    全面开启 BI PaaS｜衡石十月头条
    智能化升级 —— 巧妙运用AI工具，提升职场与学习中的个人竞争力
    20221106 今天的世界发生了什么
    Auto.js中的一般全局函数
  • 原文地址：https://blog.csdn.net/weixin_38972910/article/details/126695785