精华内容
下载资源
问答
  • springboot整合minio
    2022-04-30 22:46:33

    Springboot整合MinIo

    pom 文件添加

      <dependency>
                <groupId>io.minio</groupId>
                <artifactId>minio</artifactId>
                <version>7.1.0</version>
            </dependency>

    application.yml 配置

    minio:
      endpoint: http://host:端口
      accessKey: 
      secretKey: 密码
      bucketName: 桶名称

    MinIoClientConfig 配置类
    package com.example.securdemo.miniUtils;
    
    import io.minio.MinioClient;
    import lombok.Data;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.stereotype.Component;
    
    @Data
    @Component
    public class MinIoClientConfig {
        @Value("${minio.endpoint}")
        private String endpoint;
        @Value("${minio.accessKey}")
        private String accessKey;
        @Value("${minio.secretKey}")
        private String secretKey;
    
        /**
         * 注入minio 客户端
         * @return
         */
        @Bean
        public MinioClient minioClient(){
    
            return MinioClient.builder()
                    .endpoint(endpoint)
                    .credentials(accessKey, secretKey)
                    .build();
        }
    
    }
    

    package com.example.securdemo.miniUtils;
    
    import io.minio.*;
    import io.minio.messages.DeleteError;
    import io.minio.messages.DeleteObject;
    import io.minio.messages.Item;
    import org.apache.tomcat.util.http.fileupload.IOUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.HttpStatus;
    import org.springframework.http.MediaType;
    import org.springframework.http.ResponseEntity;
    import org.springframework.stereotype.Component;
    import org.springframework.web.multipart.MultipartFile;
    
    import java.io.*;
    import java.net.URLEncoder;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    
    /**
     * @description: minio工具类
     * @version:3.0
     */
    @Component
    public class MinioUtilS {
        @Autowired
        private MinioClient minioClient;
    
        @Value("${minio.bucketName}")
        private String bucketName;
        /**
         * description: 判断bucket是否存在,不存在则创建
         *
         * @return: void
         */
        public void existBucket(String name) {
            try {
                boolean exists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(name).build());
                if (!exists) {
                    minioClient.makeBucket(MakeBucketArgs.builder().bucket(name).build());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 创建存储bucket
         * @param bucketName 存储bucket名称
         * @return Boolean
         */
        public Boolean makeBucket(String bucketName) {
            try {
                minioClient.makeBucket(MakeBucketArgs.builder()
                        .bucket(bucketName)
                        .build());
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
            return true;
        }
    
        /**
         * 删除存储bucket
         * @param bucketName 存储bucket名称
         * @return Boolean
         */
        public Boolean removeBucket(String bucketName) {
            try {
                minioClient.removeBucket(RemoveBucketArgs.builder()
                        .bucket(bucketName)
                        .build());
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
            return true;
        }
    
    
    
    
        /**
         * description: 上传文件
         *
         * @param multipartFile
         * @return: java.lang.String
    
         */
        public List<String> upload(MultipartFile[] multipartFile) {
            List<String> names = new ArrayList<>(multipartFile.length);
            for (MultipartFile file : multipartFile) {
    
                String fileName = file.getOriginalFilename();
                String[] split = fileName.split("\\.");
                if (split.length > 1) {
                    fileName = split[0] + "_" + System.currentTimeMillis() + "." + split[1];
                } else {
                    fileName = fileName + System.currentTimeMillis();
                }
                InputStream in = null;
                try {
                    in = file.getInputStream();
                    minioClient.putObject(PutObjectArgs.builder()
                            .bucket(bucketName)
                            .object(fileName)
                            .stream(in, in.available(), -1)
                            .contentType(file.getContentType())
                            .build()
                    );
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    if (in != null) {
                        try {
                            in.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
                names.add(fileName);
            }
            return names;
        }
    
        /**
         * description: 下载文件
         *
         * @param fileName
         * @return: org.springframework.http.ResponseEntity<byte [ ]>
         */
        public ResponseEntity<byte[]> download(String fileName) {
            ResponseEntity<byte[]> responseEntity = null;
            InputStream in = null;
            ByteArrayOutputStream out = null;
            try {
                in = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileName).build());
                out = new ByteArrayOutputStream();
                IOUtils.copy(in, out);
                //封装返回值
                byte[] bytes = out.toByteArray();
                HttpHeaders headers = new HttpHeaders();
                try {
                    headers.add("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                headers.setContentLength(bytes.length);
                headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
                headers.setAccessControlExposeHeaders(Arrays.asList("*"));
                responseEntity = new ResponseEntity<byte[]>(bytes, headers, HttpStatus.OK);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if (in != null) {
                        try {
                            in.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    if (out != null) {
                        out.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return responseEntity;
        }
    
        /**
         * 查看文件对象
         * @param bucketName 存储bucket名称
         * @return 存储bucket内文件对象信息
         */
        public List<ObjectItem> listObjects(String bucketName) {
            Iterable<Result<Item>> results = minioClient.listObjects(
                    ListObjectsArgs.builder().bucket(bucketName).build());
            List<ObjectItem> objectItems = new ArrayList<>();
            try {
                for (Result<Item> result : results) {
                    Item item = result.get();
                    ObjectItem objectItem = new ObjectItem();
                    objectItem.setObjectName(item.objectName());
                    objectItem.setSize(item.size());
                    objectItems.add(objectItem);
                    System.out.println("---item文件的"+item.toString());
                }
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
            return objectItems;
        }
    
        /**
         * 批量删除文件对象
         * @param bucketName 存储bucket名称
         * @param objects 对象名称集合
         */
        public Iterable<Result<DeleteError>> removeObjects(String bucketName, List<String> objects) {
            List<DeleteObject> dos = objects.stream().map(e -> new DeleteObject(e)).collect(Collectors.toList());
            Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(dos).build());
            return results;
        }
    
    
    }
    
    
    @Data
    public class ObjectItem {
        private String objectName;
        private Long size;
    }

    更多相关内容
  • SpringBoot整合Minio

    万次阅读 2022-08-22 21:35:57
    application.yml 配置minio连接信息。

    pom.xml 导入 minio依赖,如下:

    <dependency>
        <groupId>io.minio</groupId>
        <artifactId>minio</artifactId>
        <version>8.0.3</version>
    </dependency>
    

    application.yml 配置minio连接信息

    minio:
      endpoint: http://192.168.1.11:9000
      username: admin
      password: admin
      bucketName: test
    

    Minio 配置类

    import io.minio.MinioClient;
    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * Minio 配置
     *
     * @author terry
     * @version 1.0
     * @date 2022/8/21 21:01
     */
    @Configuration
    @EnableConfigurationProperties(MinioConfig.MinioProperties.class)
    public class MinioConfig {
    
        @ConfigurationProperties(prefix = "minio")
        @Data
        public static class MinioProperties{
    
            private String endpoint;
    
            private String userName;
    
            private String password;
    
            private String bucketName;
        }
    
        @Bean
        public MinioClient minioClient(MinioProperties minio) {
            return MinioClient.builder()
                .endpoint(minio.getEndpoint())
                .credentials(minio.getUserName(), minio.getPassword())
                .build();
        }
    }
    

    Minio操作类

    import com.terry.config.MinioConfig;
    import io.minio.*;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.io.InputStream;
    import java.util.UUID;
    
    /**
     * minio 操作类
     *
     * @author terry
     * @version 1.0
     * @date 2022/8/22 21:18
     */
    @Service
    @Slf4j
    public class MinioService {
        @Autowired
        private MinioClient client;
    
        @Autowired
        private MinioConfig.MinioProperties minioProperties;
    
        public void upload(InputStream inputStream, String name) {
            String bucketName = minioProperties.getBucketName();
            String endpoint = minioProperties.getEndpoint();
            try {
                // 判断存储桶是否存在  不存在则创建
                createBucket(bucketName);
                // 新的文件名
                String fileName = UUID.randomUUID().toString() + name.substring(name.lastIndexOf("."));
                // 开始上传
                client.putObject(PutObjectArgs.builder().bucket(bucketName)
                        .object(fileName).stream(inputStream, inputStream.available(), -1).build());
                String url = bucketName + "/" + fileName;
                log.info(" 相对路径: " + url);
                log.info(" 完整路径: " + endpoint  + "/" + url);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
    
        public void createBucket(String bucketName) {
            try {
                if (!client.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
                    client.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
                    StringBuilder builder = new StringBuilder();
                    builder.append("{\n");
                    builder.append("    \"Statement\": [\n");
                    builder.append("        {\n");
                    builder.append("            \"Action\": [\n");
                    builder.append("                \"s3:GetBucketLocation\",\n");
                    builder.append("                \"s3:ListBucket\"\n");
                    builder.append("            ],\n");
                    builder.append("            \"Effect\": \"Allow\",\n");
                    builder.append("            \"Principal\": \"*\",\n");
                    builder.append("            \"Resource\": \"arn:aws:s3:::%s\"\n");
                    builder.append("        },\n");
                    builder.append("        {\n");
                    builder.append("            \"Action\": \"s3:GetObject\",\n");
                    builder.append("            \"Effect\": \"Allow\",\n");
                    builder.append("            \"Principal\": \"*\",\n");
                    builder.append("            \"Resource\": \"arn:aws:s3:::%s/*\"\n");
                    builder.append("        }\n");
                    builder.append("    ],\n");
                    builder.append("    \"Version\": \"2012-10-17\"\n");
                    builder.append("}\n");
                    String config = String.format(builder.toString(), bucketName, bucketName);
                    try {
                        client.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(config).build());
                    } catch (Exception e) {
                        log.info("[minio] 设置桶:{}策略失败", bucketName, e);
                        e.printStackTrace();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    

    测试 Minio

    import com.terry.service.MinioService;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    
    /**
     * 测试 Minio
     *
     * @author terry
     * @version 1.0
     * @date 2022/8/16 22:19
     */
    @SpringBootTest
    public class MinioTest {
    
        @Autowired
        private MinioService minioService;
    
        @Test
        public void test() throws FileNotFoundException {
            minioService.upload(new FileInputStream("D:\\test.txt"), "test.txt");
        }
    }
    
    展开全文
  • Springboot整合minio

    千次阅读 2022-04-26 00:52:27
    第一步:查找 minio 最新依赖,通过 maven 查询网站查询, 这搜索框输入 minio, 也可以查看 MinIO 官网 https://docs.min.io/docs/java-client-quickstart-guide.html如下:点击 minio 进入查看 maven 依赖,可以看到...

    第一步:查找 minio 最新依赖,通过 maven 查询网站查询, 这搜索框输入 minio, 也可以查看 MinIO 官网 https://docs.min.io/docs/java-client-quickstart-guide.html如下:

    33aa28be1761487e062b87213979524a.png

    点击 minio 进入查看 maven 依赖,可以看到最新版为 8.3.4

    <dependency>
        <groupId>io.minio</groupId>
        <artifactId>minio</artifactId>
        <version>8.3.4</version>
    </dependency>

    第二步:(整合到项目中)

    1. 将依赖添加到新建的 springboot 项目中, 在 pom.xml 添加 2. 配置 minio 客户端, 不会的话参考 minio java sdk 文档, 但是这个文档给的是 3.0.10 版本的 sdk,与新版的不兼容,最新版的还是看 github 地址

    参数说明
    Endpoint对象存储服务的 URL
    Access KeyAccess key 就像用户 ID,可以唯一标识你的账户
    Secret KeySecret key 是你账户的密码

    默认安装不指定 Access key 和 Secret key 的话都是 minioadmin, Endpoint 则为服务器地址:如我安装的的端口为 1024,那 Endpoint 就是: http://localhost:1024] 为了方便我们通过 bean 的方式注入客户端如下:

    yml

    spring:
      # 配置文件上传大小限制
      servlet:
        multipart:
          max-file-size: 100MB
          max-request-size: 100MB
    
    # minio 参数配置
    minio:
      endpoint: http://localhost:1024
      accessKey: minioadmin
      secretKey: minioadmin
    @Configuration
    public class MinIoClientConfig {
    
        @Value("${minio.endpoint}")
        private String endpoint;
        @Value("${minio.accessKey}")
        private String accessKey;
        @Value("${minio.secretKey}")
        private String secretKey;
    
        /**
         * 注入minio 客户端
         * @return
         */
        @Bean
        public MinioClient minioClient(){
    
        return MinioClient.builder()
                            .endpoint(endpoint)
                            .credentials(accessKey, secretKey)
                            .build();
        }
    }

    ok, 现在客户端已注入 spring 容器中,在使用的时候,只需要获取就可以了。

    第三步: 文件上传 1. 新增一个 UploadController 控制器用于处理文件上传,如下:

    @RestController
    public class UploadController {
    
        @Resource
        private MinioClient minioClient;
    
        /**
         * 文件上传
         * @param file
         * @return
         */
        @PostMapping("/upload")
        public String upload(MultipartFile file){
    
            try {
                PutObjectArgs objectArgs = PutObjectArgs.builder().object(file.getOriginalFilename())
                        .bucket("test")
                        .contentType(file.getContentType())
                        .stream(file.getInputStream(),file.getSize(),-1).build();
    
                minioClient.putObject(objectArgs);
                return "ok";
            } catch (Exception e) {
                e.printStackTrace();
                return e.getMessage();
            }
        }
    }

    注意这里的 bucket 是我提前在 minio 中新增好的,如果没有的话,可以自己手动添加,也可以通过代码添加, 具体参考 sdk 的说明, 这里就不多说了。

    2. 通过 postman 测试文件上传(没有 postman 的可以看我之前的博客,有相关介绍)

    358dd0b1913f34953c7c08c1971af735.png

    点击执行后返回 ok, 执成功, 此时通过 minio web 端看看文件是否上传成功

    81ae8805305e715b86c454dcb71e3883.png

    看到刚上传的文件就说明成功了。3. 其他说明, 如何通过浏览器访问刚上传的图片呢,就是通过 endpoint 服务地址加 bucket 名称加图片的名称,在本例子访问路径则为:5b01ca40273bcf53f4e6d84c0c595642.gif

    第四步: 文件下载

    在 UploadController 控制其中新增 download 方法, 如下:

    /**
         * 下载文件
         * @param filename
         */
        @GetMapping("/download/{filename}")
        public void download(@PathVariable String filename, HttpServletResponse res){
    
            GetObjectArgs objectArgs = GetObjectArgs.builder().bucket("test")
                    .object(filename).build();
    
            try (GetObjectResponse response = minioClient.getObject(objectArgs)){
                byte[] buf = new byte[1024];
    
                int len;
    
                try (FastByteArrayOutputStream os = new FastByteArrayOutputStream()){
    
                    while ((len=response.read(buf))!=-1){
    
                        os.write(buf,0,len);
    
                    }
                    os.flush();
    
                    byte[] bytes = os.toByteArray();
    
                    res.setCharacterEncoding("utf-8");
                    res.setContentType("application/force-download");// 设置强制下载不打开
                    res.addHeader("Content-Disposition", "attachment;fileName=" + filename);
                    try ( ServletOutputStream stream = res.getOutputStream()){
                        stream.write(bytes);
                        stream.flush();
                    }
                }
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    通过访问下载地址:http://localhost:8421/download/5b01ca40273bcf53f4e6d84c0c595642.gif, 文件下载下来能够正常显示,则说明成功。

    总结: 通过以上操作,我们已经完成 springboot 与 minio 的整合,可以通过 minio sdk 实现文件上传与下载功能。当然还有其他 api 操作,我就不多介绍了,都是一个思路,调用传值就可以了,自己尝试一下,就能 get 到了。


    作者:Archie_java

    来源链接:

    https://blog.csdn.net/qq_43842093/article/details/121873566

    783f9a29ed53c647025d9a56d4b7fae7.png

    展开全文
  • Springboot整合 Minio

    2022-05-21 10:42:22
    文章目录前言下载 [官网地址](https://min.io/)依赖配置类(application.yml)MinioConfigMinIoPropertiesMinioUtils使用(MinIoController) 前言 对象存储服务OSS(Object Storage Service...运行 .\minio.exe server

    前言

    对象存储服务OSS(Object Storage Service)是一种海量、安全、低成本、高可靠的云存储服务,适合存放任意类型的文件。容量和处理能力弹性扩展,多种存储类型供选择,全面优化存储成本。

    下载 官网地址

    下载完成后,启动minio
    运行 .\minio.exe server E:\MinIOPic E:\MinIOPic:上传地址
    在这里插入图片描述

    依赖

    
     <!-- minio文件分布式 -->
      <dependency>
          <groupId>io.minio</groupId>
          <artifactId>minio</artifactId>
          <version>8.3.7</version>
      </dependency>
    
    

    配置类(application.yml)

    
    minio:
      bucketName: file # minio 桶名称
      url: http://127.0.0.1:9000 # minio 服务地址
      accesskey: minioadmin # minio Access key就像用户ID,可以唯一标识你的账户
      secretKey: minioadmin # minio Secret key是你账户的密码
    
    

    MinioConfig

    
    @Configuration
    public class MinioConfig {
        @Autowired
        private MinIoProperties minioProperties;
        @Bean
        public MinioClient minioClient(){
            MinioClient minioClient =
                    MinioClient.builder()
                            .endpoint(minioProperties.getUrl())
                            .credentials(minioProperties.getAccessKey(),
                                    minioProperties.getSecretKey())
                            .build();
            return minioClient;
        }
    }
    
    

    MinIoProperties

    @Data
    @Component
    @ConfigurationProperties(prefix = "minio")
    public class MinIoProperties {
        /**
         * minio地址+端口号
         */
        private String url;
    
        /**
         * minio用户名
         */
        private String accessKey;
    
        /**
         * minio密码
         */
        private String secretKey;
    
        /**
         * 文件桶的名称
         */
        private String bucketName;
    
    
    } 
    

    MinioUtils

    
    @Component
    @Slf4j
    public class MinioUtils {
        @Autowired
        private MinioClient minioClient;
    
        /**
         * TODO 创建存储桶
         *
         * @param bucketName 存储桶名称
         * @return
         */
        public String makeBucket(String bucketName) throws Exception {
            //判断 存储桶存不存在
            boolean bucketExists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            if (bucketExists) {
                log.info("Minio 桶已经存在了:{}", bucketName);
            } else {
                //创建桶
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
                log.info("Minio 桶创建成功:{}", bucketName);
            }
            return bucketName;
        }
    
        /**
         * TODO 查询全部存储桶信息
         *
         * @return
         * @throws Exception
         */
        public List<Bucket> listBuckets() throws Exception {
            List<Bucket> listBuckets = minioClient.listBuckets();
            log.info("全部存储桶信息:{}", listBuckets);
            return listBuckets;
        }
    
        /**
         * TODO 查询单个储桶中的所有对象。
         *
         * @param bucketName 存储桶名称
         * @throws Exception
         */
        public List<Object> listObjects(String bucketName) throws Exception {
            Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName).build());
            Iterator<Result<Item>> iterator = results.iterator();
            List<Object> items = new ArrayList<>();
            String format = "{'fileName':'%s','fileSize':'%s'}";
            while (iterator.hasNext()) {
                Item item = iterator.next().get();
                items.add(JSON.parse(String.format(format, item.objectName(),
                        formatFileSize(item.size()))));
            }
            log.info("查询单个储桶中的所有对象信息:{}", items);
            return items;
        }
    
        /**
         * TODO 删除一个存储桶
         *
         * @param bucketName 存储桶名称
         * @throws Exception
         */
        public void removeBucket(String bucketName) throws Exception {
            minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
            log.info("删除一个存储桶成功");
        }
    
        /**
         * TODO 获取对象的元数据
         * @param bucketName 存储桶名称。
         * @param objectName 存储桶里的对象名称
         * @return
         * @throws Exception
         */
        public StatObjectResponse statObject(String bucketName,String objectName) throws Exception {
            StatObjectResponse statObjectResponse = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
            return statObjectResponse;
        }
    
        /**
         * TODO 上传文件
         * @param file 文件
         * @param bucketName 存储桶名称
         */
        public List<String>  putObject(MultipartFile[] file,String bucketName){
            List<String> path =new ArrayList<>();
            for (MultipartFile multipartFile : file) {
                //获取文件名
                String orgfileName = multipartFile.getOriginalFilename();
                path.add(bucketName+"/"+orgfileName);
                try {
                    //文件上传
                    InputStream in = multipartFile.getInputStream();
                    minioClient.putObject(
                            PutObjectArgs.builder().bucket(bucketName).object(orgfileName).stream(
                                    in, multipartFile.getSize(), -1)
                                    .contentType(multipartFile.getContentType())
                                    .build());
                    in.close();
                } catch (Exception e) {
                    log.error(e.getMessage());
                }
            }
            return path;
        }
    
        /**
         * TODO 将对象的数据下载到文件中
         * @param bucketName 存储桶名称
         * @param objectName 文件名称
         * @param fileName   文件名称
         * @throws Exception
         */
        public void downloadObject(String bucketName, String objectName, String fileName)throws Exception {
            log.info("bucketName = {}",bucketName);
            log.info("objectName = {}",objectName);
            log.info("fileName = {}",fileName);
            minioClient.downloadObject(DownloadObjectArgs.builder().bucket(bucketName).object(objectName).filename(fileName).build());
        }
    
    
        /**
         * TODO 删除文件
         * @param bucketName 存储桶名称
         * @param objectName 文件名称
         * @throws Exception
         */
        public void  removeObject(String bucketName, String objectName)throws Exception {
            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
        }
        /**
         * TODO 生成一个给HTTP GET请求用的presigned URL。
         *      浏览器/移动端的客户端可以用这个URL进行下载,
         *      即使其所在的存储桶是私有的。
         *      这个presigned URL可以设置一个失效时间,默认值是7天
         *
         * @param bucketName 存储桶名称
         * @param objectName 文件名称
         * @param expiry     失效时间(单位小时)
         * @return
         */
        public String getPresignedObjectUrl(String bucketName, String objectName, Integer expiry)throws Exception {
            log.info("bucketName = {}",bucketName);
            log.info("objectName = {}",objectName);
            log.info("expiry = {}",expiry);
            String presignedObjectUrl = minioClient.getPresignedObjectUrl(
                    GetPresignedObjectUrlArgs
                            .builder()
                            .method(Method.GET)
                            .bucket(bucketName)
                            .object(objectName)
                            .expiry(expiry, TimeUnit.HOURS)
                            .build());
            log.info("生成http 下载信息:{}",presignedObjectUrl);
            return presignedObjectUrl;
        }
    
    
        public static String formatFileSize(long fileS) {
            DecimalFormat df = new DecimalFormat("#.00");
            String fileSizeString = "";
            String wrongSize = "0B";
            if (fileS == 0) {
                return wrongSize;
            }
            if (fileS < 1024) {
                fileSizeString = df.format((double) fileS) + " B";
            } else if (fileS < 1048576) {
                fileSizeString = df.format((double) fileS / 1024) + " KB";
            } else if (fileS < 1073741824) {
                fileSizeString = df.format((double) fileS / 1048576) + " MB";
            } else {
                fileSizeString = df.format((double) fileS / 1073741824) + " GB";
            }
            return fileSizeString;
        }
    
    }
     
    

    使用(MinIoController)

    @RestController
    @RequestMapping("/api/minio")
    @Slf4j
    public class MinIoController {
    
        @Autowired
        private MinioClient minioClient;
        @Autowired
        private MinioUtils minioUtils;
    
        @Value("${minio.bucketName}")
        private String bucketName;
    
        @GetMapping("/getPresignedObjectUrl")
        public String getPresignedObjectUrl() throws Exception{
             minioUtils.downloadObject(bucketName, "233.mp4", "0116.mp4");
            return "ok";
        }
    
        @GetMapping("/list")
        public List<Object> list() throws Exception {
            //获取bucket列表
            Iterable<Result<Item>> myObjects = minioClient.listObjects(
                    ListObjectsArgs.builder().bucket(bucketName).build());
            Iterator<Result<Item>> iterator = myObjects.iterator();
            List<Object> items = new ArrayList<>();
            String format = "{'fileName':'%s','fileSize':'%s'}";
            while (iterator.hasNext()) {
                Item item = iterator.next().get();
                items.add(JSON.parse(String.format(format, item.objectName(),
                        minioUtils.formatFileSize(item.size()))));
            }
            return items;
        }
    
        @PostMapping("/upload")
        public ServerResponse upload(@RequestParam(name = "file", required = false)
                                             MultipartFile[] file) {
            if (file == null || file.length == 0) {
                return ServerResponse.createByErrorMessage("上传文件不能为空");
            }
            List<String> stringList = minioUtils.putObject(file, bucketName);
            Map<String, Object> data = new HashMap<String, Object>();
            data.put("bucketName", bucketName);
            data.put("fileName", stringList);
            return ServerResponse.createBySuccess("上传成功", data);
        }
    
        @RequestMapping("/download/{fileName}")
        public void download(HttpServletResponse response, @PathVariable("fileName")
                String fileName) {
            InputStream in = null;
            try {
    // 获取对象信息
                StatObjectResponse stat = minioClient.statObject(
                        StatObjectArgs.builder().bucket(bucketName).object(fileName).build());
                response.setContentType(stat.contentType());
                response.setHeader("Content-Disposition", "attachment;filename=" +
                        URLEncoder.encode(fileName, "UTF-8"));
    //文件下载
                in = minioClient.getObject(
                        GetObjectArgs.builder()
                                .bucket(bucketName)
                                .object(fileName)
                                .build());
                IOUtils.copy(in, response.getOutputStream());
            } catch (Exception e) {
                log.error(e.getMessage());
            } finally {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        log.error(e.getMessage());
                    }
                }
            }
        }
    
        @DeleteMapping("/delete/{fileName}")
        public ServerResponse delete(@PathVariable("fileName") String fileName) {
            try {
                minioClient.removeObject(
                        RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build());
            } catch (Exception e) {
                log.error(e.getMessage());
                return ServerResponse.createByErrorMessage("删除失败");
            }
            return ServerResponse.createBySuccess("删除成功", null);
        }
    
    
    }
    
    展开全文
  • springboot整合minio上传文件
  • 在java web编程中,目前微服务体系的框架越来越流行了,随着服务的拆分,可能我们的项目...对于独立的文件微服务,我们可以根据项目的需求,使用策略模式,整合多个文件服务器,例如:阿里云Oss、fastdfs、minio等。...
  • spirngboot整合minio实现文件上传,下载,批量下载,预览,删除等功能。
  • SpringBoot 整合MinIO并实现文件上传 1、依赖 <!-- https://mvnrepository.com/artifact/io.minio/minio --> <dependency> <groupId>io.minio</groupId> <artifactId>minio</...
  • 公司的开发框架集成了附件本地存储,阿里云,华为云等,现项目有要求附件存储与应用部署环境不能是同一台服务器,也不能使用云存储,经过技术选型后决定框架整合minio,将minio部署在另一台服务器开通外网端口即可...
  • 文章介绍了 SpringBoot 整合 MinIO 的全过程,并附上源码。分布式文件系统有多了一种选择
  • springboot整合minio实现文件上传下载
  • Springboot整合Minio文件上传下载

    千次阅读 2022-04-21 19:25:43
    linux安装minio 创建一个文件minio mkdir minio cd minio --进入到文件 执行下载命令 wget https://dl.minio.io/server/minio/release/linux-amd64/minio 创建一个日志文件 ,方便查看日志 touch minio.log 点击...
  • 对象存储服务OSS(ObjectStorageService)是一种海量、安全、低成本、高可靠的云存储服务,适合存放任意类型的文件。容量和处理能力弹性扩展,多种存储类型供选择,全面优化存储成本。
  • springboot配置文件application.yml 里配置minio信息 创建MinioItem字段项目类 创建MinioTemplate模板类 创建 FilesMinioService 服务类 部分操作数据库的相关代码省略,不再展示创建FilesMinioController ...
  • springboot整合minio最新版

    千次阅读 2021-12-11 14:55:49
    第一步:查找minio最新依赖,通过maven查询网站查询,这搜索框输入minio, 也可以查看MinIO官网https://docs.min.io/docs/java-client-quickstart-guide.html 如下: 点击minio进入查看maven依赖,可以看到最新版为...
  • 第一步导包 io.minio minio 8.2.0 第二步:配置文件 minio: endpointUrl: http://192.168.110.136:9000 accessKey: admin secreKey: admin123456 bucketName: gmall 第三步: 代码 package ...
  • MinIO** **是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口,非 常适合于存储大容量非结构化的数据,例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等,而 一个对象...
  • 如果SpringBoot搭建还有问题,可以参考我的文章:https://blog.csdn.net/m0_51510236/article/details/113967278 minio官方网站:https://min.io/ 程序包可以官网下载,本次演示的版本下载:...
  • SpringBoot: Minio:okhttp3.Headers$Builder.addUnsafeNonAscii 原因:Boot 版本问题。 怀疑MinIO版本问题,尝试更换 MinIO 版本,8.2.0 ,8.2.1以及其他版本 ,均无法解决。 更换Boot版本至2.4.5后问题解决...
  • -- minio依赖 --> <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <version>8.2.1</version> </dependency> application....
  • SpringBoot整合MinIO

    2021-12-11 00:09:41
    我们先来看下MinIO的官网简介 官网地址https://docs.min.io/ MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口,非常适合于存储大容量非结构化的数据,例如图片、视频、...
  • 1、minio部署 1.1 拉取镜像 docker pull minio/minio 1.2 创建数据目录 mkdir -p /home/guanz/minio mkdir -p /home/guanz/minio/midata 1.3 启动minio docker run -d -p 9000:9000 -p 9001:9001 --restart=always...
  • 然后开始学习MinIO相关知识,各种查看中英文版文档,现在最新的中文文档版本还是MinIO7的,所以查看了官网的英文版文档: [https://docs.min.io/docs] 梳理下过程,将基础功能整理如下: 1. MinIO安装(docker单机)...
  • SpringBoot整合minio

    2021-04-27 17:13:32
    io.minio</groupId> <artifactId>minio</artifactId> <version>7.0.2</version> </dependency> 配置文件配置minio服务 minio.endpoint=https://***.***.*** m
  • SpringBoot整合MinIO实现文件上传的方法详解
  • SpringBoot整合Minio实现上传文件。
  • 注:服务安装这里有个坑,服务器是x86_64的,按照官网的一直说不支持二进制文件( -bash: ./minio: cannot execute binary file )后面从中国镜像站下载的LINUX-386版本的完美运行...O=A目前团队所有项目都是采用微服务...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 710
精华内容 284
关键字:

springboot整合minio

spring 订阅