MINIO

已于 2023-02-23 17:12:52 修改
阅读量210 收藏
点赞数
分类专栏： 分布式对象存储 文章标签： java 大数据 开发语言
于 2023-02-23 17:12:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56808407/article/details/129177219
版权

文章目录

前言

简介

  • 官网地址：https://docs.min.io/cn/
  • MinIO 是在 Apache License v2.0 下发布的对象存储服务器。 它与 Amazon S3 云存储服务兼容。 它最适合存储非结构化数据，如照片，视频，日志文件，备份和容器/ VM 映像。 对象的大小可以从几 KB 到最大 5TB。
  • MinIO 服务器足够轻，可以与应用程序堆栈捆绑在一起，类似于 NodeJS，Redis 和 MySQL。
  • 一种高性能的分布式对象存储服务器，用于大型数据基础设施。它是机器学习和其他大数
    据工作负载下 Hadoop HDFS 的理想 s3 兼容替代品

优点/选择的原因

  • Minio 有良好的存储机制
  • Minio 有很好纠删码的算法与擦除编码算法
  • 拥有RS code 编码数据恢复原理
  • 公司做强做大时，数据的拥有重要性，对数据治理与大数据分析做准备。
  • 搭建自己的一套文件系统服务,对文件数据进行安全保护。
  • 拥有自己的平台，不限于其他方限制。

一、安装/配置及启动

安装及启动
启动后会打印出 AccessKey 和 SecretKey 等信息

默认配置

  • 默认 AccessKey 和 SecretKey
    • AccessKey：minioadmin
    • SecretKey：minioadmin
  • 自定义 AccessKey 和 SecretKey
    • export MINIO_ACCESS_KEY=minio
    • export MINIO_SECRET_KEY=miniostorage
  • 默认端口
    • 9000
  • 自定义端口
    • --address 0.0.0.0:9001
  • 自定义文件夹地址
    • export MINIO_VOLUMES="/home/minio/data"

访问

  • 本机访问：默认端口（http://127.0.0.1:9000）

二、使用

  1. 访问http://127.0.0.1:9000进行登录
  2. 创建Bucket ：选择Administrator-Buckets菜单，单击右侧Create Buckets按钮进入Bucket创建页面进行创建
    在这里插入图片描述
    在这里插入图片描述
  3. 选择：User-Object Browser菜单，并单击右侧 Bucket 进入管理文件页面

    4.上传：选择右侧Upload上传按钮即可上传
    在这里插入图片描述

三、MINIO 基础概念

  • Object：存储到 Minio 的基本对象，如文件、字节流，Anything…

  • Bucket：用来存储 Object 的逻辑空间。每个 Bucket 之间的数据是相互隔离的。对于客户端而言，就相当于一个存放文件的顶层文件夹。

  • Drive：即存储数据的磁盘，在 MinIO 启动时，以参数的方式传入。Minio 中所有的对象数据都会存储在 Drive 里。

  • Set：即一组 Drive 的集合

    • 每个 Set 中的 Drive 分布在不同位置。
    • 一个对象存储在一个Set上
    • 一个集群划分为多个Set
    • 一个Set包含的Drive数量是固定的，默认由系统根据集群规模自动计算得出
    • 一个SET中的Drive尽可能分布在不同的节点上

四、Java中上传文件MinIO服务器

1、引入 maven 依赖及配置

引入maven

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

application.yml配置

server:
  port: 2546
minio:
  endpoint: http://127.0.0.1:9000 #MinIO服务所在地址
  port: 9000
  bucketName: filestorebucket #存储桶名称
  accessKey: admin #访问的key
  secretKey: adminadmin  #访问的秘钥
  secure: false

将配置文件中 minio 的配置信息通过注解的方式注入到 MinioProp ，方便后续使用

/**
 * minio 属性值
 */
@Data
@Component
@ConfigurationProperties(prefix = "minio")
public class MinioProp {
    /**
     * 连接url
     */
    private String endpoint;
    /**
     * 端口
     */
    private String port;
    /**
     * 存储桶名称
     */
    private String bucketName;
    /**
     * 用户名
     */
    private String accesskey;
    /**
     * 密码
     */
    private String secretKey;

    
    private String secure;
}

核心配置类

/**
 * 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();
    }
}

2、示例代码

工具类

/**
 * Minio工具类
 *
 * @author wh
 * @version 1.0.0
 */
@Slf4j
@Component
public class MinioUtils {


    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");

    @Value("${minio.bucketName}")
    private String BUCKET_NAME;
    @Value("${minio.endpoint}")
    private String ENDPOINT;
    @Resource
    public MinioClient minioClient;


    /**
     * 判断桶是否存在
     *
     * @param bucketName bucket名称
     * @return true存在，false不存在
     */
    public Boolean bucketExists(String bucketName) {
        try {
            return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            throw new RuntimeException("检查桶是否存在失败!", e);
        }
    }

    /**
     * 创建bucket
     *
     * @param bucketName bucket名称
     */
    public void createBucket(String bucketName) {
        if (this.bucketExists(bucketName)) {
            log.info("存储桶已经存在！");
        } else {
            try {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            } catch (Exception e) {
                throw new RuntimeException("创建桶失败!", e);
            }
        }
    }

    /**
     * 创建只读bucket
     *
     * @param bucketName bucket名称
     */
    public void createReadOnlyBucket(String bucketName) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        if (this.bucketExists(bucketName)) {
            log.info("存储桶已经存在！");
        } else {
            //创建存储桶并设置只读权限
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            BucketPolicyConfig bucketPolicyConfig = createBucketPolicyConfig(bucketName);
            SetBucketPolicyArgs setBucketPolicyArgs = SetBucketPolicyArgs.builder()
                    .bucket(bucketName)
                    .config(JSONObject.toJSONString(bucketPolicyConfig))
                    .build();
            minioClient.setBucketPolicy(setBucketPolicyArgs);
        }
    }

    private BucketPolicyConfig createBucketPolicyConfig(String bucketName) {
        BucketPolicyConfig.Statement statement = BucketPolicyConfig.Statement.builder()
                .Effect("Allow")
                .Principal("*")
                .Action("s3:GetObject")
                .Resource("arn:aws:s3:::" + bucketName + "/*.**").build();
        return BucketPolicyConfig.builder()
                .Version("2012-10-17")
                .Statement(Collections.singletonList(statement))
                .build();
    }

    /**
     * 上传MultipartFile文件到全局默认文件桶中
     *
     * @param file 文件
     * @return 文件对应的URL
     */
    public String putObject(MultipartFile file) {

        // 给文件名添加时间戳防止重复
        String fileName = FileUtil.renFileName(Objects.requireNonNull(file.getOriginalFilename()));

        String objectName = sdf.format(new Date()) + "/" + fileName;
        // 开始上传
        this.putMultipartFile(BUCKET_NAME, objectName, file);
        log.info("文件上传成功!");
        return objectName;
    }

    /**
     * 上传文件
     *
     * @param fileName    文件名
     * @param stream      文件流
     * @param contentType 文件类型, 例如 image/jpeg: jpg图片格式, 点击查看: <a href="https://www.runoob.com/http/http-content-type.html">图片格式</a>
     * @return 文件url
     */
    public String putObject(@NotNull String fileName, @NotNull InputStream stream, @NotNull String contentType) throws ServerException, InsufficientDataException, ErrorResponseException, IOException, NoSuchAlgorithmException, InvalidKeyException, InvalidResponseException, XmlParserException, InternalException {
        this.createReadOnlyBucket(BUCKET_NAME);
        // 给文件名添加时间戳防止重复
        String objectName = sdf.format(new Date()) + "/" + FileUtil.renFileName(fileName);
        // 开始上传
        this.putInputStream(BUCKET_NAME, objectName, stream, contentType);
        return ENDPOINT + "/" + BUCKET_NAME + "/" + objectName;
    }

    /**
     * 上传bytes文件
     *
     * @param fileName    文件名
     * @param bytes       字节
     * @param contentType 文件类型, 例如 image/jpeg: jpg图片格式, 点击查看: <a href="https://www.runoob.com/http/http-content-type.html">图片格式</a>
     * @return 文件url
     */
    public String putObject(String fileName, byte[] bytes, String contentType) {
        // 给文件名添加时间戳防止重复
        String objectName = sdf.format(new Date()) + "/" + FileUtil.renFileName(fileName);
        // 开始上传
        this.putBytes(BUCKET_NAME, objectName, bytes, contentType);
        return ENDPOINT + "/" + BUCKET_NAME + "/" + objectName;
    }

    /**
     * 上传MultipartFile文件到指定的文件桶下
     *
     * @param bucketName 桶名称
     * @param file       文件
     * @return 文件对应的URL
     */
    public String putObject(String bucketName, String fileName, MultipartFile file) {
        // 先创建桶
        this.createBucket(bucketName);

        // 给文件名添加时间戳防止重复
        String objectName = sdf.format(new Date()) + "/" + FileUtil.renFileName(fileName);
        // 开始上传
        this.putMultipartFile(BUCKET_NAME, objectName, file);
        log.info("文件上传成功!");
        return ENDPOINT + "/" + BUCKET_NAME + "/" + objectName;
    }

    /**
     * 上传流到指定的文件桶下
     *
     * @param bucketName  桶名称
     * @param fileName    文件名称, 如果要带文件夹请用 / 分割, 例如 /help/index.html
     * @param stream      文件流
     * @param contentType 文件类型, 例如 image/jpeg: jpg图片格式, 点击查看: <a href="https://www.runoob.com/http/http-content-type.html">图片格式</a>
     * @return 文件对应的URL
     */
    public String putObject(String bucketName, String fileName, InputStream stream, String contentType) {
        // 先创建桶
        this.createBucket(bucketName);
        // 给文件名添加时间戳防止重复
        String objectName = sdf.format(new Date()) + "/" + FileUtil.renFileName(fileName);
        // 开始上传
        this.putInputStream(bucketName, objectName, stream, contentType);
        return ENDPOINT + "/" + bucketName + "/" + objectName;
    }

    /**
     * 上传流到指定的文件桶下
     *
     * @param bucketName  桶名称
     * @param fileName    文件名称, 如果要带文件夹请用 / 分割, 例如 /help/index.html
     * @param bytes       字节
     * @param contentType 文件类型, 例如 image/jpeg: jpg图片格式, 点击查看: <a href="https://www.runoob.com/http/http-content-type.html">图片格式</a>
     * @return 文件对应的URL
     */
    public String putObject(String bucketName, String fileName, byte[] bytes, String contentType) {
        // 先创建桶
        this.createBucket(bucketName);
        // 给文件名添加时间戳防止重复
        String objectName = sdf.format(new Date()) + "/" + FileUtil.renFileName(fileName);
        // 开始上传
        this.putBytes(bucketName, objectName, bytes, contentType);
        return ENDPOINT + "/" + bucketName + "/" + objectName;
    }

    /**
     * 上传File文件到默认桶下
     *
     * @param fileName    文件名
     * @param file        文件
     * @param contentType 文件类型, 例如 image/jpeg: jpg图片格式, 点击查看: <a href="https://www.runoob.com/http/http-content-type.html">图片格式</a>
     * @return 文件对应的URL
     */
    public String putObject(String fileName, File file, String contentType) {

        // 给文件名添加时间戳防止重复
        String objectName = sdf.format(new Date()) + "/" + FileUtil.renFileName(fileName);
        // 开始上传
        this.putFile(BUCKET_NAME, objectName, file, contentType);
        return ENDPOINT + "/" + BUCKET_NAME + "/" + objectName;
    }

    /**
     * 上传File文件
     *
     * @param bucketName  文件桶
     * @param objectName  文件名
     * @param file        文件
     * @param contentType 文件类型, 例如 image/jpeg: jpg图片格式, 点击查看: <a href="https://www.runoob.com/http/http-content-type.html">图片格式</a>
     * @return 文件对应的URL
     */
    public String putObject(String bucketName, String objectName, File file, String contentType) {
        // 先创建桶
        this.createBucket(bucketName);
        // 给文件名添加时间戳防止重复
        String fileName = FileUtil.renFileName(objectName);
        // 开始上传
        this.putFile(bucketName, fileName, file, contentType);
        return ENDPOINT + "/" + bucketName + "/" + fileName;
    }

    /**
     * 判断文件是否存在
     *
     * @param objectName 文件名称, 如果要带文件夹请用 / 分割, 例如 /help/index.html
     * @return true存在, 反之
     */
    public Boolean checkFileIsExist(String objectName) {
        return this.checkFileIsExist(BUCKET_NAME, objectName);
    }

    /**
     * 判断文件夹是否存在
     *
     * @param folderName 文件夹名称
     * @return true存在, 反之
     */
    public Boolean checkFolderIsExist(String folderName) {
        return this.checkFolderIsExist(BUCKET_NAME, folderName);
    }

    /**
     * 判断文件是否存在
     *
     * @param bucketName 桶名称
     * @param objectName 文件名称, 如果要带文件夹请用 / 分割, 例如 /help/index.html
     * @return true存在, 反之
     */
    public Boolean checkFileIsExist(String bucketName, String objectName) {
        try {
            minioClient.statObject(
                    StatObjectArgs.builder().bucket(bucketName).object(objectName).build()
            );
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    /**
     * 判断文件夹是否存在
     *
     * @param bucketName 桶名称
     * @param folderName 文件夹名称
     * @return true存在, 反之
     */
    public Boolean checkFolderIsExist(String bucketName, String folderName) {
        try {
            Iterable<Result<Item>> results = minioClient.listObjects(
                    ListObjectsArgs
                            .builder()
                            .bucket(bucketName)
                            .prefix(folderName)
                            .recursive(false)
                            .build());
            for (Result<Item> result : results) {
                Item item = result.get();
                if (item.isDir() && folderName.equals(item.objectName())) {
                    return true;
                }
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    /**
     * 根据文件全路径获取文件流
     *
     * @param objectName 文件名称
     * @return 文件流
     */
    public InputStream getObject(String objectName) {
        return this.getObject(BUCKET_NAME, objectName);
    }

    /**
     * 根据文件桶和文件全路径获取文件流
     *
     * @param bucketName 桶名称
     * @param objectName 文件名
     * @return 文件流
     */
    public InputStream getObject(String bucketName, String objectName) {
        try {
            return minioClient
                    .getObject(GetObjectArgs.builder().bucket(bucketName).object(objectName).build());
        } catch (Exception e) {
            throw new RuntimeException("根据文件名获取流失败!", e);
        }
    }

    /**
     * 根据url获取文件流
     *
     * @param url 文件URL
     * @return 文件流
     */
    public InputStream getObjectByUrl(String url) {
        try {
            return new URL(url).openStream();
        } catch (IOException e) {
            throw new RuntimeException("根据URL获取流失败!", e);
        }
    }

    /**
     * 获取全部bucket
     *
     * @return 所有桶信息
     */
    public List<Bucket> getAllBuckets() {
        try {
            return minioClient.listBuckets();
        } catch (Exception e) {
            throw new RuntimeException("获取全部存储桶失败!", e);
        }
    }

    /**
     * 根据bucketName获取信息
     *
     * @param bucketName bucket名称
     * @return 单个桶信息
     */
    public Optional<Bucket> getBucket(String bucketName) {
        try {
            return minioClient.listBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
        } catch (Exception e) {
            throw new RuntimeException("根据存储桶名称获取信息失败!", e);
        }
    }

    /**
     * 根据bucketName删除信息
     *
     * @param bucketName bucket名称
     */
    public void removeBucket(String bucketName) {
        try {
            minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            throw new RuntimeException("根据存储桶名称删除桶失败!", e);
        }
    }

    /**
     * 删除文件
     *
     * @param objectName 文件名称
     */
    public boolean removeObject(String objectName) {
        try {
            this.removeObject(BUCKET_NAME, objectName);
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    /**
     * 删除文件
     *
     * @param bucketName bucket名称
     * @param objectName 文件名称
     */
    public boolean removeObject(String bucketName, String objectName) {
        try {
            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    /**
     * 上传MultipartFile通用方法
     *
     * @param bucketName 桶名称
     * @param objectName 文件名
     * @param file       文件
     */
    private void putMultipartFile(String bucketName, String objectName, MultipartFile file) {
        InputStream stream = null;
        try {
            stream = file.getInputStream();
        } catch (IOException e) {
            throw new RuntimeException("文件流获取错误", e);
        }
        try {
            minioClient.putObject(
                    PutObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .contentType(file.getContentType())
                            .stream(stream, stream.available(), -1)
                            .build()
            );
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("文件流上传错误", e);
        }
    }

    /**
     * 上传InputStream通用方法
     *
     * @param bucketName 桶名称
     * @param objectName 文件名
     * @param stream     文件流
     */
    private void putInputStream(String bucketName, String objectName, InputStream stream, String contentType) {
        try {
            minioClient.putObject(
                    PutObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .contentType(contentType)
                            .stream(stream, stream.available(), -1)
                            .build()
            );
        } catch (Exception e) {
            throw new RuntimeException("文件流上传错误", e);
        }
    }

    /**
     * 上传 bytes 通用方法
     *
     * @param bucketName 桶名称
     * @param objectName 文件名
     * @param bytes      字节编码
     */
    private void putBytes(String bucketName, String objectName, byte[] bytes, String contentType) {
        // 字节转文件流
        InputStream stream = new ByteArrayInputStream(bytes);
        try {
            minioClient.putObject(
                    PutObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .contentType(contentType)
                            .stream(stream, stream.available(), -1)
                            .build()
            );
        } catch (Exception e) {
            throw new RuntimeException("文件流上传错误", e);
        }
    }

    /**
     * 上传 file 通用方法
     *
     * @param bucketName  桶名称
     * @param objectName  文件名
     * @param file        文件
     * @param contentType 文件类型, 例如 image/jpeg: jpg图片格式, 点击查看: <a href="https://www.runoob.com/http/http-content-type.html">图片格式</a>
     */
    private void putFile(String bucketName, String objectName, File file, String contentType) {
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            minioClient.putObject(
                    PutObjectArgs.builder()
                            .bucket(bucketName)
                            .object(objectName)
                            .contentType(contentType)
                            .stream(fileInputStream, fileInputStream.available(), -1)
                            .build()
            );
        } catch (Exception e) {
            throw new RuntimeException("文件上传错误", e);
        }
    }


    /**
     * 获取文件信息, 如果抛出异常则说明文件不存在
     *
     * @param bucketName bucket名称
     * @param objectName 文件名称
     * @throws Exception <a href="https://docs.minio.io/cn/java-client-api-reference.html#statObject">官方异常信息</a>
     */
    public StatObjectResponse getObjectInfo(String bucketName, String objectName) throws Exception {
        return minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
    }

    /**
     * 获取文件外链
     *
     * @param bucketName bucket名称
     * @param objectName 文件名称
     * @param expires    过期时间 <=7
     * @return url
     */
    @SneakyThrows
    public String getObjectURL(String bucketName, String objectName, Integer expires) {
        return getObjectURL(bucketName, objectName, expires, Method.GET);
    }

    /**
     * 获取文件外链
     *
     * @param bucketName bucket名称
     * @param objectName 文件名称
     * @param expires    过期时间 <=7
     * @return url
     */
    @SneakyThrows
    public String getObjectURL(String bucketName, String objectName, Integer expires, Method method) {
        Boolean aBoolean = checkFileIsExist(bucketName, objectName);
        if (!aBoolean) {
            throw new RuntimeException("文件不存在！");
        }
        IntFunction<Integer> integerIntFunction = (int i) -> Math.min(i, 7);
        return minioClient.getPresignedObjectUrl(
                GetPresignedObjectUrlArgs.builder()
                        .method(method)
                        .bucket(bucketName)
                        .object(objectName)
                        .expiry(integerIntFunction.apply(expires), TimeUnit.HOURS)
                        .build());
    }

    /**
     * 获取文件外链
     *
     * @param objectName 文件名称
     * @param expires    过期时间 <=7
     * @return url
     */
    @SneakyThrows
    public String getObjectURL(String objectName, Integer expires) {
        return getObjectURL(BUCKET_NAME, objectName, expires);
    }

    /**
     * 获取文件外链
     *
     * @param objectName 文件名称
     * @return url
     */
    @SneakyThrows
    public String getObjectURL(String objectName) {
        return getObjectURL(BUCKET_NAME, objectName, 1);
    }

    /**
     * 根据文件前置查询文件
     *
     * @param bucketName bucket名称
     * @param prefix     前缀
     * @param recursive  是否递归查询
     * @return MinioItem 列表
     */
    @SneakyThrows
    public List<Item> getAllObjectsByPrefix(String bucketName, String prefix, boolean recursive) {
        List<Item> list = new ArrayList<>();
        Iterable<Result<Item>> objectsIterator = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).prefix(prefix)
                        .recursive(recursive).build()
        );
        if (objectsIterator != null) {
            for (Result<Item> result : objectsIterator) {
                Item item = result.get();
                list.add(item);
            }
        }
        return list;
    }

}


public class FileUtil {
    /**
     * 生成唯一ID
     *
     * @param objectName 文件名
     * @return 唯一ID
     */
    public static String renFileName(String objectName) {
        //判断文件最后一个点所在的位置
        int lastIndexOf = objectName.lastIndexOf(".");
        if (lastIndexOf == -1) {
            return String.format("%s_%s", objectName, System.currentTimeMillis());
        } else {
            // 获取文件前缀,已最后一个点进行分割
            String filePrefix = objectName.substring(0, objectName.lastIndexOf("."));
            // 获取文件后缀,已最后一个点进行分割
            String fileSuffix = objectName.substring(objectName.lastIndexOf(".") + 1);
            // 组成唯一文件名
            return String.format("%s_%s.%s", filePrefix, System.currentTimeMillis(), fileSuffix);
        }
    }
}

/**
 * Minio Bucket访问策略配置
 * Created by macro on 2020/8/11.
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Builder
public class BucketPolicyConfig {

    private String Version;
    private List<Statement> Statement;

    @Data
    @EqualsAndHashCode(callSuper = false)
    @Builder
    public static class Statement {
        private String Effect;
        private String Principal;
        private String Action;
        private String Resource;

    }
}

MinioController(控制层)

/**
 * MinIO对象存储管理
 */
@Controller
@Slf4j
@RequestMapping("/minio")
public class MinioController{

    @Resource
    private MinioUtils minioUtils;


    /**
     * 文件上传
     *
     * @param file
     * @return
     */
    @PostMapping(value = "/upload")
    @ResponseBody
    public Map<String, String> upload(@RequestPart("file") MultipartFile file) {
        try {
            String url = minioUtils.putObject(file);
            Map<String, String> map = new HashMap<>();
            String fileName = file.getOriginalFilename();
            map.put("fileName", fileName);
            map.put("objName", url);
            return map;
        } catch (Exception e) {
            e.printStackTrace();
            log.info("上传发生错误: {}！", e.getMessage());
            throw e;
        }
    }


    /**
     * 文件删除
     *
     * @param objectName
     * @return
     */
    @PostMapping(value = "/delete")
    @ResponseBody
    public boolean delete(@RequestParam("objectName") String objectName) {
        try {
            minioUtils.removeObject(objectName);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }


    /**
     * 文件预览
     *
     * @param objectName 对象名称
     * @return 文件访问连接
     */
    @GetMapping(value = "/preview")
    @ResponseBody
    public String preview(@RequestParam("objectName") String objectName) {
        Boolean aBoolean = minioUtils.checkFileIsExist(objectName);
        if (!aBoolean) {
            return "文件不存在！";
        }
        return minioUtils.getObjectURL(objectName);
    }

    /**
     * 文件下载
     *
     * @param objectName 对象名称
     * @return 文件流
     */
    @GetMapping(value = "/download")
    @ResponseBody
    public void download(@RequestParam("objectName") String objectName, HttpServletResponse response) throws IOException {
        try {
            Boolean aBoolean = minioUtils.checkFileIsExist(objectName);
            if (!aBoolean) {
                response.setHeader("Content-type", "text/html;charset=UTF-8");
                String data = "文件下载失败";
                OutputStream ps = response.getOutputStream();
                ps.write(data.getBytes(StandardCharsets.UTF_8));
                return;
            }

            InputStream object = minioUtils.getObject(objectName);
            byte[] buf = new byte[1024];
            int length;
            response.reset();
            response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(objectName.substring(objectName.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 e) {
            response.setHeader("Content-type", "text/html;charset=UTF-8");
            String data = "文件下载失败";
            OutputStream ps = response.getOutputStream();
            ps.write(data.getBytes(StandardCharsets.UTF_8));
        }

    }
}

上传测试
在这里插入图片描述
删除测试
在这里插入图片描述

获取文件/预览地址
在这里插入图片描述

我好帅啊~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
minIo详细步骤介绍
weixin_52028697的博客
08-02 2208
对于项目的文件存储可以使用像阿里云、腾讯云这种平台的服务，当然也可以自己搭建一个文件管理系统。先根据官网地址进行下载MinIo的server端和client端下载好后，将server client端放到一个你想放的文件夹，本文以路径放置，并创建了一个文件夹来作为server端启动时指定的路径，如图：在此路径下进入cmd窗口，输入如下命令当出现这样就说明你的minio启动正常，选择你的浏览器输入,会自动跳转到minio控制台界面。出现页面登录的时候都输入minioadmin即可。...............
MinIO获取ACCESS_KEY以及SECRET_KEY
qq_33906471的博客
05-20 3697
在我们对MinIO操作的时候会用到ACCESS_KEY以及SECRET_KEY但是这两个怎么获取呢，接下来的文章就给大家介绍一下。
关于初始化Minio时报错`Invalid endPoint : http://127.0.0.1:9000/minio`
xinleicol的博客
04-14 8128
关于初始化Minlo时报错Invalid endPoint : http://127.0.0.1:9000/minio 0 问题 初学Minlo，想通过代码操作客户端连接Minlo进行文件上传，初始化JS代码如下： var minioClient = new Minio.Client({ endPoint: 'http://127.0.0.1:9000/minio', port: 9000, useSSL: false, accessKey:
大数据之minio简单使用
机长红猪
09-15 950
简介 架构 安装 方式一：离线安装 创建minio目录 mkdir /opt/software/minio && cd /opt/software/minio 下载安装包 wget http://dl.minio.org.cn/server/minio/release/linux-amd64/minio wget https://dl.min.io/client/mc/release/linux-amd64/mc 赋执行权限 chmod +x minio mc 创建启动
菜鸟关于SpringBoot配置MinIo的一些疑惑问题的记录
LongJ_Sir的博客
06-10 1727
菜鸟了解@Autowired
linux查看minio版本
04-13
在Linux操作系统中，管理和操作MinIO这种分布式对象存储服务时，了解其版本信息至关重要，因为这有助于确保系统安全、性能优化以及及时应用更新。MinIO是一款开源的对象存储服务器，广泛用于存储大规模的数据，如云...
minio图片上传Demo
09-19
MinIO是一款开源的对象存储系统，它支持S3 API，可以用于存储和检索大量的非结构化数据，如图片、文档和视频等。Vue.js是一个流行的前端JavaScript框架，常用于构建用户界面。结合这两个技术，我们可以创建一个图片...
Centos7搭建minio分布式集群
10-27
MinIO是一款开源的对象存储服务，它提供了与Amazon S3兼容的API，适用于大规模数据存储和备份。在CentOS 7上搭建MinIO分布式集群是一项重要的IT任务，这将帮助我们构建一个可扩展、高可用的云存储解决方案。下面将...
MinIO部署文件、文档
07-26
MinIO是一款开源的对象存储系统，特别适用于大数据和云计算环境中的数据存储与管理。它提供了高性能、安全性以及S3兼容的接口，使得用户可以方便地在本地或云端部署大规模的存储集群。下面我们将深入探讨MinIO的部署...
minio基本使用，minio基本使用，minio基本使用
03-24
MinIO是一款开源的对象存储系统，它提供类似Amazon S3的云存储服务，适用于大数据、人工智能、备份、归档等场景。MinIO的核心特性包括高性能、安全性、可扩展性以及跨平台支持。本篇文章将深入探讨MinIO的基本使用，...
MinIO存储在docker中安装及其使用
itboy
12-15 6998
MinIO MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。 MinIO是一个非常轻量的服务,可以很简单的和其他应用的结合，类似 NodeJS, Redis 或者 MySQL 一、doc...
springboot(3.2.5)初步集成MinIO(8.5.9)开发记录
缘友一世的博客
05-07 512
【代码】springboot(3.2.5)初步集成MinIO(8.5.9)开发记录。
Minio控制台详细教程
HoJe的博客
03-05 2万+
此文讲解Minio控制台详细教程，可能会涉及到有些知识大家可能不懂情况。需要知道Minio兼容的是AMS S3对象存储服务。需要知道AMS S3对象存储服务是什么，里面涉及的到配置如何去配等等。
Minio工具类
weixin_43148691的博客
09-17 8690
引入Maven依赖 <dependency> <groupId>io.minio</groupId> <artifactId>minio</artifactId> <version>8.3.0</version> </dependency> 配置文件 ## ====================== ↓↓↓↓↓↓ MinIO文件服务器 ↓↓↓↓↓↓ =====================
minio安装部署及使用
m0_67401761的博客
07-28 2554
这一步，我们将配置文件中minio的配置信息通过注解的方式注入到MinioProp这个实体中，方便后面我们使用。通过注入MinIO服务器的相关配置信息，得到MinioClient对象，我们上传文件依赖此对象。进行创建桶，名字自取，创建完成后服务器home/minio/data下也会创建这个文件目录。地址http//127.0.0.19000。PostMan进行测试上传;默认的端口为9000。后台启动，并打印日志。...
MinIO安装、部署、开发文档、完整API参考文档
热门推荐
算命de博客
06-05 2万+
目录 微软Windows系统 下载二进制文件 GNU/Linux 下载二进制文件 最低需求 使用maven 使用gradle 直接下载JAR 快速入门示例－文件上传 API文档 初始化Minio Client object。 MinIO AWS S3 1. 构造函数 MinIO AWS S3 2. 存储桶操作 makeBucket(String bucketName) listBuckets() bucketExists(String bucketName) .
Springboot整合 Minio
qq_45597391的博客
05-21 580
文章目录前言下载 [官网地址](https://min.io/)依赖配置类（application.yml）MinioConfigMinIoPropertiesMinioUtils使用（MinIoController） 前言 对象存储服务OSS（Object Storage Service）是一种海量、安全、低成本、高可靠的云存储服务，适合存放任意类型的文件。容量和处理能力弹性扩展，多种存储类型供选择，全面优化存储成本。 下载 官网地址 下载完成后，启动minio 运行 .\minio.exe server
MinIO安装以及使用
Map的博客
09-10 1万+
1.Minio介绍 MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从数KB到最大5TB都能很好的支持。开源并且用Go语言开发，有web操作界面，我们可以用它来搭建兼容S3协议的存储云服务。相比 hadoop hdfs 分布式存储服务轻量很多，且支持单节点部署。 SDK（API）: 官方安装文档，MinIO提供了很多语言的SDK跟API支持：java
minio fastdfs
最新发布
07-28
Minio 和 FastDFS 都是用于文件存储的分布式系统，但它们属于不同的技术栈。 Minio 是一个开源的对象存储服务，它提供了类似于 Amazon S3 的 API，可以用于云存储、备份、静态网站托管等场景。Minio 简单易用，支持多种数据冗余策略，并且有高度的可扩展性和自定义选项，可以在本地、云端或混合环境中部署。 FastDFS（Fast Distributed File System），则是由腾讯开源的一款分布式文件存储系统，主要用于处理大规模的图片、视频等二进制文件。FastDFS 将文件划分为“组”和“块”，通过 C/S 架构提供高效上传、下载和管理，特别适合高并发的文件访问需求，如网站静态资源管理。 两者的比较： 1. **功能侧重点**：Minio 更侧重于对象存储，支持更复杂的 API 和数据管理；而 FastDFS 更关注文件分块存储，特别是对大文件的高效传输。 2. **应用场景**：Minio 更适合需要长期保存大量结构化或非结构化数据的应用；FastDFS 则适用于对文件访问速度有较高要求，比如图片分享网站或移动应用。 3. **开源社区**：Minio 社区活跃，API 完善；FastDFS 起源于腾讯内部，适合对稳定性和性能有特殊要求的环境。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我好帅啊~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值