MinIO的安装与使用

MinIO的安装与使用

一、MinIO是什么？二、MinIO安装（centos7）2.1 下载MinIO2.2 启动MinIO2.3 修改配置2.4 编写启动脚本，以及加入到systemctl中 三、Springboot集成MinIO3.1 项目应用 四、Java中图片压缩上传4.1 背景4.2 开发准备4.3 压缩上传 五、MinIO集群搭建（完善中~）

一、MinIO是什么？

MinIO 是一款高性能、分布式的对象存储系统. 它是一款软件产品, 可以100%的运行在标准硬件。即X86等低成本机器也能够很好的运行MinIO。

MinIO与传统的存储和其他的对象存储不同的是：它一开始就针对性能要求更高的私有云标准进行软件架构设计。因为MinIO一开始就只为对象存储而设计。所以他采用了更易用的方式进行设计，它能实现对象存储所需要的全部功能，在性能上也更加强劲，它不会为了更多的业务功能而妥协，失去MinIO的易用性、高效性。 这样的结果所带来的好处是：它能够更简单的实现局有弹性伸缩能力的原生对象存储服务。

MinIO在传统对象存储用例（例如辅助存储，灾难恢复和归档）方面表现出色。同时，它在机器学习、大数据、私有云、混合云等方面的存储技术上也独树一帜。当然，也不排除数据分析、高性能应用负载、原生云的支持。

MinIO主要采用Golang语言实现，，客户端与存储服务器之间采用http/https通信协议。

它与 Amazon S3 云存储服务 API 兼容

MinIO的相关信息

中文官网: http://www.minio.org.cn/
中文文档: http://docs.minio.org.cn/docs/
中文下载地址：http://www.minio.org.cn/download.shtml#/linux
英文官网: https://min.io/
英文文档: https://docs.min.io/
英文下载地址：https://min.io/download#/linux
Github地址：https://github.com/minio/minio

二、MinIO安装（centos7）

2.1 下载MinIO

演示以官网下载二进制文件配置，下载地址见上方，，，，docker安装更简单哦~

#创建目录mkdir /usr/local/minio/cd /usr/local/minio/#下载并添加权限wget http://dl.minio.org.cn/server/minio/release/linux-amd64/minio#赋值权限chmod +x minio

2.2 启动MinIO

#创建数据目录，数据目录存储需要大点mkdir -p /home/data/minio#创建日志目录mkdir -p /home/data/minio/logtouch /home/data/minio/log/minio.log#前台启动minio./minio server /home/data/minio#后台启动minionohup ./minio server /home/data/minio > /home/data/minio/log/minio.log &# nohup端口自定义启动服务 指定文件存放路径 /home/data/minio 还有设置日志文件路径 /home/data/minio/log/minio.lognohup ./minio server --address :9000 --console-address :9001 /home/data/minio > /home/data/minio/log/minio.log 2>&1 &

–address :9000 --console-address :9001 是配置端口，默认minio端口是9000，如果9000端口被占用了，那就加上这一串配置，端口号的冒号之前不需要特意写出ip，当然如果你的ip的动态变化的，而不是静态的话，前边的ip不用写上，当然最好是用静态的ip

关闭防火墙
如果未关闭，输入以下命令：

systemctl stop firewalld

注意：如果不想关闭防火墙，需要开放ip端口9000和设置静态控制访问IP

访问：http://192.168.92.100:9000查看控制台
这里我们都使用的默认配置账号密码 minioadmin:minioadmin

2.3 修改配置

这里账号和密码都是用的默认的，如果我们要修改可以在环境变量里设置
修改环境变量

打开 /etc/profile 文件

vim /etc/profile

在文件的最末尾加上以下信息（启动的时候看提示，新版本需要用MINIO_ROOT_USER和MINIO_ROOT_PASSWORD，旧版需要用MINIO_ACCESS_KEY和MINIO_SECRET_KEY）。

按 i 键后，在文档末尾输入
（1）新版：

export MINIO_ROOT_USER=minioadminexport MINIO_ROOT_PASSWORD=admin123

（2）旧版

export MINIO_ACCESS_KEY=minioadminexport MINIO_SECRET_KEY=admin123

保存退出，刷新重载环境变量

source /etc/profile

2.4 编写启动脚本，以及加入到systemctl中

为了方便管理，我们这里给命令添加到脚本中

在/usr/local/minio/目录下新建run.sh

vim run.sh

然后将以下内容保存到run.sh,并为其赋予执行权限chmod +x run.sh

#!/bin/bash#配置登陆账号密码export MINIO_ROOT_USER=minioadminexport MINIO_ROOT_PASSWORD=admin123# nohup启动服务 指定文件存放路径 /home/data/minio 还有设置日志文件路径 /home/data/minio/log/minio.lognohup ./minio server --address :9000 --console-address :9001 /home/data/minio > /home/data/minio/log/minio.log 2>&1 &

然后启动minio

# 启动minio服务bash run.sh# 查看日志tail -200f /home/data/minio/log/minio.log

然后会有日志打印信息，然后可以看到minio服务器地址，和控制台信息地址

然后在浏览器中访问地址http://192.168.92.100:9000,输入这个地址后会重定向到控制台登录地址http://192.168.92.100:9001/login

添加到systemctl启动命令中

编写minio.service文件

vim /usr/lib/systemd/system/minio.service

填写以下内容

[Unit]Description=minioDocumentation=https://docs.min.ioWants=network-online.targetAfter=network-online.targetAssertFileIsExecutable=/usr/local/minio/minio[Service]#User and groupUser=rootGroup=rootExecStart=/usr/local/minio/run.sh#Let systemd restart this service alwaysRestart=always#Specifies the maximum file descriptor number that can be opened by this processLimitNOFILE=65536#Disable timeout logic and wait until process is stoppedTimeoutStopSec=infinitySendSIGKILL=no[Install]WantedBy=multi-user.target

赋值权限并且启动

chmod +x /usr/lib/systemd/system/minio.service

启动、查看、设置开机启动

systemctl daemon-reloadsystemctl start miniosystemctl enable miniosystemctl status minio

启动报错处理

systemctl start minioAssertion failed on job for minio.service.# 是 minio.service 的 AssertFileIsExecutable 路径错误AssertFileIsExecutable=/usr/local/minio# 改为AssertFileIsExecutable=/usr/local/minio/minio

到这里单机版的已经安装完毕！

三、Springboot集成MinIO

3.1 项目应用

项目的pom文件中引入minio依赖

<properties>        <minio.version>7.1.0</minio.version> <dependencies>        <dependency>            <groupId>io.minio</groupId>            <artifactId>minio</artifactId>            <version>${minio.version}</version>        </dependency> </dependencies>

在application.yml文件中配置minio

minio:  endpoint: http://192.168.92.100  port: 9000  accessKey: minioadmin  secretKey: admin123  bucketName: test  secure: false spring:#设置文件上传大小限制  servlet:    multipart:      max-file-size: 100MB      max-request-size: 150MB

创建minio配置类和工具类
配置类：

package cn.cvzhanshi.wechatpush.config;import io.minio.MinioClient;import io.minio.errors.InvalidPortException;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;import org.springframework.stereotype.Component;@Configuration@Component@ConfigurationProperties(prefix = "minio")@Getter@Setterpublic class MinioConfig {    private String endpoint;    private int port;    private String accessKey;    private String secretKey;    private Boolean secure;    private String bucketName;    @Bean    public MinioClient getMinioClient() throws InvalidPortException {        MinioClient minioClient = MinioClient.builder().endpoint(endpoint, port, secure)                .credentials(accessKey, secretKey)                .build();        return minioClient;    }////    @Bean(name = "multipartResolver")//    public MultipartResolver multipartResolver(){//        CommonsMultipartResolver resolver = new CommonsMultipartResolver();//        resolver.setDefaultEncoding("UTF-8");//        //resolveLazily属性启用是为了推迟文件解析，以在在UploadAction中捕获文件大小异常//        resolver.setResolveLazily(true);//        resolver.setMaxInMemorySize(40960);//        //上传文件大小 50M 50*1024*1024//        resolver.setMaxUploadSize(50*1024*1024);//        return resolver;//    }}

工具类：

package cn.cvzhanshi.wechatpush.utils;import io.minio.*;import io.minio.errors.*;import io.minio.http.Method;import io.minio.messages.Bucket;import io.minio.messages.DeleteError;import io.minio.messages.DeleteObject;import io.minio.messages.Item;import lombok.extern.slf4j.Slf4j;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; /** * MinIO 客户端工具类 */@Component@Slf4jpublic class MinioClientUtils {     @Autowired    private MinioClient minioClient;     private static final int DEFAULT_EXPIRY_TIME = 7 * 24 * 3600;     /**     * 检查存储桶是否存在     *     * @param bucketName 存储桶名称     * @return boolean     */    public boolean bucketExists(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {        boolean flag = false;        flag = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());        if (flag) {            return true;        }        return false;    }     /**     * 创建存储桶     *     * @param bucketName 存储桶名称     */    public boolean makeBucket(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, RegionConflictException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {        boolean flag = bucketExists(bucketName);        if (!flag) {            minioClient.makeBucket(                    MakeBucketArgs.builder()                            .bucket(bucketName)                            .build());            return true;        } else {            return false;        }    }     /**     * 列出所有存储桶名称     *     * @return List<String>     */    public List<String> listBucketNames() throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {        List<Bucket> bucketList = listBuckets();        List<String> bucketListName = new ArrayList<>();        for (Bucket bucket : bucketList) {            bucketListName.add(bucket.name());        }        return bucketListName;    }     /**     * 列出所有存储桶     *     * @return List<Bucket>     */    public List<Bucket> listBuckets() throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {        return minioClient.listBuckets();    }     /**     * 删除存储桶     *     * @param bucketName 存储桶名称     * @return boolean     */    public boolean removeBucket(String bucketName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {        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(RemoveBucketArgs.builder().bucket(bucketName).build());            flag = bucketExists(bucketName);            if (!flag) {                return true;            }         }        return false;    }     /**     * 列出存储桶中的所有对象名称     *     * @param bucketName 存储桶名称     * @return List<String>     */    public List<String> listObjectNames(String bucketName) throws XmlParserException, IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, InvalidBucketNameException, InsufficientDataException, InternalException {        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 Iterable<Result<Item>>     */    public Iterable<Result<Item>> listObjects(String bucketName) throws XmlParserException, IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, InvalidBucketNameException, InsufficientDataException, InternalException {        boolean flag = bucketExists(bucketName);        if (flag) {            return minioClient.listObjects( ListObjectsArgs.builder().bucket(bucketName).build());        }        return null;    }     /**     * 通过文件上传到对象     *     * @param bucketName 存储桶名称     * @param objectName 存储桶里的对象名称     * @param fileName   File name     * @return boolean     */    public boolean uploadObject(String bucketName, String objectName, String fileName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {        boolean flag = bucketExists(bucketName);        if (flag) {            minioClient.uploadObject(                    UploadObjectArgs.builder()                            .bucket(bucketName).object(objectName).filename(fileName).build());            ObjectStat statObject = statObject(bucketName, objectName);            if (statObject != null && statObject.length() > 0) {                return true;            }        }        return false;     }     /**     * 文件上传     *     * @param bucketName 存储捅名称     * @param multipartFile 文件     * @param filename   文件名     */    public void putObject(String bucketName, MultipartFile multipartFile, String filename) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {        PutObjectOptions putObjectOptions = new PutObjectOptions(multipartFile.getSize(), PutObjectOptions.MIN_MULTIPART_SIZE);        putObjectOptions.setContentType(multipartFile.getContentType());        minioClient.putObject(                PutObjectArgs.builder().bucket(bucketName).object(filename).stream(                        multipartFile.getInputStream(), multipartFile.getSize(), -1).contentType(multipartFile.getContentType())                        .build());    }     /**     * 通过InputStream上传对象     *     * @param bucketName 存储桶名称     * @param objectName 存储桶里的对象名称     * @param inputStream     要上传的流     * @param contentType 上传的文件类型 例如 video/mp4  image/jpg     * @return boolean     */    public boolean putObject(String bucketName, String objectName, InputStream inputStream,String contentType) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {        boolean flag = bucketExists(bucketName);        if (flag) {            minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(objectName).stream(                    //不清楚文件的大小时，可以传-1，10485760。如果知道大小也可以传入size，partsize。                    inputStream,  -1, 10485760)                    .contentType(contentType)                    .build());            ObjectStat statObject = statObject(bucketName, objectName);            if (statObject != null && statObject.length() > 0) {                return true;            }        }        return false;    }     /**     * 以流的形式获取一个文件对象     *     * @param bucketName 存储桶名称     * @param objectName 存储桶里的对象名称     * @return InputStream     */    public InputStream getObject(String bucketName, String objectName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {        boolean flag = bucketExists(bucketName);        if (flag) {            ObjectStat statObject = statObject(bucketName, objectName);            if (statObject != null && statObject.length() > 0) {                InputStream stream = minioClient.getObject( GetObjectArgs.builder()                        .bucket(bucketName)                        .object(objectName)                        .build());                return stream;            }        }        return null;    }     /**     * 以流的形式获取一个文件对象（断点下载）     *     * @param bucketName 存储桶名称     * @param objectName 存储桶里的对象名称     * @param offset     起始字节的位置     * @param length     要读取的长度 (可选，如果无值则代表读到文件结尾)     * @return InputStream     */    public InputStream getObject(String bucketName, String objectName, long offset, Long length) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {        boolean flag = bucketExists(bucketName);        if (flag) {            ObjectStat statObject = statObject(bucketName, objectName);            if (statObject != null && statObject.length() > 0) {                InputStream stream = minioClient.getObject(  GetObjectArgs.builder()                        .bucket(bucketName)                        .object(objectName)                        .offset(1024L)                        .length(4096L)                        .build());                return stream;            }        }        return null;    }     /**     * 下载并将文件保存到本地     *     * @param bucketName 存储桶名称     * @param objectName 存储桶里的对象名称     * @param fileName   File name     * @return boolean     */    public boolean downloadObject(String bucketName, String objectName, String fileName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {        boolean flag = bucketExists(bucketName);        if (flag) {            ObjectStat statObject = statObject(bucketName, objectName);            if (statObject != null && statObject.length() > 0) {                minioClient.downloadObject(DownloadObjectArgs.builder()                        .bucket(bucketName)                        .object(objectName)                        .filename(fileName)                        .build());                return true;            }        }        return false;    }     /**     * 删除一个对象     *     * @param bucketName 存储桶名称     * @param objectName 存储桶里的对象名称     */    public boolean removeObject(String bucketName, String objectName) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {        boolean flag = bucketExists(bucketName);        if (flag) {            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());            return true;        }        return false;    }     /**     * 删除指定桶的多个文件对象,返回删除错误的对象列表，全部删除成功，返回空列表     *     * @param bucketName  存储桶名称     * @param objectNames 含有要删除的多个object名称的迭代器对象     * @return     * eg:     * List<DeleteObject> objects = new LinkedList<>();     * objects.add(new DeleteObject("my-objectname1"));     * objects.add(new DeleteObject("my-objectname2"));     * objects.add(new DeleteObject("my-objectname3"));     */    public List<String> removeObjects(String bucketName, List<DeleteObject> objectNames) throws IOException, InvalidKeyException, InvalidResponseException, InsufficientDataException, NoSuchAlgorithmException, ServerException, InternalException, XmlParserException, InvalidBucketNameException, ErrorResponseException {        List<String> deleteErrorNames = new ArrayList<>();        boolean flag = bucketExists(bucketName);        if (flag) {            Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(objectNames).build());            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     */    public String getPresignedObjectUrl(String bucketName, String objectName, Integer expires) throws InvalidExpiresRangeException, IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {        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);            }            try {                url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()                        .method(Method.GET)                        .bucket(bucketName)                        .object(objectName)                        .expiry(expires)//动态参数                        //                       .expiry(24 * 60 * 60)//用秒来计算一天时间有效期//                        .expiry(1, TimeUnit.DAYS)//按天传参//                        .expiry(1, TimeUnit.HOURS)//按小时传参数                        .build());            } catch (ErrorResponseException | InsufficientDataException | InternalException | InvalidBucketNameException | InvalidExpiresRangeException | InvalidKeyException | InvalidResponseException | IOException | NoSuchAlgorithmException | ServerException | XmlParserException e) {                e.printStackTrace();            }        }        return url;    }     /**     * 生成一个给HTTP PUT请求用的presigned URL。     * 浏览器/移动端的客户端可以用这个URL进行上传，即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间，默认值是7天。     *     * @param bucketName 存储桶名称     * @param objectName 存储桶里的对象名称     * @param expires    失效时间（以秒为单位），默认是7天，不得大于七天     * @return String     */    public String presignedPutObject(String bucketName, String objectName, Integer expires) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {        boolean flag = bucketExists(bucketName);        String url = "";        if (flag) {            if (expires < 1 || expires > DEFAULT_EXPIRY_TIME) {                try {                    throw new InvalidExpiresRangeException(expires,                            "expires must be in range of 1 to " + DEFAULT_EXPIRY_TIME);                } catch (InvalidExpiresRangeException e) {                    e.printStackTrace();                }            }            try {                url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()                        .method(Method.PUT)                        .bucket(bucketName)                        .object(objectName)                        .expiry(expires)//动态参数                        //                       .expiry(24 * 60 * 60)//用秒来计算一天时间有效期//                        .expiry(1, TimeUnit.DAYS)//按天传参//                        .expiry(1, TimeUnit.HOURS)//按小时传参数                        .build());            } catch (ErrorResponseException | InsufficientDataException e) {                e.printStackTrace();            } catch (InternalException e) {                log.error("InternalException",e);            } catch (InvalidBucketNameException e) {                log.error("InvalidBucketNameException",e);            } catch (InvalidExpiresRangeException e) {                log.error("InvalidExpiresRangeException",e);            } catch (InvalidKeyException e) {                log.error("InvalidKeyException",e);            } catch (InvalidResponseException e) {                log.error("InvalidResponseException",e);            } catch (IOException e) {                log.error("IOException",e);            } catch (NoSuchAlgorithmException e) {                log.error("NoSuchAlgorithmException",e);            } catch (ServerException e) {                log.error("ServerException",e);            } catch (XmlParserException e) {                log.error("XmlParserException",e);            }        }        return url;    }     /**     * 获取对象的元数据     *     * @param bucketName 存储桶名称     * @param objectName 存储桶里的对象名称     * @return     */    public ObjectStat statObject(String bucketName, String objectName) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {        boolean flag = bucketExists(bucketName);        if (flag) {            ObjectStat statObject = null;            try {                statObject = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());            } catch (ErrorResponseException e) {                log.error("ErrorResponseException",e);            } catch (InsufficientDataException e) {                log.error("ErrorResponseException",e);                e.printStackTrace();            } catch (InternalException e) {                log.error("InternalException",e);            } catch (InvalidBucketNameException e) {                log.error("InvalidBucketNameException",e);            } catch (InvalidKeyException e) {                log.error("InvalidKeyException",e);            } catch (InvalidResponseException e) {                log.error("InvalidResponseException",e);            } catch (IOException e) {                log.error("IOException",e);            } catch (NoSuchAlgorithmException e) {                log.error("NoSuchAlgorithmException",e);            } catch (ServerException e) {                log.error("ServerException",e);            } catch (XmlParserException e) {                log.error("XmlParserException",e);            }            return statObject;        }        return null;    }     /**     * 文件访问路径     *     * @param bucketName 存储桶名称     * @param objectName 存储桶里的对象名称     * @return String     */    public String getObjectUrl(String bucketName, String objectName) throws IOException, InvalidResponseException, InvalidKeyException, NoSuchAlgorithmException, ServerException, ErrorResponseException, XmlParserException, InvalidBucketNameException, InsufficientDataException, InternalException {        boolean flag = bucketExists(bucketName);        String url = "";        if (flag) {            try {                url = minioClient.getObjectUrl(bucketName, objectName);            } catch (ErrorResponseException e) {                log.error("XmlParserException",e);            } catch (InsufficientDataException e) {                log.error("InsufficientDataException",e);            } catch (InternalException e) {                log.error("InternalException",e);            } catch (InvalidBucketNameException e) {                log.error("InvalidBucketNameException",e);            } catch (InvalidKeyException e) {                log.error("InvalidKeyException",e);            } catch (InvalidResponseException e) {                log.error("InvalidResponseException",e);            } catch (IOException e) {                log.error("IOException",e);            } catch (NoSuchAlgorithmException e) {                log.error("NoSuchAlgorithmException",e);            } catch (ServerException e) {                log.error("ServerException",e);            } catch (XmlParserException e) {                log.error("XmlParserException",e);            }        }        return url;    }       public void downloadFile(String bucketName, String fileName, String originalName, HttpServletResponse response) {        try {             InputStream file = minioClient.getObject(GetObjectArgs.builder()                    .bucket(bucketName)                    .object(fileName)                    .build());            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) {            log.error("ErrorResponseException",e);        } catch (Exception e) {            log.error("Exception",e);        }    }} 

创建一个数据表，用于保存上传到minio的文件的信息

CREATE TABLE `minio_file` (  `id` bigint(20) NOT NULL COMMENT '文件id',  `original_file_name` varchar(255) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '原始文件名称',  `file_ext_name` varchar(15) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '文件拓展名',  `file_size` bigint(20) DEFAULT NULL COMMENT '文件大小(单位：字节）',  `file_name` varchar(35) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '存入minio时的文件名称',  `mime` varchar(50) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '文件的content-type',  `file_url` varchar(255) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '文件路径',  `is_delete` tinyint(1) DEFAULT NULL COMMENT '是否删除 0 否 1 是',  `create_by` varchar(25) COLLATE utf8mb4_bin DEFAULT NULL,  `create_time` datetime DEFAULT NULL,  `update_by` varchar(25) COLLATE utf8mb4_bin DEFAULT NULL,  `update_time` datetime DEFAULT NULL,  PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

创建minio上传接口

package cn.cvzhanshi.wechatpush.controller;import cn.cvzhanshi.wechatpush.config.MinioConfig;import cn.cvzhanshi.wechatpush.utils.MinioClientUtils;import cn.hutool.core.io.FileUtil;import io.swagger.annotations.Api;import io.swagger.annotations.ApiImplicitParam;import io.swagger.annotations.ApiImplicitParams;import io.swagger.annotations.ApiOperation;import lombok.AllArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.apache.commons.lang3.RandomStringUtils;import org.apache.commons.lang3.math.NumberUtils;import org.springframework.stereotype.Controller;import org.springframework.util.CollectionUtils;import org.springframework.web.bind.annotation.*;import org.springframework.web.multipart.MultipartFile;import java.io.FileInputStream;import java.time.Instant;import java.util.ArrayList;import java.util.List;@RestController@RequestMapping("/fileHandle")@Slf4j@AllArgsConstructor@Api(tags = "文件处理模块")public class FileHandleController {private MinioClientUtils minioClientUtils;private MinioConfig minioConfig;@ApiOperation(value = "上传文件,支持批量上传")@ApiImplicitParams({@ApiImplicitParam(name = "files", value = "文件流对象,接收数组格式", paramType = "query",required = true, dataType = "MultipartFile", allowMultiple = true)})@PostMapping("/uploadFile")public ApiResult uploadFile(@RequestParam(value = "files", required = true) MultipartFile[] files) {log.info(files.toString());     /*   if (CollectionUtils.isEmpty(files)){            return ApiResult.error("未选择文件！");        }*/List<String> MinioResponseDTOList = new ArrayList<>();for (MultipartFile file : files) {String originalFilename = file.getOriginalFilename();//            获取文件拓展名String extName = FileUtil.extName(originalFilename);log.info("文件拓展名:" + extName);//            生成新的文件名，存入到miniolong millSeconds = Instant.now().toEpochMilli();String minioFileName = millSeconds + RandomStringUtils.randomNumeric(12) + "." + extName;String contentType = file.getContentType();log.info("文件mime:{}", contentType);//            返回文件大小,单位字节long size = file.getSize();log.info("文件大小：" + size);try {String bucketName = minioConfig.getBucketName();minioClientUtils.putObject(bucketName, file, minioFileName);String fileUrl = minioClientUtils.getObjectUrl(bucketName, minioFileName);             /*   MinioFile minioFile = new MinioFile();                minioFile.setOriginalFileName(originalFilename);                minioFile.setFileExtName(extName);                minioFile.setFileName(minioFileName);                minioFile.setFileSize(size);                minioFile.setMime(contentType);                minioFile.setIsDelete(NumberUtils.INTEGER_ZERO);                minioFile.setFileUrl(fileUrl);                boolean insert = minioFile.insert();                if (insert) {                    MinioResponseDTO minioResponseDTO = new MinioResponseDTO();                    minioResponseDTO.setFileId(minioFile.getId());                    minioResponseDTO.setOriginalFileName(originalFilename);                    minioResponseDTO.setFileUrl(fileUrl);                    MinioResponseDTOList.add(minioResponseDTO);                }*/MinioResponseDTOList.add(fileUrl);} catch (Exception e) {log.error("上传文件出错:{}", e);return ApiResult.error("上传文件出错");}}return ApiResult.success(MinioResponseDTOList);}/** * 仅仅用于测试，是否可以正常上传文件 * * @return * @throws Exception */@GetMapping("/test")@ApiOperation(value = "测试minio文件上传")public ApiResult testPutObject() throws Exception {FileInputStream fileInputStream = new FileInputStream("C:\\Users\\MSI\\Desktop\\新建文本文档.txt");boolean bs = minioClientUtils.putObject("fsp-dev", "新建文本文档.txt", fileInputStream, "image/jpg");log.info("上传成功?" + bs);return ApiResult.success("上传成功");}}

测试接口

四、Java中图片压缩上传

4.1 背景

现在大家都是用的智能手机拍照，拍出来的照片小则 2-3 M，大则十几 M，所以导致图片显示较慢。思考再三，决定将图片进行压缩再上传图片服务器来解决图片显示慢的问题

4.2 开发准备

引入 maven 依赖

<!-- 图片压缩 --><dependency>    <groupId>net.coobird</groupId>    <artifactId>thumbnailator</artifactId>    <version>0.4.8</version></dependency>

本次我们选择了使用 thumbnailator 来作为压缩的工具

thumbnailator 简介

Thumbnailator 是一个用来生成图像缩略图的 Java 类库，通过很简单的代码即可生成图片缩略图，也可直接对一整个目录的图片生成缩略图
支持图片缩放，区域裁剪，水印，旋转，保持比例

压缩准备
判断是否是图片方法

/** * 判断文件是否为图片 */public boolean isPicture(String imgName) {    boolean flag = false;    if (StringUtils.isBlank(imgName)) {        return false;    }    String[] arr = {"bmp", "dib", "gif", "jfif", "jpe", "jpeg", "jpg", "png", "tif", "tiff", "ico"};    for (String item : arr) {        if (item.equals(imgName)) {            flag = true;            break;        }    }    return flag;}

4.3 压缩上传

/** * 上传文件 * * @param file 文件 * @return */public JSONObject uploadFile(MultipartFile file) throws Exception {    JSONObject res = new JSONObject();    res.put("code", 500);    // 判断上传文件是否为空    if (null == file || 0 == file.getSize()) {        res.put("msg", "上传文件不能为空");        return res;    }    // 判断存储桶是否存在    if (!client.bucketExists("test")) {        client.makeBucket("test");    }    // 拿到文件后缀名，例如：png    String suffix = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".") + 1);    // UUID 作为文件名    String uuid = String.valueOf(UUID.randomUUID());    // 新的文件名    String fileName = DateUtils.getYyyymmdd() + "/" + uuid + "." + suffix;    /**     * 判断是否是图片     * 判断是否超过了 100K     */    if (isPicture(suffix) && (1024 * 1024 * 0.1) <= file.getSize()) {        // 在项目根目录下的 upload 目录中生成临时文件        File newFile = new File(ClassUtils.getDefaultClassLoader().getResource("upload").getPath() + uuid + "." + suffix);        // 小于 1M 的        if ((1024 * 1024 * 0.1) <= file.getSize() && file.getSize() <= (1024 * 1024)) {            Thumbnails.of(file.getInputStream()).scale(1f).outputQuality(0.3f).toFile(newFile);        }        // 1 - 2M 的        else if ((1024 * 1024) < file.getSize() && file.getSize() <= (1024 * 1024 * 2)) {            Thumbnails.of(file.getInputStream()).scale(1f).outputQuality(0.2f).toFile(newFile);        }        // 2M 以上的        else if ((1024 * 1024 * 2) < file.getSize()) {            Thumbnails.of(file.getInputStream()).scale(1f).outputQuality(0.1f).toFile(newFile);        }        // 获取输入流        FileInputStream input = new FileInputStream(newFile);        // 转为 MultipartFile        MultipartFile multipartFile = new MockMultipartFile("file", newFile.getName(), "text/plain", input);        // 开始上传        client.putObject("test", fileName, multipartFile.getInputStream(), file.getContentType());        // 删除临时文件        newFile.delete();        // 返回状态以及图片路径        res.put("code", 200);        res.put("msg", "上传成功");        res.put("url", minioProp.getEndpoint() + "/" + "test" + "/" + fileName);    }    // 不需要压缩，直接上传    else {        // 开始上传        client.putObject("test", fileName, file.getInputStream(), file.getContentType());        // 返回状态以及图片路径        res.put("code", 200);        res.put("msg", "上传成功");        res.put("url", minioProp.getEndpoint() + "/" + "test" + "/" + fileName);    }    return res;}

这里我们判断了当文件为图片的时候，且当它大小超过了 (1024 * 1024 * 0.1)，约为 100K 的时候，才进行压缩我们首先在根目录下的 upload 目录中创建了一个临时文件 newFileThumbnails.of(file.getInputStream()).scale(1f).outputQuality(0.3f).toFile(newFile);将压缩后的文件输出到临时文件中然后将 FileInputStream 转为 MultipartFile 上传最后删除临时文件 newFile.delete();完成图片压缩上传

遇到的问题：
Thumbnails.scale效果会导致图片大小变大

Thumbnails应该是存在bug，但是也一直没有更新版本，所以根据多次测试得来的结果：用jpg转成jpg效果最佳。所以当图片为png时，先改成jpg格式，再进行压缩。

public static String imgConvert(String tempDirPath, String fileName, String fileExt) throws IOException {    String srcPath = tempDirPath + fileName;  //原始图片路径    if("png".equals(fileExt)) {        //生成新图片名称    SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");            String fileString = df.format(new Date()) + "_" + new Random().nextInt(1000) + ".jpg";                        //新图片全路径            String newJpg = tempDirPath + fileString;                     // 1、先转换成jpg              Thumbnails.of(srcPath).scale(1f).toFile(newJpg);                         //2.jpg图片压缩            Thumbnails.of(newJpg).scale(1f).outputQuality(0.25d).toFile(newJpg);                        //压缩成功后,删除png图片            File f = new File(srcPath);            f.delete();                        return fileString;    } else {    Thumbnails.of(srcPath).scale(1f).outputQuality(0.25d).toFile(srcPath);    }    return null;    }

五、MinIO集群搭建（完善中~）