精华内容
下载资源
问答
  • 主要介绍了基于Java写minio客户端实现上传下载文件,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java操作MinIo上传下载文件

    千次阅读 2021-01-24 18:03:35
    介绍与安装请查看另一篇文章 ...完整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/XMLSc

    介绍与安装请查看另一篇文章
    MinIo安装及其使用指南

    环境准备

    依赖版本
    Java1.8
    minio7.0.2
    maven3.3.9
    SpringBoot2.4

    创建项目

    完整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.4.2</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
        <groupId>com.minio.demo</groupId>
        <artifactId>demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>demo</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</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <scope>runtime</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>io.minio</groupId>
                <artifactId>minio</artifactId>
                <version>7.0.2</version>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
            </dependency>
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.4.4</version>
            </dependency>
            <dependency>
                <groupId>javax.persistence</groupId>
                <artifactId>persistence-api</artifactId>
                <version>1.0</version>
                <scope>compile</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.73</version>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <configuration>
                        <excludes>
                            <exclude>
                                <groupId>org.projectlombok</groupId>
                                <artifactId>lombok</artifactId>
                            </exclude>
                        </excludes>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    </project>
    
    

    配置文件

    server:
      port: 11808
    
    minio:
      endpoint: http://192.168.31.150/
      port: 9000
      accessKey: AKIAIOSFODNN7EXAMPLE
      secretKey: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
      secure: false
      bucketName: "demo"
    

    代码是之前写的demo,有一部分是参考其他博主写的代码,但由于时间有些久远,不记得是哪位博主了,因此未未能注明来源,还望抱歉,另外,以下代码经过postman测试,没什么太大的问题.不过仅供参考,请结合实际业务编写.

    Minio配置类

    import io.minio.MinioClient;
    import io.minio.errors.InvalidEndpointException;
    import io.minio.errors.InvalidPortException;
    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.stereotype.Component;
    
    @Data
    @Component
    @ConfigurationProperties(prefix = "minio")
    public class MinioConfig {
    
        // endPoint是一个URL,域名,IPv4或者IPv6地址
        private String endpoint;
    
        // TCP/IP端口号
        private int port;
    
        private String accessKey;
    
        private String secretKey;
    
        // 如果是true,则用的是https而不是http,默认值是true
        private Boolean secure;
    
        // 默认存储桶
        private String bucketName;
    
        @Bean
        public MinioClient getMinioClient() throws InvalidEndpointException, InvalidPortException {
            MinioClient minioClient = new MinioClient(endpoint, port, accessKey, secretKey, secure);
            return minioClient;
        }
    }
    

    MinioService

    import io.minio.ObjectStat;
    import io.minio.Result;
    import io.minio.errors.*;
    import io.minio.messages.Item;
    import org.springframework.web.multipart.MultipartFile;
    
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.InputStream;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    
    public interface MinioService {
    
    
        /**
         * 判断 bucket是否存在
         *
         * @param bucketName
         * @return
         */
        boolean bucketExists(String bucketName);
    
        /**
         * 创建 bucket
         *
         * @param bucketName
         */
        void makeBucket(String bucketName);
    
        /**
         * 文件上传
         *
         * @param bucketName
         * @param objectName
         * @param filename
         */
        void putObject(String bucketName, String objectName, String filename);
    
        /**
         * 文件上传
         *
         * @param bucketName
         * @param objectName
         * @param stream
         */
        void putObject(String bucketName, String objectName, InputStream stream, String contentType);
    
        /**
         * 文件上传
         *
         * @param bucketName
         * @param multipartFile
         */
        void putObject(String bucketName, MultipartFile multipartFile, String filename);
    
        /**
         * 删除文件
         * @param bucketName
         * @param objectName
         */
        boolean removeObject(String bucketName,String objectName);
    
        /**
         * 下载文件
         *
         * @param fileName
         * @param originalName
         * @param response
         */
        void downloadFile(String bucketName, String fileName, String originalName, HttpServletResponse response);
    
        /**
         * 获取文件路径
         * @param bucketName
         * @param objectName
         * @return
         */
        String getObjectUrl(String bucketName,String objectName);
    
    
        /**
         * @description:  文件下载
         * @param:  bucketName
          objectName
         * @return: io.minio.ObjectStat
         * @author yangc
         * @date: 2020-10-20 20:24
         */
        ObjectStat statObject(String bucketName, String objectName);
    
        /**
         * 以流的形式获取一个文件对象
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @return
         */
        InputStream getObject(String bucketName, String objectName);
    
    
        /**
         * 列出存储桶中所有对象
         *
         * @param bucketName 存储桶名称
         * @return
         */
        Iterable<Result<Item>> listObjects(String bucketName);
    
    
        /**
         * 生成一个给HTTP GET请求用的presigned URL
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @param expires 失效时间(以秒为单位),默认是7天,不得大于七天
         * @return
         */
        String presignedGetObject(String bucketName, String objectName, Integer expires);
    
    
        /**
         * 设置存储桶策略
         *
         * @param bucketName 存储桶名称
         * @return
         */
        void setBucketPolicy(String bucketName, String policy) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException;
    
    
        /**
         * 获取存储桶策略
         *
         * @param bucketName 存储桶名称
         * @return
         */
        String getBucketPolicy(String bucketName) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, BucketPolicyTooLargeException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException;
    }
    
    

    MinioServiceIpl

    import com.minio.demo.service.MinioService;
    import com.minio.demo.utils.MinioUtil;
    import io.minio.ObjectStat;
    import io.minio.Result;
    import io.minio.errors.*;
    import io.minio.messages.Item;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.web.multipart.MultipartFile;
    
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.InputStream;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    
    @Service
    public class MinioServiceImpl implements MinioService {
    
        @Autowired
        private MinioUtil minioUtil;
    
        /**
         * 判断 bucket是否存在
         *
         * @param bucketName
         * @return
         */
        @Override
        public boolean bucketExists(String bucketName) {
            return minioUtil.bucketExists(bucketName);
        }
    
        /**
         * 创建 bucket
         *
         * @param bucketName
         */
        @Override
        public void makeBucket(String bucketName) {
            minioUtil.makeBucket(bucketName);
        }
    
        /**
         * 文件上传
         *
         * @param bucketName
         * @param objectName
         * @param filename
         */
        @Override
        public void putObject(String bucketName, String objectName, String filename) {
            minioUtil.putObject(bucketName, objectName, filename);
        }
    
    
        @Override
        public void putObject(String bucketName, String objectName, InputStream stream, String contentType) {
            minioUtil.putObject(bucketName, objectName, stream, contentType);
        }
    
        /**
         * 文件上传
         *
         * @param bucketName
         * @param multipartFile
         */
        @Override
        public void putObject(String bucketName, MultipartFile multipartFile, String filename) {
            minioUtil.putObject(bucketName, multipartFile, filename);
        }
    
        /**
         * 删除文件
         * @param bucketName
         * @param objectName
         */
        @Override
        public boolean removeObject(String bucketName,String objectName) {
            return minioUtil.removeObject(bucketName,objectName);
        }
    
        /**
         * 下载文件
         *
         * @param fileName
         * @param originalName
         * @param response
         */
        @Override
        public void downloadFile(String bucketName, String fileName, String originalName, HttpServletResponse response) {
            minioUtil.downloadFile(bucketName,fileName, originalName, response);
        }
    
        /**
         * 获取文件路径
         * @param bucketName
         * @param objectName
         * @return
         */
        @Override
        public String getObjectUrl(String bucketName,String objectName) {
            return minioUtil.getObjectUrl(bucketName,objectName);
        }
    
        /**
         * @param bucketName
         * @param objectName
         * @description: 文件下载
         * @param: bucketName
         * objectName
         * @return: io.minio.ObjectStat
         * @author yangc
         * @date: 2020-10-20 20:24
         */
        @Override
        public ObjectStat statObject(String bucketName, String objectName) {
            return minioUtil.statObject(bucketName,objectName);
        }
    
        /**
         * 以流的形式获取一个文件对象
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @return
         */
        @Override
        public InputStream getObject(String bucketName, String objectName) {
            return minioUtil.getObject(bucketName,objectName);
        }
    
        /**
         * 列出存储桶中所有对象
         *
         * @param bucketName 存储桶名称
         * @return
         */
        @Override
        public Iterable<Result<Item>> listObjects(String bucketName) {
            return minioUtil.listObjects(bucketName);
        }
    
        /**
         * 生成一个给HTTP GET请求用的presigned URL
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @param expires    失效时间(以秒为单位),默认是7天,不得大于七天
         * @return
         */
        @Override
        public String presignedGetObject(String bucketName, String objectName, Integer expires) {
            return minioUtil.presignedGetObject(bucketName, objectName, expires);
        }
    
        /**
         * 设置存储桶策略
         *
         * @param bucketName 存储桶名称
         * @param policy
         * @return
         */
        @Override
        public void setBucketPolicy(String bucketName, String policy) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
            minioUtil.setBucketPolicy(bucketName, policy);
        }
    
        /**
         * 获取存储桶策略
         *
         * @param bucketName 存储桶名称
         * @return
         */
        @Override
        public String getBucketPolicy(String bucketName) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, BucketPolicyTooLargeException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {
            return minioUtil.getBucketPolicy(bucketName);
        }
    
    
    }
    
    

    MinioUtil

    import io.minio.MinioClient;
    import io.minio.ObjectStat;
    import io.minio.PutObjectOptions;
    import io.minio.Result;
    import io.minio.errors.*;
    import io.minio.messages.Bucket;
    import io.minio.messages.DeleteError;
    import io.minio.messages.Item;
    import lombok.SneakyThrows;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.web.multipart.MultipartFile;
    
    import javax.servlet.ServletOutputStream;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.InputStream;
    import java.nio.charset.StandardCharsets;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @PackageName: com.hope.minio.utils
     * @ClassName: MinioUtil
     * @Author Hope
     * @Date 2020/7/27 11:43
     * @Description: MinioUtil
     */
    @Component
    public class MinioUtil {
    
        @Autowired
        private MinioClient minioClient;
    
        private static final int DEFAULT_EXPIRY_TIME = 7 * 24 * 3600;
    
        /**
         * 检查存储桶是否存在
         *
         * @param bucketName 存储桶名称
         * @return
         */
        @SneakyThrows
        public boolean bucketExists(String bucketName) {
            boolean flag = false;
            flag = minioClient.bucketExists(bucketName);
            if (flag) {
                return true;
            }
            return false;
        }
    
        /**
         * 创建存储桶
         *
         * @param bucketName 存储桶名称
         */
        @SneakyThrows
        public boolean makeBucket(String bucketName) {
            boolean flag = bucketExists(bucketName);
            if (!flag) {
                minioClient.makeBucket(bucketName);
                return true;
            } else {
                return false;
            }
        }
    
        /**
         * 列出所有存储桶名称
         *
         * @return
         */
        @SneakyThrows
        public List<String> listBucketNames() {
            List<Bucket> bucketList = listBuckets();
            List<String> bucketListName = new ArrayList<>();
            for (Bucket bucket : bucketList) {
                bucketListName.add(bucket.name());
            }
            return bucketListName;
        }
    
        /**
         * 列出所有存储桶
         *
         * @return
         */
        @SneakyThrows
        public List<Bucket> listBuckets() {
            return minioClient.listBuckets();
        }
    
        /**
         * 删除存储桶
         *
         * @param bucketName 存储桶名称
         * @return
         */
        @SneakyThrows
        public boolean removeBucket(String bucketName) {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                Iterable<Result<Item>> myObjects = listObjects(bucketName);
                for (Result<Item> result : myObjects) {
                    Item item = result.get();
                    // 有对象文件,则删除失败
                    if (item.size() > 0) {
                        return false;
                    }
                }
                // 删除存储桶,注意,只有存储桶为空时才能删除成功。
                minioClient.removeBucket(bucketName);
                flag = bucketExists(bucketName);
                if (!flag) {
                    return true;
                }
    
            }
            return false;
        }
    
        /**
         * 列出存储桶中的所有对象名称
         *
         * @param bucketName 存储桶名称
         * @return
         */
        @SneakyThrows
        public List<String> listObjectNames(String bucketName) {
            List<String> listObjectNames = new ArrayList<>();
            boolean flag = bucketExists(bucketName);
            if (flag) {
                Iterable<Result<Item>> myObjects = listObjects(bucketName);
                for (Result<Item> result : myObjects) {
                    Item item = result.get();
                    listObjectNames.add(item.objectName());
                }
            }
            return listObjectNames;
        }
    
        /**
         * 列出存储桶中的所有对象
         *
         * @param bucketName 存储桶名称
         * @return
         */
        @SneakyThrows
        public Iterable<Result<Item>> listObjects(String bucketName) {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                return minioClient.listObjects(bucketName);
            }
            return null;
        }
    
        /**
         * 通过文件上传到对象
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @param fileName   File name
         * @return
         */
        @SneakyThrows
        public boolean putObject(String bucketName, String objectName, String fileName) {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                minioClient.putObject(bucketName, objectName, fileName, null);
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) {
                    return true;
                }
            }
            return false;
    
        }
    
        /**
         * 文件上传
         *
         * @param bucketName
         * @param multipartFile
         */
        @SneakyThrows
        public void putObject(String bucketName, MultipartFile multipartFile, String filename) {
            PutObjectOptions putObjectOptions = new PutObjectOptions(multipartFile.getSize(), PutObjectOptions.MIN_MULTIPART_SIZE);
            putObjectOptions.setContentType(multipartFile.getContentType());
            minioClient.putObject(bucketName, filename, multipartFile.getInputStream(), putObjectOptions);
        }
    
    
        /**
         * 通过InputStream上传对象
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @param stream     要上传的流
         * @param stream     要上传的文件类型 MimeTypeUtils.IMAGE_JPEG_VALUE
         * @return
         */
        @SneakyThrows
        public boolean putObject(String bucketName, String objectName, InputStream stream,String contentType) {
            boolean flag = bucketExists(bucketName);
            if (flag) {
            	PutObjectOptions putObjectOptions = new PutObjectOptions(stream.available(), -1);
            	/**
            	 * 开启公共类功能设置setContentType
            	 */
            	if (StringUtils.isNotBlank(contentType)) {
            		putObjectOptions.setContentType(contentType);
    			}
                minioClient.putObject(bucketName, objectName, stream, putObjectOptions);
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) {
                    return true;
                }
            }
            return false;
        }
        
    	/**
         * 以流的形式获取一个文件对象
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @return
         */
        @SneakyThrows
        public InputStream getObject(String bucketName, String objectName) {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) {
                    InputStream stream = minioClient.getObject(bucketName, objectName);
                    return stream;
                }
            }
            return null;
        }
    
        /**
         * 以流的形式获取一个文件对象(断点下载)
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @param offset     起始字节的位置
         * @param length     要读取的长度 (可选,如果无值则代表读到文件结尾)
         * @return
         */
        @SneakyThrows
        public InputStream getObject(String bucketName, String objectName, long offset, Long length) {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) {
                    InputStream stream = minioClient.getObject(bucketName, objectName, offset, length);
                    return stream;
                }
            }
            return null;
        }
    
        /**
         * 下载并将文件保存到本地
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @param fileName   File name
         * @return
         */
        @SneakyThrows
        public boolean getObject(String bucketName, String objectName, String fileName) {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                ObjectStat statObject = statObject(bucketName, objectName);
                if (statObject != null && statObject.length() > 0) {
                    minioClient.getObject(bucketName, objectName, fileName);
                    return true;
                }
            }
            return false;
        }
    
        /**
         * 删除一个对象
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         */
        @SneakyThrows
        public boolean removeObject(String bucketName, String objectName) {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                minioClient.removeObject(bucketName, objectName);
                return true;
            }
            return false;
        }
    
        /**
         * 删除指定桶的多个文件对象,返回删除错误的对象列表,全部删除成功,返回空列表
         *
         * @param bucketName  存储桶名称
         * @param objectNames 含有要删除的多个object名称的迭代器对象
         * @return
         */
        @SneakyThrows
        public List<String> removeObject(String bucketName, List<String> objectNames) {
            List<String> deleteErrorNames = new ArrayList<>();
            boolean flag = bucketExists(bucketName);
            if (flag) {
                Iterable<Result<DeleteError>> results = minioClient.removeObjects(bucketName, objectNames);
                for (Result<DeleteError> result : results) {
                    DeleteError error = result.get();
                    deleteErrorNames.add(error.objectName());
                }
            }
            return deleteErrorNames;
        }
    
        /**
         * 生成一个给HTTP GET请求用的presigned URL。
         * 浏览器/移动端的客户端可以用这个URL进行下载,即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间,默认值是7天。
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @param expires    失效时间(以秒为单位),默认是7天,不得大于七天
         * @return
         */
        @SneakyThrows
        public String presignedGetObject(String bucketName, String objectName, Integer expires) {
            boolean flag = bucketExists(bucketName);
            String url = "";
            if (flag) {
                if (expires < 1 || expires > DEFAULT_EXPIRY_TIME) {
                    throw new InvalidExpiresRangeException(expires,
                            "expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
                }
                url = minioClient.presignedGetObject(bucketName, objectName, expires);
            }
            return url;
        }
    
        /**
         * 生成一个给HTTP PUT请求用的presigned URL。
         * 浏览器/移动端的客户端可以用这个URL进行上传,即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间,默认值是7天。
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @param expires    失效时间(以秒为单位),默认是7天,不得大于七天
         * @return
         */
        @SneakyThrows
        public String presignedPutObject(String bucketName, String objectName, Integer expires) {
            boolean flag = bucketExists(bucketName);
            String url = "";
            if (flag) {
                if (expires < 1 || expires > DEFAULT_EXPIRY_TIME) {
                    throw new InvalidExpiresRangeException(expires,
                            "expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);
                }
                url = minioClient.presignedPutObject(bucketName, objectName, expires);
            }
            return url;
        }
    
        /**
         * 获取对象的元数据
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @return
         */
        @SneakyThrows
        public ObjectStat statObject(String bucketName, String objectName) {
            boolean flag = bucketExists(bucketName);
            if (flag) {
                ObjectStat statObject = minioClient.statObject(bucketName, objectName);
                return statObject;
            }
            return null;
        }
    
        /**
         * 文件访问路径
         *
         * @param bucketName 存储桶名称
         * @param objectName 存储桶里的对象名称
         * @return
         */
        @SneakyThrows
        public String getObjectUrl(String bucketName, String objectName) {
            boolean flag = bucketExists(bucketName);
            String url = "";
            if (flag) {
                url = minioClient.getObjectUrl(bucketName, objectName);
            }
            return url;
        }
    
    
        /**
         * 设置存储桶策略
         *
         * @param bucketName 存储桶名称
         * @param policy 存储桶里的对象名称
         */
        public void setBucketPolicy(String bucketName, String policy) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    
            minioClient.setBucketPolicy(bucketName, policy);
        }
    
    
        /**
         * 获取存储桶策略
         *
         * @param bucketName 存储桶名称
         * @return
         */
        public String getBucketPolicy(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, BucketPolicyTooLargeException, NoSuchAlgorithmException, InternalException, XmlParserException, InvalidBucketNameException, InsufficientDataException, ErrorResponseException {
    
            return minioClient.getBucketPolicy(bucketName);
        }
    
    
    
        public void downloadFile(String bucketName, String fileName, String originalName, HttpServletResponse response) {
            try {
    
                InputStream file = minioClient.getObject(bucketName, fileName);
                String filename = new String(fileName.getBytes("ISO8859-1"), StandardCharsets.UTF_8);
                if (StringUtils.isNotEmpty(originalName)) {
                    fileName = originalName;
                }
                response.setHeader("Content-Disposition", "attachment;filename=" + filename);
                ServletOutputStream servletOutputStream = response.getOutputStream();
                int len;
                byte[] buffer = new byte[1024];
                while ((len = file.read(buffer)) > 0) {
                    servletOutputStream.write(buffer, 0, len);
                }
                servletOutputStream.flush();
                file.close();
                servletOutputStream.close();
            } catch (ErrorResponseException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
    }
    
    

    MinioController

    import com.alibaba.fastjson.JSON;
    import com.minio.demo.config.MinioConfig;
    import com.minio.demo.result.Result;
    import com.minio.demo.service.MinioService;
    import com.minio.demo.utils.UploadFile;
    import io.minio.ObjectStat;
    import io.minio.errors.*;
    import io.minio.messages.Item;
    import lombok.SneakyThrows;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.apache.tomcat.util.http.fileupload.IOUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.*;
    import org.springframework.web.multipart.MultipartFile;
    
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.URLEncoder;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.text.DecimalFormat;
    import java.util.*;
    
    @RequestMapping("/minio")
    @RestController
    @Slf4j
    public class MinioController {
    
        @Autowired
        private MinioService minioService;
    
        @Autowired
        private MinioConfig minioConfig;
    
        @Autowired
        private UploadFile uploadFile;
    
    
        @SneakyThrows
        @PostMapping("/file")
        public Result uploadFile(MultipartFile file, @RequestParam("bucketName") String bucketName) {
            uploadFile.uploadFile(file, bucketName);
            return Result.success();
        }
    
        @PostMapping("/files")
        public Result uploadFiles(@RequestParam("multipartFiles") List<MultipartFile> files, @RequestParam("bucketName") String bucketName) {
            for (MultipartFile file : files) {
                uploadFile.uploadFile(file, bucketName);
            }
            return Result.success();
        }
    
        @GetMapping("/file")
        public Result download(HttpServletResponse response, @RequestParam("fileName") String fileName, @RequestParam("bucketName") String bucketName, @RequestParam("fileId") String fileId) {
            try {
                //获取存储捅名
                bucketName = StringUtils.isNotBlank(bucketName) ? bucketName : minioConfig.getBucketName();
                //获取对象信息和对象的元数据。
                ObjectStat objectStat = minioService.statObject(bucketName, fileName);
                //setContentType 设置发送到客户机的响应的内容类型
                response.setContentType(objectStat.contentType());
                //设置响应头
                response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(objectStat.name(), "UTF-8"));
                //文件流
                InputStream object = minioService.getObject(bucketName, fileName);
                //设置文件大小
                response.setHeader("Content-Length", String.valueOf(objectStat.length()));
                IOUtils.copy(object, response.getOutputStream());
                //关闭流
                object.close();
                return Result.success();
            } catch (Exception e) {
                log.error("下载文件失败,错误信息: " + e.getMessage());
                return Result.fail("下载失败.");
            }
        }
    
        @DeleteMapping(value = "/file")
        public Result deleteFile(@RequestParam("bucketName") String bucketName, @RequestParam("objectName") String objectName) {
            minioService.removeObject(bucketName, objectName);
            return Result.success();
        }
    
    
        @GetMapping(value = "/file/list")
        public Result<List<Object>> getFileList(@RequestParam("bucketName") String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
            try {
                //获取存储捅名
                bucketName = StringUtils.isNotBlank(bucketName) ? bucketName : minioConfig.getBucketName();
                //列出存储桶中所有对象
                Iterable<io.minio.Result<Item>> results = minioService.listObjects(bucketName);
                //迭代器
                Iterator<io.minio.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, "http://localhost:9000/"+bucketName+"/"+item.objectName(), formatFileSize(item.size()))));
                }
                return Result.success(items);
            } catch (Exception e) {
                log.error("获取文件列表失败,错误信息: " + e.getMessage());
                return Result.fail("获取文件列表失败");
            }
        }
    
        @GetMapping("/preview/file")
        public Result<List<Object>> getPreviewFile(@RequestParam("bucketName") String bucketName,
                                                   @RequestParam("expires") Integer expires,
                                                   @RequestParam("objectName") String objectName) {
            //获取存储捅名
            bucketName = StringUtils.isNotBlank(bucketName) ? bucketName : minioConfig.getBucketName();
            //生成一个给HTTP GET请求用的presigned URL
            String filePath = minioService.presignedGetObject(bucketName, objectName, expires);
            //封装信息
            return Result.success(filePath);
        }
    
    
    
        @GetMapping("/previewList")
        public Result<List<Object>> getPreviewList(@RequestParam("bucketName") String bucketName,
                                                   @RequestParam("expires") Integer expires
        ) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {
    
            try {
                //获取存储捅名
                bucketName = StringUtils.isNotBlank(bucketName) ? bucketName : minioConfig.getBucketName();
                //列出存储桶中所有对象
                Iterable<io.minio.Result<Item>> myObjects = minioService.listObjects(bucketName);
                //迭代器
                Iterator<io.minio.Result<Item>> iterator = myObjects.iterator();
                List<Object> items = new ArrayList<>();
                String format = "{'fileName':'%s','fileSize':'%s'}";
                while (iterator.hasNext()) {
                    //返回迭代中的下一个元素。
                    Item item = iterator.next().get();
                    //生成一个给HTTP GET请求用的presigned URL
                    String filePath = minioService.presignedGetObject(bucketName, item.objectName(), expires);
                    //封装信息
                    items.add(JSON.parse(String.format(format, filePath, formatFileSize(item.size()))));
                }
                return Result.success(items);
            } catch (Exception e) {
                return Result.fail("生成可以预览的文件链接失败,错误信息:" + e.getMessage());
            }
    
        }
    
        /**
         * 显示文件大小信息单位
         *
         * @param fileS
         * @return
         */
        private 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;
        }
    
    }
    

    UploadFile

    import cn.hutool.core.io.file.FileNameUtil;
    import com.minio.demo.config.MinioConfig;
    import com.minio.demo.service.MinioService;
    import lombok.SneakyThrows;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.web.multipart.MultipartFile;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.UUID;
    
    @Component
    public class UploadFile {
    
        @Autowired
        private MinioService minioService;
    
        @Autowired
        private MinioConfig minioConfig;
    
        @SneakyThrows
        public  void uploadFile(MultipartFile file, String bucketName) {
    
            // 获取存储桶名称,不存在则使用默认桶名
            bucketName = StringUtils.isNotBlank(bucketName) ? bucketName : minioConfig.getBucketName();
    
            // 判断是否存在该存储桶
            if (!minioService.bucketExists(bucketName)) {
                // 不存在则创建
                minioService.makeBucket(bucketName);
                // 设置存储桶只读策略
                String bucketPolicy ="{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"" +
                        "Action\":[\"s3:GetBucketLocation\",\"s3:ListBucket\"],\"Resource\":[\"arn:aws:s3:::fast\"]},{\"Effect\":\"Allow\",\"" +
                        "Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:GetObject\"],\"Resource\":[\"arn:aws:s3:::" +
                        bucketName+"/*\"]}]}";
                // 设置存储桶策略
                minioService.setBucketPolicy(bucketName,bucketPolicy);
            }
            // 原始文件名
            String fileName = file.getOriginalFilename();
            // 获取文件后缀名
            String extName = FileNameUtil.extName(fileName);
            // 定义文件路径
            String format = new SimpleDateFormat("yyyy/MM/dd/").format(new Date());
            // 定义文件修改之后的名字,去除uuid中的' - '
            String fileuuid = UUID.randomUUID().toString().replaceAll("-", "");
            // 定义新的文件名
            String objectName = format + fileuuid + "." + extName;
            //上传文件
            minioService.putObject(bucketName, file, objectName);
        }
    }
    
    

    测试

    单个文件上传

    在这里插入图片描述

    在这里插入图片描述

    多文件上传

    在这里插入图片描述
    在这里插入图片描述

    文件下载

    在这里插入图片描述

    文件删除

    在这里插入图片描述

    生成可以预览的链接

    在这里插入图片描述

    生成单个可预览的链接

    在这里插入图片描述

    demo仓库地址

    为方面大家查看,已经将代码上传到码云上,地址如下:

    https://gitee.com/cyangDrow/min-iodemo/tree/master

    展开全文
  • Minio下载及配置文件

    2021-02-23 09:26:07
    Minio下载及配置文件 下载参考:http://www.minio.org.cn/download.shtml#/windows 2. Minio配置文件(windows版) set MINIO_ACCESS_KEY=admin set MINIO_SECRET_KEY=admin123 minio.exe server --address :9000 D:\...
    Minio下载及配置文件
    

    下载参考:http://www.minio.org.cn/download.shtml#/windows
    2. Minio配置文件(windows版)

    set MINIO_ACCESS_KEY=admin
    set MINIO_SECRET_KEY=admin123
    minio.exe server --address :9000 D:\minio\file
    # 含义:用户名admiin,密码admin123 端口号:9000(默认) 上传文件存储位置:D:\minio\file
    

    将以上代码报错到bat文件中,放在与Minio文件服务文件放在同一路径下,点击bat文件即可(上传文件存储位置需要提前创建)

    展开全文
  • 前面两章介绍了 MinIO 文件服务器的环境搭建,以及在 Java 中上传文件MinIO 文件服务器中,现在,一起来看下如何从 MinIO 文件服务器中下载文件吧 1、获取文件对象 我们在 MinIO 工具类中,获取文件对象的方法,...

    前面两章介绍了 MinIO 文件服务器的环境搭建,以及在 Java 中上传文件至 MinIO 文件服务器中,现在,一起来看下如何从 MinIO 文件服务器中下载文件吧

    1、获取文件对象

    我们在 MinIO 工具类中,获取文件对象的方法,即获取文件的输入流对象

    /**
     * 获取文件
     *
     * @param bucketName bucket名称
     * @param objectName 文件名称
     * @return 二进制流
     */
    @SneakyThrows
    public InputStream getObject(String bucketName, String objectName) {
        return client.getObject(bucketName, objectName);
    }
    
    • bucketName,是指存储桶的名称
    • objectName,是指文件的路径,即存储桶下文件的相对路径

    例如,图片的地址为

    http://127.0.0.1:9000/bucketName/20200806/1596681603481809.png
    

    那么 objectName 就为

    20200806/1596681603481809.png
    

    2、下载文件

    我们需要编写一个 API 来进行访问从而下载文件

    /**
         * 下载文件
         *
         * @param fileUrl  文件绝对路径
         * @param response
         * @throws IOException
         */
        @GetMapping("downloadFile")
        public void downloadFile(String fileUrl, HttpServletResponse response) throws IOException {
            if (StringUtils.isBlank(fileUrl)) {
                response.setHeader("Content-type", "text/html;charset=UTF-8");
                String data = "文件下载失败";
                OutputStream ps = response.getOutputStream();
                ps.write(data.getBytes("UTF-8"));
                return;
            }
            try {
                // 拿到文件路径
                String url = fileUrl.split("9000/")[1];
                // 获取文件对象
                InputStream object = minioUtils.getObject(MinioConst.MINIO_BUCKET, url.substring(url.indexOf("/") + 1));
                byte buf[] = new byte[1024];
                int length = 0;
                response.reset();
                response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(url.substring(url.lastIndexOf("/") + 1), "UTF-8"));
                response.setContentType("application/octet-stream");
                response.setCharacterEncoding("UTF-8");
                OutputStream outputStream = response.getOutputStream();
                // 输出文件
                while ((length = object.read(buf)) > 0) {
                    outputStream.write(buf, 0, length);
                }
                // 关闭输出流
                outputStream.close();
            } catch (Exception ex) {
                response.setHeader("Content-type", "text/html;charset=UTF-8");
                String data = "文件下载失败";
                OutputStream ps = response.getOutputStream();
                ps.write(data.getBytes("UTF-8"));
            }
        }
    

    这里传入的参数 fileUrl 为文件的绝对路径,即可以直接访问的路径,还需要通过此路径,截取得到文件的相对路径(即去掉 IP 地址和端口,去掉存储桶名称的路径)

    3、测试

    通过访问 API

    http://127.0.0.1/minio/downloadFile?fileUrl=http://127.0.0.1:9000/bucketName/20200806/1596681603481809.png
    

    便能成功下载文件了

    如您在阅读中发现不足,欢迎留言!!!

    展开全文
  • minio文件存储服务

    2021-08-16 00:09:15
    新建一个目录存放minio文件,如 D:\minioData,CMD进入刚刚下载的minio.exe所在目录,直接在cmd下运行:minio.exe server D:\minioData 启动成功以后如记住显示的access Key和Secret Key (默认全是minioadmin) ...
  • 一、前言 MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。...MinIO官方文档:https://docs.min.io/cn/ 二、Docker安装MinIO # 环境准备 git clone https://gitee.com/zhengqingya/docker-compose.git #

    一、前言

    MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口,非常适合于存储大容量非结构化的数据,例如图片视频日志文件备份数据容器/虚拟机镜像等,而一个对象文件可以是任意大小,从几kb到最大5T不等。

    MinIO官方文档:https://docs.min.io/cn/

    二、Docker安装MinIO

    # 环境准备
    git clone https://gitee.com/zhengqingya/docker-compose.git
    
    # Liunx系统走此路径
    cd docker-compose/Liunx
    # Windows系统走此路径
    cd docker-compose/Windows
    
    # 运行服务
    docker-compose -f docker-compose-minio.yml -p minio up -d
    

    访问地址:http://127.0.0.1:9001/minio
    登录账号密码:root/password

    在这里插入图片描述

    三、SpringBoot整合MinIO实现文件上传与下载

    1、pom.xml中引入MinIO依赖

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

    2、application.yml中配置MinIO

    # ====================== ↓↓↓↓↓↓ MinIO文件服务器 ↓↓↓↓↓↓ ======================
    minio:
      url: http://127.0.0.1:9001
      accessKey: root
      secretKey: password
      bucketName: test
    

    3、MinIO属性类

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

    4、MinIO工具类

    Java Client API参考文档:https://docs.min.io/cn/java-client-api-reference.html

    @Slf4j
    @Component
    public class MinIoUtil {
    
        @Autowired
        MinIoProperties minIoProperties;
    
        private static MinioClient minioClient;
    
        /**
         * 初始化minio配置
         *
         * @param :
         * @return: void
         * @date : 2020/8/16 20:56
         */
        @PostConstruct
        public void init() {
            try {
                minioClient = new MinioClient(minIoProperties.getUrl(), minIoProperties.getAccessKey(),
                    minIoProperties.getSecretKey());
                createBucket(minIoProperties.getBucketName());
            } catch (Exception e) {
                e.printStackTrace();
                log.error("初始化minio配置异常: 【{}】", e.fillInStackTrace());
            }
        }
    
        /**
         * 判断 bucket是否存在
         *
         * @param bucketName:
         *            桶名
         * @return: boolean
         * @date : 2020/8/16 20:53
         */
        @SneakyThrows(Exception.class)
        public static boolean bucketExists(String bucketName) {
            return minioClient.bucketExists(bucketName);
        }
    
        /**
         * 创建 bucket
         *
         * @param bucketName:
         *            桶名
         * @return: void
         * @date : 2020/8/16 20:53
         */
        @SneakyThrows(Exception.class)
        public static void createBucket(String bucketName) {
            boolean isExist = minioClient.bucketExists(bucketName);
            if (!isExist) {
                minioClient.makeBucket(bucketName);
            }
        }
    
        /**
         * 获取全部bucket
         *
         * @param :
         * @return: java.util.List<io.minio.messages.Bucket>
         * @date : 2020/8/16 23:28
         */
        @SneakyThrows(Exception.class)
        public static List<Bucket> getAllBuckets() {
            return minioClient.listBuckets();
        }
    
        /**
         * 文件上传
         *
         * @param bucketName:
         *            桶名
         * @param fileName:
         *            文件名
         * @param filePath:
         *            文件路径
         * @return: void
         * @date : 2020/8/16 20:53
         */
        @SneakyThrows(Exception.class)
        public static void upload(String bucketName, String fileName, String filePath) {
            minioClient.putObject(bucketName, fileName, filePath, null);
        }
    
        /**
         * 文件上传
         *
         * @param bucketName:
         *            桶名
         * @param fileName:
         *            文件名
         * @param stream:
         *            文件流
         * @return: java.lang.String : 文件url地址
         * @date : 2020/8/16 23:40
         */
        @SneakyThrows(Exception.class)
        public static String upload(String bucketName, String fileName, InputStream stream) {
            minioClient.putObject(bucketName, fileName, stream, new PutObjectOptions(stream.available(), -1));
            return getFileUrl(bucketName, fileName);
        }
    
        /**
         * 文件上传
         *
         * @param bucketName:
         *            桶名
         * @param file:
         *            文件
         * @return: java.lang.String : 文件url地址
         * @date : 2020/8/16 23:40
         */
        @SneakyThrows(Exception.class)
        public static String upload(String bucketName, MultipartFile file) {
            final InputStream is = file.getInputStream();
            final String fileName = file.getOriginalFilename();
            minioClient.putObject(bucketName, fileName, is, new PutObjectOptions(is.available(), -1));
            is.close();
            return getFileUrl(bucketName, fileName);
        }
    
        /**
         * 删除文件
         *
         * @param bucketName:
         *            桶名
         * @param fileName:
         *            文件名
         * @return: void
         * @date : 2020/8/16 20:53
         */
        @SneakyThrows(Exception.class)
        public static void deleteFile(String bucketName, String fileName) {
            minioClient.removeObject(bucketName, fileName);
        }
    
        /**
         * 下载文件
         *
         * @param bucketName:
         *            桶名
         * @param fileName:
         *            文件名
         * @param response:
         * @return: void
         * @date : 2020/8/17 0:34
         */
        @SneakyThrows(Exception.class)
        public static void download(String bucketName, String fileName, HttpServletResponse response) {
            // 获取对象的元数据
            final ObjectStat stat = minioClient.statObject(bucketName, fileName);
            response.setContentType(stat.contentType());
            response.setCharacterEncoding("UTF-8");
            response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
            InputStream is = minioClient.getObject(bucketName, fileName);
            IOUtils.copy(is, response.getOutputStream());
            is.close();
        }
    
        /**
         * 获取minio文件的下载地址
         *
         * @param bucketName:
         *            桶名
         * @param fileName:
         *            文件名
         * @return: java.lang.String
         * @date : 2020/8/16 22:07
         */
        @SneakyThrows(Exception.class)
        public static String getFileUrl(String bucketName, String fileName) {
            return minioClient.presignedGetObject(bucketName, fileName);
        }
    
    }
    

    5、MinIO测试接口

    @RestController
    @RequestMapping("/api/minio")
    @Api(tags = {"MinIO测试接口"})
    public class MinIoController {
    
        @Autowired
        MinIoProperties minIoProperties;
    
        @ApiOperation(value = "上传文件")
        @PostMapping(value = "/upload")
        public String upload(@RequestParam("file") MultipartFile file) throws Exception {
            String fileUrl = MinIoUtil.upload(minIoProperties.getBucketName(), file);
            return "文件下载地址:" + fileUrl;
        }
    
        @ApiOperation(value = "下载文件")
        @GetMapping(value = "/download")
        public void download(@RequestParam("fileName") String fileName, HttpServletResponse response) {
            MinIoUtil.download(minIoProperties.getBucketName(), fileName, response);
        }
    
        @ApiOperation(value = "删除文件")
        @GetMapping(value = "/delete")
        public String delete(@RequestParam("fileName") String fileName) {
            MinIoUtil.deleteFile(minIoProperties.getBucketName(), fileName);
            return "删除成功";
        }
    
    }
    

    本文案例demo源码

    https://gitee.com/zhengqingya/java-workspace


    今日分享语句:
    努力是一种生活态度,与年龄无关。所以,无论什么时候,千万不可放纵自己,给自己找懒散和拖延的借口,对自己严格一点儿,时间长了,努力便成为一种心理习惯,一种生活方式!

    展开全文
  • MinIo简介 MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。...MinIO官方文档:https://docs.min.io/cn/ 安装 docker 安装: docker run -p 9000:9000 --name minio1 \ -e "MINIO_ACCESS_KEY=gou
  • 提供一个服务,通过文件名去minio中找是否存在文件,如果存在,将文件返回给调用者,如何实现,最终是提供一个下载路径吗?
  • minio 文件服务器

    2020-07-10 21:48:20
    minio 文件服务器环境搭建/以及示例代码,方便搭建文件服务器,代码包含传统的本地保存、minio保存、s3保存等示例代码。
  • minio--excel文件下载

    千次阅读 2020-01-05 15:34:18
    问题:项目中要更新minio里面的excel文件,上传覆盖后,根据设置的永久下载链接,下载文件依然时旧的文件,通过minio的分享链接(带有效期认证)下载为新文件,百思不得其解,询问同事也没得到回复; 解决: 自己...
  • minio文件储存服务

    2020-12-15 11:46:55
    Minio可以做为云存储的解决方案用来保存海量的图片,视频,文档。由于采用Golang实现,服务端可以工作在Windows,Linux, OS X和FreeBSD上。配置简单,基本是复制可执行程序,单行命令可以运行起来。
  • 分布式文件存储系统 minio
  • 使用minio上传下载文件图片等 1. 引入依赖,还是比较新的 <!-- minio 配置--> <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <...
  • springboot+minio实现文件上传下载

    千次阅读 2020-09-17 14:18:52
    springboot+minio实现文件上传下载: windows安装minio服务器:https://min.io/download#/windows官网下载.exe文件。 新建一个文件data,powershell进入到.exe文件目录,运行命令.\minio.exe server F:\minio\data...
  • 首先,下载文件安装,链接:https://pan.baidu.com/s/17dpzPBaobaj8kkUgB272LA 提取码:1004 复制这段内容后打开百度网盘手机App,操作更方便哦 Linux下安装命令: chmod +x minio #启动 ./minio server /usr/...
  • (2)本文章是在spring boot中集成minio,实现文件上传,当然单纯的java环境也可以实现文件上传功能。 (3)我的环境是: java 1.8.0_131 maven 3.3.9 spring boot 2.2.0 minio文档 英文:https://docs.min.io/ 中文:...
  • MinIo文件上传) 预备知识点 雷迪斯 昂首阔步 弹簧靴 MinIO SpringTask 本仓库 关注 收藏 功能演示 MinIO上传文件 SpringBoot上传文件 环境建造 创建Docker容器 docker pull redis:4 docker run --name redis -p ...
  • 开源项目-minio-mc.zip

    2019-10-24 04:28:20
    开源项目-minio-mc.zip,基于go的amazon s3 cli
  • C++ 下载 Minio文件

    千次阅读 2020-10-27 17:47:39
    C++ 下载 Minio 文件 Minio 默认没有提供 C++ 的访问接口,可以使用 AWS 的 C++ SDK 来访问 Minio。 安装 SDK 下载 aws-sdk-cpp git clone https://github.com/aws/aws-sdk-cpp.git 安装依赖 sudo apt-get install ...
  • springboot+minio实现文件的上传下载

    千次阅读 2020-11-18 17:38:26
    springboot+minio实现文件的上传下载
  • Java 上传下载文件Minio

    千次阅读 2019-09-25 16:15:28
    最低需求: Java 1.8或更高版本: OracleJDK 8.0 OpenJDK8.0 使用maven <dependency>...io.minio</groupId> <artifactId>minio</artifactId> <version>3.0.8<...
  • 1、导入minio依赖: <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <...# MinIo文件服务器 minio: # bucket名称 bucket: "t
  • pom ...io.minio</groupId> <artifactId>minio</artifactId> <version>8.2.2</version> </dependency> minio配置类 import lombok.Data; import o.
  • minio实现文件上传下载和删除功能

    万次阅读 热门讨论 2020-06-10 21:15:01
    minio的中文文档:https://docs.min.io/cn/ minio安装 首先查询docker镜像: docker search minio 选着stars最高的那个拉取: docker pull minio/minio 启动minio服务器,并设置端口号,容器名,账号和密码...
  • MinIO按前缀批量下载文件到本地

    千次阅读 2020-12-15 10:29:08
    * 按前缀批量下载文件到本地 * @param bucketName 存储桶名称 * @param prefix 文件前缀 * @param saveDir 本地存储路径 */ @SneakyThrows public void downloadFiles(String bucketName, String prefix, ...
  • windows版的minio可执行文件
  • Java MinIO文件上传,下载和删除

    千次阅读 2020-07-31 16:36:24
    1.先导入maven依赖( minio版本不能太低不然运行时会出现:org.xmlpull.v1.XmlPullParserException 错误) <dependency> <groupId>io.minio</groupId> <artifactId>minio</...
  • 个人导出这两部分,方便平时查看使用。官方文档地址:https://docs.minio.io/。官方有中文翻译,在左上角可以切换
  • 本文不讨论怎么搭建minio,仅说明Python是如何上传和下载minio的 步骤一、安装minio pip install minio 步骤二、网页登录minio,右下角+号新建一个桶 上传文件 需将下面代码中minio_conf中的endpoint更改为你实际...
  • minio下载与使用

    千次阅读 2020-10-26 12:50:28
    minio.exe 下载地址:http://dl.minio.org.cn/server/minio/release/windows-amd64/ .\minio.exe server E:\minioDate 在 minio.exe 文件夹,打开 doc 窗口 .\minio.exe server E:\minioDate E:\minioDate ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,310
精华内容 2,124
关键字:

minio下载文件