说明：Minio是开源的对象存储服务器，相当于免费版的OSS，本文介绍在Linux环境下部署Minio服务器，并在SpringBoot中使用，最后将Minio的代码打包成一个起步依赖。

安装&启动

第一步：下载

首先，在官网上下载服务器程序，非常简单，下载下来就是一个文件；

这里建议不要使用命令行的方式直接在服务器上输入 wget https://dl.min.io/server/minio/release/linux-amd64/minio 下载，网络环境不好，巨慢；

第二步：启动

下载完成后，是一个没有扩展名的文件，上传到云服务器上，在根目录下创建一个minio文件夹，把服务器程序放到这个文件夹里面；

输入下面两行命令，启动minio服务器；

chmod +x minio
MINIO_ROOT_USER=admin MINIO_ROOT_PASSWORD=password ./minio server /mnt/data --console-address ":9001"

• 第一行命令：给minio文件设置可执行权限；

• 第二行命令：设置minio服务器的账号（admin）、密码（password），并启动，端口是9001；

注意密码位数不要过少，会启动失败，使用默认的就可以；

第三步：登录测试

启动完成后，就可以通过IP:端口的方式来访问了。需要注意，如果使用的是云服务器，需要开放9001端口；

在页面中输入地址，访问到minio的管理平台；

第四步：使用

如果有使用过OSS，就会非常熟悉这些界面上的操作；

创建一个桶，设置为public，后面在代码中使用；

创建完bucket后，可以直接把文件资源上传到Minio上；

代码使用

第一步：创建项目

首先，创建一个简单的SpringBoot项目，只加入下面两个依赖，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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.hzy</groupId>
    <artifactId>minio-simple</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <!--Springboot项目-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.12</version>
        <relativePath/>
    </parent>

    <dependencies>
        <!--启动类依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--minio依赖-->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.4.3</version>
        </dependency>
    </dependencies>
</project>

第二步：创建配置类

创建Minio所需要的配置文件类，另外注入一个MinioClient对象到IOC容器中；

import io.minio.MinioClient;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;

@ConfigurationProperties(prefix = "minio")
public class MinioConfig {

    private String endpoint;
    private String bucketName;
    private String accessKey;
    private String secretKey;

    public String getEndpoint() {
        return endpoint;
    }

    public void setEndpoint(String endpoint) {
        this.endpoint = endpoint;
    }

    public String getBucketName() {
        return bucketName;
    }

    public void setBucketName(String bucketName) {
        this.bucketName = bucketName;
    }

    public String getAccessKey() {
        return accessKey;
    }

    public void setAccessKey(String accessKey) {
        this.accessKey = accessKey;
    }

    public String getSecretKey() {
        return secretKey;
    }

    public void setSecretKey(String secretKey) {
        this.secretKey = secretKey;
    }

    /**
     * 创建一个Minio客户端
     * @return
     */
    @Bean
    public MinioClient createMinioClient(){
        return MinioClient
                .builder()
                .endpoint(endpoint)
                .credentials(accessKey,secretKey)
                .build();
    }
}

第三步：创建操作类

创建一个Minio操作的工具类，如下，更多请参考（http://t.csdn.cn/hHfDK）：

import com.hzy.config.MinioConfig;
import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.DeleteObject;
import io.minio.messages.Item;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.stereotype.Component;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Optional;

/**
 * MinIO工具类
 */
@Component
@EnableConfigurationProperties(MinioConfig.class)
public class MinioUtils {

    @Autowired
    private MinioClient minioClient;

    @Autowired
    private MinioConfig minIOConfig;

    /**
     * 创建基于Java端的MinioClient
     */
    public void createMinioClient() {
        if (null == minioClient) {
            minioClient = MinioClient
                    .builder()
                    .endpoint(minIOConfig.getEndpoint())
                    .credentials(minIOConfig.getAccessKey(), minIOConfig.getSecretKey())
                    .build();
            try {
                createBucket(minIOConfig.getBucketName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 启动SpringBoot容器的时候初始化Bucket
     * 如果没有Bucket则创建
     *
     * @throws Exception
     */
    private void createBucket(String bucketName) throws Exception {
        if (!bucketExists(bucketName)) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        }
    }

    /**
     * 判断Bucket是否存在，true：存在，false：不存在
     *
     * @return
     * @throws Exception
     */
    public boolean bucketExists(String bucketName) throws Exception {
        return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
    }

    /**
     * 使用MultipartFile进行文件上传
     *
     * @param bucketName  存储桶
     * @param fileBytes   文件字节数组
     * @param objectName  对象名
     * @param contentType 类型
     * @return
     * @throws Exception
     */
    public ObjectWriteResponse uploadFile(String bucketName, byte[] fileBytes, String objectName,
                                          String contentType) throws Exception {

        InputStream inputStream = new ByteArrayInputStream(fileBytes);

        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .contentType(contentType)
                        .stream(inputStream, inputStream.available(), -1)
                        .build());
    }
}

第四步：添加配置

设置配置文件，如下，注意哦，Minio代码端连接的端口是9000，所以如果使用的是云服务器，需要开通此端口；

minio:
  endpoint: http://Minio服务器IP:9000
  bucketName: simple
  accessKey: admin
  secretKey: password

第五步：创建Controller启动

最后，创建一个Controller，启动，测试；

import com.hzy.utils.MinioUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

@RestController
public class MinioController {

    @Autowired
    private MinioUtils minioUtils;

    @PostMapping("upload")
    public void uploadImage(MultipartFile file){
        try {
            minioUtils.uploadFile("simple", file.getBytes(), "pic", file.getContentType());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

第六步：上传文件测试

使用Apifox，填上地址、请求方式为POST、请求数据为Body，表单、参数名file（要与controller层一致）、选择文件；

发送完成后，查看Minio管理平台，查看文件；

可以看到，图片已上传成功；

这时，点击图片，右边有个Share，点击，在弹出的窗口里可以看到该图片的连接；

但是注意哦，这个链接是假链接，无效的，将这个链接修改成如下才可以访问到图片：

http://Minio服务器IP:9000/bucket名/文件路径

第七步：优化

而这个路径，我们是可以在代码里拼接的，比如上传图片后我们需要将此地址存入到数据库中，就可以将代码改成下面这样：

@RestController
public class MinioController {

    @Autowired
    private MinioUtils minioUtils;

    @Autowired
    private MinioConfig minioConfig;

    @PostMapping("upload")
    public String uploadImage(MultipartFile file) {
        // 生成UUID作为文件的名称
        String fileName = UUID.randomUUID() + file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf('.'));
        try {
            // 上传到Minio上
            minioUtils.uploadFile(minioConfig.getBucketName(), file.getBytes(), fileName, file.getContentType());
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 文件的路径，可存入数据库
        return minioConfig.getEndpoint() + "/" + minioConfig.getBucketName() + "/" + fileName;
    }
}

发送图片测试；

打开这个链接，可以访问到这张图片；

当然，这还是非常粗糙的，在项目中使用需要考虑到图片大小和格式校验、目录分级、图片审核等等；

起步依赖

第一步：创建项目

首先，先另外创建一个SpringBoot项目，用来测试Minio起步依赖，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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.hzy</groupId>
    <artifactId>starter-simple</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <!--Springboot项目-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.12</version>
        <relativePath/>
    </parent>

    <dependencies>
        <!--启动类依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--minio起步依赖-->
        <dependency>
            <groupId>com.hzy</groupId>
            <artifactId>minio-simple</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

第二步：剪切代码

把前面Minio项目中的controller层代码、application.yml配置都剪切过来，如下：

第三步：修改Minio依赖

Minio作为起步依赖，为了方别其他模块引用使用，原则是尽可能少的引用其他依赖，降低其他模块使用的成本，所以需要进行一些裁剪；

那么，如果不太清楚该去掉哪些依赖，我的一个方法是，先去掉依赖，然后根据报错的注解，再按提示添加对应的依赖，这样可以尽可能少的添加依赖。

（去掉Minio-simple项目中的parent标签的内容，代码报错，依据提示添加依赖）

按照提示，minio-simple项目加入以下依赖即可

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.hzy</groupId>
    <artifactId>minio-simple</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>
        <!--minio依赖-->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.4.3</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.27</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot</artifactId>
            <version>2.7.12</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

</project>

改造完成后，强烈建议启动starter-simple项目（demo项目），测试一下功能是否还能跑通；

---

第四步：执行install命令

在minio-simple项目中的Maven中，跳过test，执行install命令，安装此项目到本地仓库中；

执行完成；

此时，可以在本地仓库中找到此Maven；

第五步：测试

最后一步，也是最重要的一步，测试该起步依赖是否整合成功。

首先，需要把前面的minio-simple项目移除项目空间，有些同学忽略了此步骤，测试成功后就认为起步依赖整合完成了，其实不是哈，这样子使用的仍然是minio-simple项目中的代码，而不是本地仓库的jar包；

确认一下，pom.xml中添加了Minio起步依赖的Maven坐标；

启动项目；

测试完成；

至此，Minio起步依赖整合完成，以后别的项目中，可以直接在项目中引入该依赖，自动装配对应的Bean对象，使用对应的方法；

总结

Minio与OSS差不多，但是开源、免费，推荐使用；