docker安装minio，springboot操作minio上传下载

35岁回家种地

已于 2022-12-27 18:15:27 修改

阅读量747

点赞数

分类专栏： docker SpringBoot 文章标签： docker linux 运维 spring spring boot

于 2022-09-01 17:13:40 首次发布

本文链接：https://blog.csdn.net/mvcvsstruts/article/details/126640180

版权

docker 同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

SpringBoot

2 篇文章 0 订阅

订阅专栏

1、下载镜像
下载指定版本需要去版本库查询下 https://hub.docker.com/r/minio/minio/tags

#下载最新版
docker pull minio/minio  
docker pull minio/minio:RELEASE.2019-12-30T05-45-39Z

2、启动
这里会有不同版本的问题

22版以后的启动命令：

docker run -p 9000:9000 -p 9001:9001 --name minio \
-d --restart=always \
-e "MINIO_ROOT_USER=minioadmin" \ 账号
-e "MINIO_ROOT_PASSWORD=minioadmin" \ 密码
-v /opt/docker_minio/data:/data \  数据挂载地址
-v /opt/docker_minio/config:/root/.minio \  配置文件挂载地址
minio/minio:RELEASE.2022-01-08T03-11-54Z server /data \  版本号地址
--console-address ":9000" --address ":9001"  监控端口

22版以前的启动命令

docker run -p 8900:9000 --name minio2019 \
-d --restart=always \
-e "MINIO_ACCESS_KEY=minioadmin" \
-e "MINIO_SECRET_KEY=minioadmin" \
-v /opt/docker_minio/data:/data \
-v /opt/docker_minio/config:/root/.minio \
minio/minio:RELEASE.2019-12-30T05-45-39Z server /data \
--address ":9000"

3.验证
ip+端口
在这里插入图片描述
这里也分为两种版本的jar包，整体区别不大。
**

旧版

**
1.引入jar

		<!--minio-->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>7.0.2</version>
        </dependency>

2.创建连接配置


import io.minio.MinioClient;

import javax.crypto.SecretKey;
import java.io.InputStream;

import java.security.KeyPair;


 public interface MinioClientService {

    /**
     * 获取连接
     * @return
     */
     MinioClient getClient();
    /**
     * 以流的形式下载一个对象。
     */
       void getFileInputStream(String fileName);

    /**
     * 下载对象指定区域的字节数组做为流。（断点下载）
     * @param fileName
     * @param offset 是起始字节的位置
     * @param length 是要读取的长度 (可选，如果无值则代表读到文件结尾)。
     */
       void getFileInputStream(String fileName, Long offset, Long length);

    /**
     * 下载并将文件保存到本地。
     * @param fileName 目标名
     * @param downloadFileName 下载文件名
     */
      void getLocalFile(String fileName,String downloadFileName);

    /**
     * 在给定的存储桶中获取整个加密对象的数据作为InputStream，然后用传入的master key解密和加密对象关联的content key。
     * 然后创建一个含有InputStream和Cipher的CipherInputStream。这个Cipher被初始为用于使用content key进行解密，
     * 所以CipherInputStream会在返回数据前，尝试读取数据并进行解密。所以read()方法返回的是处理过的原始对象数据。
     * CipherInputStream必须用完关闭，否则连接不会被释放。
     * @param fileName
     * @param key  SecretKey类型的数据。
     */
    void getMasterKeyFile( String fileName, SecretKey key);

    /**
     * 在给定的存储桶中获取整个加密对象的数据作为InputStream，然后用传入的master keyPair解密和加密对象关联的content key。
     * 然后创建一个含有InputStream和Cipher的CipherInputStream。这个Cipher被初始为用于使用content key进行解密，
     * 所以CipherInputStream会在返回数据前，尝试读取数据并进行解密。所以read()方法返回的是处理过的原始对象数据。
     *
     * CipherInputStream必须用完关闭，否则连接不会被释放。
     * @param fileName
     * @param key
     */

    void getKeyPairFile(String fileName, KeyPair key);

    /**
     * 上传文件到桶-流
     * @param stream
     * @param
     * @return
     */
    String putFileForInputStream(String fileName, InputStream stream);

    /**
     * 获取连接前缀名称（到文件夹桶）
     * @return
     */
    String getClientPrefix();


}

import io.minio.MinioClient;
import io.minio.PutObjectOptions;
import io.minio.ServerSideEncryption;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;

@Configuration
public class MinioClientServiceImpl implements MinioClientService {


    @Value("${minio.url}")
    public  String url;

    @Value("${minio.userName}")
    public  String userName;

    @Value("${minio.password}")
    public  String password;

    @Value("${minio.bucketName}")
    public  String bucketName;

    /**
     * 获取连接
     * @return
     */
    @Override
    public  MinioClient getClient(){
        MinioClient minioClient = null ;
        try {
            // 使用MinIO服务的URL，端口，Access key和Secret key创建一个MinioClient对象
            minioClient = new MinioClient(url, userName, password);
            // 检查存储桶是否已经存在
            boolean isExist = minioClient.bucketExists(bucketName);
            if(!isExist) {
                // 创建一个名为asiatrip的存储桶，用于存储照片的zip文件。
                minioClient.makeBucket("weapon");
            }
        } catch(Exception e) {
            System.out.println("Error occurred: " + e);
        }
        return minioClient;
    }

    /**
     * 以流的形式下载一个对象。
     */
    @Override
    public   void getFileInputStream(String fileName){
        try {
            MinioClient minioClient =  getClient();
            // 调用statObject()来判断对象是否存在。
            // 如果不存在, statObject()抛出异常,
            // 否则则代表对象存在。
            minioClient.statObject(bucketName, fileName);

            /**
             * bucketName	String	存储桶名称。
             * objectName	String	存储桶里的对象名称。
             */
            InputStream stream = minioClient.getObject(bucketName, fileName);

            // 读取输入流直到EOF并打印到控制台。
            byte[] buf = new byte[16384];
            int bytesRead;
            while ((bytesRead = stream.read(buf, 0, buf.length)) >= 0) {
                System.out.println(new String(buf, 0, bytesRead));
            }

            // 关闭流，此处为示例，流关闭最好放在finally块。
            stream.close();
        } catch (Exception e) {
            System.out.println("Error occurred: " + e);
        }
    }

    /**
     * 下载对象指定区域的字节数组做为流。（断点下载）
     * @param fileName
     * @param offset 是起始字节的位置
     * @param length 是要读取的长度 (可选，如果无值则代表读到文件结尾)。
     */
    @Override
    public   void getFileInputStream(String fileName, Long offset, Long length){
        try {
            MinioClient minioClient =  getClient();
            // 调用statObject()来判断对象是否存在。
            // 如果不存在, statObject()抛出异常,
            // 否则则代表对象存在。
            minioClient.statObject(bucketName, fileName);

            // 获取指定offset和length的"myobject"的输入流。
            InputStream stream = minioClient.getObject(bucketName, fileName, offset, length);

            // 读取输入流直到EOF并打印到控制台。
            byte[] buf = new byte[16384];
            int bytesRead;
            while ((bytesRead = stream.read(buf, 0, buf.length)) >= 0) {
                System.out.println(new String(buf, 0, bytesRead));
            }
            // 关闭流。
            stream.close();
        } catch (Exception e) {
            System.out.println("Error occurred: " + e);
        }
    }

    /**
     * 下载并将文件保存到本地。
     * @param fileName 目标名
     * @param downloadFileName 下载文件名
     */
    @Override
    public  void getLocalFile(String fileName,String downloadFileName){
        try {
            MinioClient minioClient =  getClient();
            // 调用statObject()来判断对象是否存在。
            // 如果不存在, statObject()抛出异常,
            // 否则则代表对象存在。
            minioClient.statObject(bucketName, fileName);

            // 获取myobject的流并保存到photo.jpg文件中。
            minioClient.getObject(bucketName, fileName, downloadFileName);

        } catch (Exception e) {
            System.out.println("Error occurred: " + e);
        }
    }

    /**
     * 在给定的存储桶中获取整个加密对象的数据作为InputStream，然后用传入的master key解密和加密对象关联的content key。
     * 然后创建一个含有InputStream和Cipher的CipherInputStream。这个Cipher被初始为用于使用content key进行解密，
     * 所以CipherInputStream会在返回数据前，尝试读取数据并进行解密。所以read()方法返回的是处理过的原始对象数据。
     * CipherInputStream必须用完关闭，否则连接不会被释放。
     * @param fileName
     * @param key  SecretKey类型的数据。
     */
    @Override
    public  void getMasterKeyFile( String fileName, SecretKey key){
        try {
            MinioClient minioClient =  getClient();
            // 调用statObject()来判断对象是否存在。
            // 如果不存在, statObject()抛出异常,
            // 否则则代表对象存在。
            minioClient.statObject(bucketName, fileName);

            //生成256位AES key。
            KeyGenerator symKeyGenerator = KeyGenerator.getInstance("AES");
            symKeyGenerator.init(256);
            SecretKey symKey = symKeyGenerator.generateKey();

            // 获取对象数据并保存到photo.jpg
            InputStream stream = minioClient.getObject(bucketName, fileName, ServerSideEncryption.withCustomerKey(symKey));

            // 读流到EOF，并输出到控制台。
            byte[] buf = new byte[16384];
            int bytesRead;
            while ((bytesRead = stream.read(buf, 0, buf.length)) >= 0) {
                System.out.println(new String(buf, 0, bytesRead, StandardCharsets.UTF_8));
            }

            // 关闭流。
            stream.close();

        } catch (Exception e) {
            System.out.println("Error occurred: " + e);
        }
    }

    /**
     * 在给定的存储桶中获取整个加密对象的数据作为InputStream，然后用传入的master keyPair解密和加密对象关联的content key。
     * 然后创建一个含有InputStream和Cipher的CipherInputStream。这个Cipher被初始为用于使用content key进行解密，
     * 所以CipherInputStream会在返回数据前，尝试读取数据并进行解密。所以read()方法返回的是处理过的原始对象数据。
     *
     * CipherInputStream必须用完关闭，否则连接不会被释放。
     * @param fileName
     * @param key
     */
    @Override
    public  void getKeyPairFile(String fileName, KeyPair key){
        try {
            MinioClient minioClient =  getClient();
            // 调用statObject()来判断对象是否存在。
            // 如果不存在, statObject()抛出异常,
            // 否则则代表对象存在。
            minioClient.statObject("mybucket", "myobject");

            KeyPairGenerator keyGenerator = KeyPairGenerator.getInstance("RSA");
            keyGenerator.initialize(1024, new SecureRandom());
            KeyPair keypair = keyGenerator.generateKeyPair();

            // 获取对象数据并保存到photo.jpg
            //InputStream stream = minioClient.getObject("testbucket", "my-objectname", keypair);

            // 读流到EOF，并输出到控制台。
//            byte[] buf = new byte[16384];
//            int bytesRead;
//            while ((bytesRead = stream.read(buf, 0, buf.length)) >= 0) {
//                System.out.println(new String(buf, 0, bytesRead, StandardCharsets.UTF_8));
//            }
            // 关闭流。
            //stream.close();
        } catch (Exception e) {
            System.out.println("Error occurred: " + e);
        }
    }

    /**
     * 上传文件到桶-流
     * @param stream
     * @param
     * @return
     */
    @Override
    public  String putFileForInputStream(String fileName, InputStream stream){
        String urlName = null ;
        try {
            // 使用MinIO服务的URL，端口，Access key和Secret key创建一个MinioClient对象
            MinioClient minioClient = getClient();
            PutObjectOptions options = new PutObjectOptions(stream.available(), -1);
            minioClient.putObject(bucketName, fileName, stream, options);
            urlName =  "/"  +  fileName;
            stream.close();
        } catch(Exception e) {

        }
        return urlName;
    }

    @Override
    public String getClientPrefix() {
        return url+bucketName;
    }

//    public static void main(String[] args) {
//        /**
//         * 将 Json 形式的字符串转换为 Map
//         */
//        String str = "{\"name\":\"cy\",\"age\":22}";
//        JSONObject jsonObject = JSONObject.fromObject(str);
//        Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(jsonObject, Map.class);
//        System.out.println(map);
//
//        /**
//         * 将 Json 形式的字符串转换为 JavaBean
//         */
//        str = "{\"id\":\"100101\",\"name\":\"zhangsan\"}";
//        jsonObject = JSONObject.fromObject(str);
//        System.out.println(jsonObject);
//        Person person = (Person) JSONObject.toBean(jsonObject, Person.class);
//        System.out.println(person);
//    }


}

新版

maven

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

获取MinioClient

/**
     * 获取连接
     * @return
     */
    @Override
    public  MinioClient getClient(){
        MinioClient minioClient = null ;
        try {
            // 新版获取方式
            minioClient = MinioClient.builder()
                .endpoint(url)
                .credentials(userName, password)
                .build();
            // 检查存储桶是否已经存在
            boolean isExist = minioClient.bucketExists(bucketName);
            if(!isExist) {
                // 创建一个名为asiatrip的存储桶，用于存储照片的zip文件。
                minioClient.makeBucket("weapon");
            }
        } catch(Exception e) {
            System.out.println("Error occurred: " + e);
        }
        return minioClient;
    }

新版部分方法

/**
     * 创建bucket
     */
    public void createBucket(String bucketName) throws Exception {
        if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        }
    }

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

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

    /**
     * 上传文件
     *
     * @param file 文件名
     * @return
     */
    public String upload(String fileName,MultipartFile file) throws Exception {
        //判断文件是否为空
        if (null == file || 0 == file.getSize()) {
            return null;
        }
        //判断存储桶是否存在  不存在则创建
        createBucket(bucketName);
        //开始上传
        minioClient.putObject(
                PutObjectArgs.builder().bucket(bucketName).object(fileName).stream(
                        file.getInputStream(), file.getSize(), -1)
                        .contentType(file.getContentType())
                        .build());

        return "/"+fileName;
    }

    /**
     * 获取文件外链
     *
     * @param bucketName
     * @param region
     * @param fileName
     * @return
     */
    public String getObjectUrl(String bucketName, String region, String fileName) throws Exception {
        return minioClient.getPresignedObjectUrl(
                GetPresignedObjectUrlArgs.builder()
                        .method(Method.GET)
                        .bucket(bucketName)
                        .region(region)
                        .object(fileName)
                        .build());
    }

    /**
     * 删除⽂件
     *
     * @param bucketName bucket名称
     * @param objectName ⽂件名称
     */
    public void removeObject(String bucketName, String objectName) throws Exception {
        minioClient.removeObject(
                RemoveObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build()
        );
    }

yml配置文件

minio:
  url: http://192.168.1.242:9000/
  userName: ****
  password: ****
  bucketName: weapon

如果有些方法没有可以看一下官方全部的文档
http://docs.minio.org.cn/docs/master/java-client-quickstart-guide
minio官方文档

http://docs.minio.org.cn/docs/master/java-client-api-reference
minio官方API文档

spring的方式也是一样注册一个bean，配置minio参数。

35岁回家种地

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录