Minio分布式数据库使用

前言：当前需求是接收从设备传来的数据，其中的图片为base64字符串，首先需要将其转换为图片再保存再Minio中

安装Minio

https://dl.min.io/server/minio/release/windows-amd64/minio.exe

新建minio文件夹，并在该文件夹内shift+enter进入powershell界面

输入以下命令启动minio文件服务器

.\minio.exe server D:\minio --console-address ":9001" --address ":9000"

浏览器输入网址http://127.0.0.1:9001/browser

输入用户名和密码 minioadmin进入页面

新建桶

先建1个桶（buckets），点击create a bucket

取名 后点击create，Access policy权限改为public

 

引入依赖

    io.minio
    minio
    8.4.3

编写配置文件

安装minio时对外暴露的端口号为9001和9000，这里使用后面的9000进行连接，不然会报错

# 应用服务 WEB 访问端口
server:
  port: 11110

minio:
  url: http://127.0.0.1:9000
  accessKey: minioadmin
  secretKey: minioadmin
  bucketName: cutter

MinioConfig配置类

package com.example.miniotest.config;

import io.minio.MinioClient;
import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix = "minio")
@Getter
@Setter
/**
 * MiniO配置类
 * @author zhangzhi
 */
public class MinioConfig {
    /**
     * 服务地址
     */
    private String url;

    /**
     * 用户名
     */
    private String accessKey;

    /**
     * 密码
     */
    private String secretKey;

    /**
     * 存储桶名称
     */
    private String bucketName;


    @Bean
    public MinioClient getMinioClient()
    {
        return MinioClient.builder().endpoint(url).credentials(accessKey, secretKey).build();
    }
}

测试：

base64与图片转换工具类

返回值为：图片的输入流

package com.example.miniotest.utils;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.Base64;

/**
 * 图片和Base64字符串转换的工具类
 * @author 
 */
public class ImageUtils {

    /**
     * 图片转Base64字符串
     *
     * @param imageFileName
     * @return
     */
    public static String convertImageToBase64Str(String imageFileName) {
        ByteArrayOutputStream baos = null;
        try {
            //获取图片类型
            String suffix = imageFileName.substring(imageFileName.lastIndexOf(".") + 1);
            //构建文件
            File imageFile = new File(imageFileName);
            //通过ImageIO把文件读取成BufferedImage对象
            BufferedImage bufferedImage = ImageIO.read(imageFile);
            //构建字节数组输出流
            baos = new ByteArrayOutputStream();
            //写入流
            ImageIO.write(bufferedImage, suffix, baos);
            //通过字节数组流获取字节数组
            byte[] bytes = baos.toByteArray();
            //获取JDK8里的编码器Base64.Encoder转为base64字符
            return Base64.getEncoder().encodeToString(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (baos != null) {
                    baos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * Base64字符串转图片
     *
     * @param base64String
     * @param imageFileName
     */
    public static ByteArrayInputStream convertBase64StrToImage(String base64String, String imageFileName) {
        ByteArrayInputStream bais = null;
        try {
            //获取图片类型
            String suffix = imageFileName.substring(imageFileName.lastIndexOf(".") + 1);
            //获取JDK8里的解码器Base64.Decoder,将base64字符串转为字节数组
            byte[] bytes = Base64.getDecoder().decode(base64String);
            //构建字节数组输入流
            bais = new ByteArrayInputStream(bytes);
            //通过ImageIO把字节数组输入流转为BufferedImage
//            BufferedImage bufferedImage = ImageIO.read(bais);
//
//            System.out.println(bufferedImage);
//            //构建文件
//            File imageFile = new File(imageFileName);
//            //写入生成文件
//            ImageIO.write(bufferedImage, suffix, imageFile);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (bais != null) {
                    bais.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        return bais;
    }
}

图片上传逻辑代码：

图片名称：当前时间.jpg ，通过工具类将base64字符串转换为图片的输入流，并上传至minio，将当前图片的路径修改为设置的图片名称。

String image_base64Str = baseCutterImage.getImageByte();
String imageFileName = "";
imageFileName = DateUtil.format(Calendar.getInstance().getTime(), DatePattern.PURE_DATE_PATTERN)
        + IdUtil.getSnowflakeNextId() + ".jpg";
ByteArrayInputStream inputStream = null;
PutObjectArgs args = null;
inputStream = ImageUtils.convertBase64StrToImage(image_base64Str, imageFileName);
args = PutObjectArgs.builder()
        .bucket(minioConfig.getBucketName())
        .object(imageFileName)
        .stream(inputStream, inputStream.available(), -1)
        .build();
client.putObject(args);
//修改图片路径为文件名
baseCutterImage.setImageByte(imageFileName);

图片访问逻辑代码：

通过图片名称来从minio获取图片的真实存储路径，并更新当前图片路径

//访问minio 修改图片的URL地址
        GetPresignedObjectUrlArgs args = null;
        for (CutterImageVO cutterImageVO : cutterImageVOS) {
            try {
                args = GetPresignedObjectUrlArgs.builder()
                        .bucket(minioConfig.getBucketName())
                        .object(cutterImageVO.getImageUrl())
                        .expiry(1, TimeUnit.DAYS)
                        .method(Method.GET)
                        .build();
                cutterImageVO.setImageUrl(client.getPresignedObjectUrl(args));
            }catch (Exception e) {
                e.printStackTrace();
            }
        }