二.minio整合springboot、文件上传下载、增删改查bucket和object

最新推荐文章于 2024-08-23 08:05:48 发布
最新推荐文章于 2024-08-23 08:05:48 发布
阅读量2.8k 收藏 15
点赞数 2
分类专栏： springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xixiyuguang/article/details/119447614
版权

minio

目录

1.效果展示

1.1windows中minio运行

 1.2minio管理页面

 1.3制作图片服务

2.springboot项目创建

pom

properties

util

config

 domain

 dao

controller

gitee：https://gitee.com/pythonloser/springboot-minio/tree/master

一.minio安装与使用：https://blog.csdn.net/xixiyuguang/article/details/119344480

二.minio整合springboot、文件上传下载、增删改查bucket和object：https://blog.csdn.net/xixiyuguang/article/details/119447614

三.minio 的分布式部署、单节点多磁盘、多节点模式：https://blog.csdn.net/xixiyuguang/article/details/119456729

1.效果展示

1.1windows中minio运行

 1.2minio管理页面

 1.3制作图片服务

2.springboot项目创建

pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.yg</groupId>
    <artifactId>minio</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>18-springboot-minio</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.18</version>
        </dependency>


        <!-- minio -->
        <!-- minio 相关依赖 -->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <!--<version>3.0.10</version>-->
            <version>8.0.3</version>
        </dependency>
        <!-- alibaba的fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.51</version>
        </dependency>
        <!-- thymeleaf模板引擎 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

        <!---->
        <dependency>
            <groupId>asm</groupId>
            <artifactId>asm</artifactId>
            <version>3.3.1</version>
        </dependency>

        <dependency>
            <groupId>org.json</groupId>
            <artifactId>json</artifactId>
            <version>20140107</version>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

properties



# minio 文件存储配置信息
minio.endpoint=http://127.0.0.1:9090
minio.accesskey=admin
minio.secretKey=12345678

spring.thymeleaf.mode=HTML
spring.thymeleaf.prefix=classpath:/templates/


spring.servlet.multipart.max-request-size=500MB
spring.servlet.multipart.max-file-size=500MB

util

package com.yg.minio;

import com.alibaba.fastjson.JSONObject;
import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.InputStream;
import java.util.List;
import java.util.Optional;

@Slf4j
@Component
public class MinioUtils {

    /**
     * 默认块大小
     * 上传的时候必须设置分块大小。对象大小直接-1，分块大小[5m,5G]，参数的单位是B，
     * 所以最小单位是：5 * 1024 * 1024 = 5242880。minio支持分块传输
     */
    private final long defaultPartSize = 5242880;

    @Autowired
    private MinioClient minioClient;

    @Autowired
    private MinioProp minioProp;

    /**
     * 创建bucket
     *
     * @param bucketName bucket名称
     */
    @SneakyThrows
    public void createBucket(String bucketName) {
        if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        }
    }

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

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

    /**
     * 根据bucketName删除信息
     *
     * @param bucketName bucket名称
     */
    @SneakyThrows
    public void removeBucket(String bucketName) {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /**
     * 获取文件外链
     *
     * @param bucketName bucket名称
     * @param objectName 文件名称
     * @param expires    (单位秒) 过期时间 <=7
     * @return url
     */
    @SneakyThrows
    public String getObjectURL(String bucketName, String objectName, Integer expires) {
        return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                .expiry(expires)
                .method(Method.GET)
                .build());
    }

    /**
     * 获取文件
     *
     * @param bucketName bucket名称
     * @param objectName 文件名称
     * @return 二进制流
     */
    @SneakyThrows
    public InputStream getObject(String bucketName, String objectName) {
        return minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(objectName).build());
    }

    /**
     * 上传文件
     *
     * @param bucketName bucket名称
     * @param objectName 文件名称
     * @param stream     文件流
     * @throws Exception https://docs.minio.io/cn/java-client-api-reference.html#putObject
     */
    public void putObject(String bucketName, String objectName, InputStream stream) throws Exception {
        minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(stream, -1, defaultPartSize).build());
    }

    /**
     * @param bucketName bucket名称
     * @param objectName 文件名称
     * @param fileName   上传文件路径
     * @throws Exception
     */
    public void putObject(String bucketName, String objectName, String fileName) throws Exception {
        minioClient.uploadObject(UploadObjectArgs.builder().bucket(bucketName).object(objectName).filename(fileName).build());
    }

    /**
     * 上传文件
     *
     * @param bucketName  bucket名称
     * @param objectName  文件名称
     * @param stream      文件流
     * @param size        大小
     * @param contextType 类型
     * @throws Exception https://docs.minio.io/cn/java-minioClient-api-reference.html#putObject
     */
    public void putObject(String bucketName, String objectName, InputStream stream, long size, String contextType) throws Exception {
        minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(stream, size, defaultPartSize).contentType(contextType).build());
    }

    /**
     * 获取文件信息
     *
     * @param bucketName bucket名称
     * @param objectName 文件名称
     * @throws Exception https://docs.minio.io/cn/java-client-api-reference.html#statObject
     */
    public StatObjectResponse getObjectInfo(String bucketName, String objectName) throws Exception {
        return minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
    }

    /**
     * 删除文件
     *
     * @param bucketName bucket名称
     * @param objectName 文件名称
     * @throws Exception https://docs.minio.io/cn/java-client-api-reference.html#removeObject
     */
    public void removeObject(String bucketName, String objectName) throws Exception {
        minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
    }

    /**
     * 上传文件
     *
     * @param file       文件
     * @param bucketName 存储桶
     * @return
     */
    public JSONObject uploadFile(MultipartFile file, String bucketName) throws Exception {
        JSONObject res = new JSONObject();
        res.put("code", 0);
        // 判断上传文件是否为空
        if (null == file || 0 == file.getSize()) {
            res.put("msg", "上传文件不能为空");
            return res;
        }
        // 判断存储桶是否存在
        createBucket(bucketName);
        // 文件名
        String originalFilename = file.getOriginalFilename();
        // 新的文件名
        String fileName = bucketName + "_" + System.currentTimeMillis() + originalFilename.substring(originalFilename.lastIndexOf("."));
        // 开始上传
        minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(fileName).stream(file.getInputStream(), -1, defaultPartSize).contentType(file.getContentType()).build());
        res.put("code", 1);
        res.put("msg", minioProp.getEndpoint() + "/" + bucketName + "/" + fileName);
        return res;
    }

    /**
     * 查询policy
     * @param bucketName
     * @return
     * @throws Exception
     */
    public String getBucketPolicy(String bucketName) throws Exception {
        return minioClient.getBucketPolicy(GetBucketPolicyArgs.builder().bucket(bucketName).build());
    }

    /**
     * 设置policy
     * @param bucketName
     * @return
     * @throws Exception
     */
    public void setBucketPolicy(String bucketName) throws Exception {
        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:::my-bucketname\"\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:::my-bucketname/myobject*\"\n");
        builder.append("        }\n");
        builder.append("    ],\n");
        builder.append("    \"Version\": \"2012-10-17\"\n");
        builder.append("}\n");
        minioClient.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(bucketName).config(builder.toString()).build());
    }
}

config

package com.yg.minio;

import io.minio.MinioClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * minio 核心配置类
 */
@Configuration
@EnableConfigurationProperties(MinioProp.class)
public class MinioConfig {

    @Autowired
    private MinioProp minioProp;

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


package com.yg.minio;

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

/**
 * minio 属性值
 */
@Data
@Component
@ConfigurationProperties(prefix = "minio")
public class MinioProp {
    /**
     * 连接url
     */
    private String endpoint;
    /**
     * 用户名
     */
    private String accesskey;
    /**
     * 密码
     */
    private String secretKey;
}

 domain

@XmlRootElement(name = "Album")
public class Album {
    private String url;
    private String description;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

 dao

package com.yg.minio.photo;

import io.minio.GetPresignedObjectUrlArgs;
import io.minio.ListObjectsArgs;
import io.minio.MinioClient;
import io.minio.Result;
import io.minio.http.Method;
import io.minio.messages.Item;

import java.util.ArrayList;
import java.util.List;

public class AlbumDao {

    public List<Album> listAlbums() throws Exception {

        List<Album> list = new ArrayList<Album>();
        final String bucket = "album";

        // Initialize minio client object.
        MinioClient minioClient =
                MinioClient.builder()
                        .endpoint("http://127.0.0.1:9090")
                        .credentials("admin", "12345678")
                        .build();
        String url;
        // List all objects.
        Iterable<Result<Item>> myObjects = minioClient.listObjects(ListObjectsArgs.builder().bucket(bucket).build());

        // Iterate over each elements and set album url.
        for (Result<Item> result : myObjects) {
            Item item = result.get();
            System.out.println(item.lastModified() + ", " + item.size() + ", " + item.objectName());

            // Generate a presigned URL which expires in a day
            url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder().bucket(bucket)
                    .object(item.objectName()).method(Method.GET).expiry(60 * 60 * 24).build());

            Album album = new Album();
            album.setUrl(url);
            album.setDescription(item.objectName());
            list.add(album);
        }

        // Return list of albums.
        return list;
    }
}

controller

package com.yg.minio;

import com.yg.minio.photo.Album;
import com.yg.minio.photo.AlbumDao;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import java.util.List;

@Controller
public class ThymeleafController {

    //http://localhost:8080/test
    @RequestMapping("/test")
    public String index(Model model, HttpServletRequest httpServletRequest) {
        return "test";
    }


    //http://localhost:8080/photo
    @RequestMapping("/photo")
    public String photo(Model model, HttpServletRequest httpServletRequest) {

        try {
            AlbumDao albumDao = new AlbumDao();
            List<Album> albums = albumDao.listAlbums();
            model.addAttribute("albums", albums);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "photo";
    }

}


package com.yg.minio;

import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.InputStreamResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URLEncoder;

@Controller
public class MinioController {

    @Autowired
    private MinioUtils minioUtils;


    /**
     * 上传
     *
     * @param file
     * @param request
     * @return
     */
    @PostMapping("/upload")
    @ResponseBody
    public String upload(@RequestParam(name = "file", required = false) MultipartFile file, HttpServletRequest request) {
        JSONObject res = null;
        try {
            res = minioUtils.uploadFile(file, "product");
        } catch (Exception e) {
            e.printStackTrace();
            res.put("code", 0);
            res.put("msg", "上传失败");
        }
        return res.toJSONString();
    }

    /**
     * 下载
     */
    @GetMapping("/download")
    @ResponseBody
    public void download(HttpServletResponse httpResponse) {
        try {

            InputStream product = minioUtils.getObject("product", "product_1628144206698.JPG");

            byte buf[] = new byte[1024];
            int length = 0;
            httpResponse.reset();

            httpResponse.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode("中文.JPG", "UTF-8"));
            httpResponse.setContentType("application/octet-stream");
            httpResponse.setCharacterEncoding("utf-8");
            OutputStream outputStream = httpResponse.getOutputStream();
            while ((length = product.read(buf)) > 0) {
                outputStream.write(buf, 0, length);
            }
            outputStream.close();
        } catch (Exception ex) {
            System.out.println(ex.getMessage());
        }
    }

    /**
     * ResponseEntity的方式读取文件,设置只能读取图片
     * http://127.0.0.1:8080/readFile/1
     */
    @GetMapping(value = "/readFile/{fileId}", produces = {"image/jpeg"})
    public ResponseEntity readFile(@PathVariable String fileId) {
        String objectName = "product_1628144206698.JPG";
        InputStream inputStream = minioUtils.getObject("product", objectName);
        try {
            InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
            String fileName = URLEncoder.encode(objectName, "UTF-8");
            //文件类型
            MediaType mediaType = MediaType.parseMediaType("image/jpeg");
            HttpHeaders httpHeaders = new HttpHeaders();
//            httpHeaders.setContentDispositionFormData("attachment", fileName); //如果是下载，需要将这个加上
            httpHeaders.setContentType(mediaType);
            return new ResponseEntity<InputStreamResource>(inputStreamResource, httpHeaders, HttpStatus.OK);
        } catch (Exception e) {
            System.out.println(e.toString());
            return null;
        }
    }


    /***
     *ResponseEntity方式下载
     * @param fileId
     * @param response
     * @return
     * http://127.0.0.1:8080/downloadFile/1
     */
    @GetMapping("/downloadFile/{fileId}")
    public ResponseEntity<byte[]> downloadFile(@PathVariable Long fileId, HttpServletResponse response) {
        try {

            String objectName = "product_1628144206698.JPG";
            InputStream inputStream = minioUtils.getObject("product", objectName);
            String fileName = URLEncoder.encode(objectName, "UTF-8");

            HttpHeaders httpHeaders = new HttpHeaders();
            httpHeaders.setContentDispositionFormData("attachment", fileName);
            httpHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
            ResponseEntity responseEntity = new ResponseEntity<>(readInputStream(inputStream), httpHeaders, HttpStatus.OK);
            return responseEntity;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 输入流装成字节数组
     *
     * @param inStream
     * @return
     * @throws Exception
     */
    public byte[] readInputStream(InputStream inStream) throws Exception {
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len = 0;
        while ((len = inStream.read(buffer)) != -1) {
            outStream.write(buffer, 0, len);
        }
        inStream.close();
        return outStream.toByteArray();
    }
}



@RestController
@RequestMapping("photo")
public class PhotoController {

    AlbumDao albumDao = new AlbumDao();

    /**
     * http://localhost:8080/photo/list
     * @return
     */
    @RequestMapping("/list")
    public List<Album> listAlbums() {
        try {
            return albumDao.listAlbums();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

于光yuguang
关注
专栏目录
Spring Boot 全家桶 SpringBootBucket
xsh_cloudy的博客
05-15 375
https://www.oschina.net/p/springboot-bucket
MinIO文件上传模板
zerowsy的博客
12-15 428
https://min.io/根据官方模板书写
SpringBootBucket 开源项目教程
最新发布
gitblog_00679的博客
08-23 272
SpringBootBucket 开源项目教程 SpringBootBucketSpringboot bucket项目地址:https://gitcode.com/gh_mirrors/sp/SpringBootBucket 1. 项目的目录结构及介绍 SpringBootBucket 项目的目录结构如下： SpringBootBucket/ ├── src/ │ ├── main/ │ ...
MinIO - 从 环境搭建 -＞ SpringBoot实战 -＞ 演示，掌握 Bucket 和 Object 操作
CYK_byte的博客
07-06 1086
案例：获取 文件夹"dir1" 中的 "test.gif"文件 ，保存到本地磁盘的 "D:/tmp/" 路径下，并重命名为 "123.gif"案例：将本地 "D:/tmp/滑稽.gif" 图片上传到 MinIO 的 "dir1" 文件夹下，并重命名为 "test.gif"案例：给 MinIO 上的 "dir1" 文件夹下的 "test.gif" 文件生成一个带签名的 url 路径（get 请求）.案例：查询 "dir1" 文件夹下的 "test.gif" 文件的状态。
minIO 下载安装和实现上传功能
m0_68979682的博客
08-04 1319
1.先在pom.xml导入依赖,(官网获取)现在通过一个案列与java集成。启动完成后，可以看到访问的路径。再当前的文件目录中输入cmd。使用提供的账号密码进行登录。账号：minioadmin。密码：minioadmin。通过命令行启动Minio。...
MinIO杂谈（bucket、对象Object管理、策略policy生成、创建临时用户user）
as350144的专栏
04-05 6979
Minio杂谈，文件对象管理器（集成MinIO、阿里云OSS基本操作及临时token获取）
SpringBoot(31) 整合MinIO实现文件上传与下载
08-17
在本教程中，我们将深入探讨如何使用SpringBoot框架与MinIO进行集成，以实现文件的上传和下载功能。SpringBoot以其简洁的配置和强大的功能深受Java开发者喜爱，而MinIO则是一个高性能的对象存储服务器，适合处理大...
SpringBoot集成minio实现文件的上传，下载，获取列表，增加桶等的基本操作
06-27
SpringBoot集成minio实现文件的上传，下载，获取列表，增加桶等的基本操作 该项目是个人大作业项目源码，项目中的源码都是经过本地编译过可运行的，都经过严格调试，确保可以运行！！！评审分达到95分以上。资源项目...
SpringBoot + minio实现文件切片极速上传技术源码（敢说全网整合完整度前三）
06-02
简单易用：Minio的安装和配置非常简单，只需要下载并运行相应的二进制文件即可。它提供了一个Web UI,可以通过界面管理存储桶和对象。 可扩展性：Minio可以轻松地扩展到多个节点，以提供高可用性和容错能力。它支持...
Springboot通过MinIO进行文件操作代码
09-27
在Spring Boot应用中，MinIO是一个非常流行的对象存储服务，它可以用来进行文件的上传、下载、删除等操作。MinIO是高度兼容Amazon S3的对象存储服务器，提供了简单、快速、可扩展的数据存储解决方案。本教程将详细...
springboot整合minio实现文件上传下载
weixin_41964243的博客
11-13 1891
密码，密码不能设置过于简单，不然 minio 会启动失败，长度最小是 8 个字符；：用户名，长度最小是 5 个字符；：web 后台端口，默认随机；：指定集群配置文件目录；：api 的端口，默认是。
Minio上传分块文件不按原大小上传
jjfolk的博客
04-25 489
此时可以看到上传的文件最后一个为最小其余都是6兆，并且在进行后续合并测试也通过了，合并出来的文件也完好无损，关于这个问题本来想深挖一下原因的但是因为凌晨2点半在写这个不想浪费时间也想多留住几根头发所以试下了改变分块文件的大小为6就快速解决了，有同样问题的程序猿可以参考一下如果有大佬发现了原因麻烦评论告知一下。所以我在进行分块的时候将每个文件大小设置为6兆。今天测试一个Minio上传分块文件源文件如下。再次进行上传Minio中文件如下。
Minio 入门，单机、集群部署踩坑，JAVA上传下载实践
殷长庆的博客
02-25 3574
官网地址 https://min.io/ 官网文档 https://docs.min.io/docs/minio-quickstart-guide.html 下载地址 https://dl.min.io/ 基础概念 Object：存储到Minio的基本对象，如文件、字节流Bucket：用来存储Object的逻辑空间。每个Bucket之间的数据是相互隔离的。对于客户端而言，就相当于一个存放文件的顶层文件夹。Drive：即存储数据的磁盘，在MinIO启动时，以参数的方式传入。Minio中所有的对象
vue中使用MINIO将文件上传到指定的bucket库中（vue2和vue3）
qq_45634989的博客
09-14 4751
vue中使用MINIO将文件上传到指定的bucket库中（vue2和vue3）
快速入门轻量级对象存储服务Minio
weixin_44768189的博客
03-14 769
文档地址：http://docs.minio.org.cn/docs/master/minio-monitoring-guide 介绍 MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。 一、下载安装 Window版本下载 https://dl.min.io/server/minio/r..
通过http请求minio获取 bucket 可用容量和已用容量（Java）
weixin_44573077的博客
04-11 1235
请求MinIO接口获取metrics进行分析，获取可用容量和已用容量。
SpringBoot集成Minio存储桶之简单使用
qq_61273171的博客
02-22 334
在配置文件application-dev.yml中配置minio服务地址，用户名，密码和桶名称。三、测试类中实现文件的上传、并且返回文件的保存路径。设置配置类读取minio配置信息。
SpringBoot整合Minio及常见问题解决
qq_53253335的博客
03-28 1563
Data@Component@Serial/*** 访问地址*//*** accessKey类似于用户ID，用于唯一标识你的账户*//*** secretKey是你账户的密码*//*** 默认存储桶*/
minio整合springboot
07-28
例如，如果您想上传文件到MinIO，可以创建一个服务类并注入`MinioClient`，然后编写上传文件的方法： ```java @Service public class MinioService { private final MinioClient minioClient; public ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值