# minio-study

**Repository Path**: ChengSongyun/minio-study

## Basic Information

- **Project Name**: minio-study
- **Description**: 关于存储工具MinIO的使用学习
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-09-18
- **Last Updated**: 2025-09-18

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Minio

## 一、Minio概念

Minio是一个开源的**对象存储服务器**，可以在上面存储图片，文件，文件夹等。

1. 桶（Bucket）：在Minio中桶就等同于在该服务器中的根目录
2. 对象（Object）：在Minio中桶下面的所有都叫对象（也就是文件都称之为对象）

## 二、Minio使用教程

### 1、下载Minio

中文官网：[MinIO | 用于AI的S3 & Kubernetes原生对象存储](https://minio.org.cn/)

进入官网点击下载

![image-20250905093813041](C:\Users\CSY\AppData\Roaming\Typora\typora-user-images\image-20250905093813041.png)

选择相匹配的系统，我这里选择的是Windows系统，并点击DOWNLOAD进行下载

注意：默认下载的是社区版，功能有限

![image-20250905093849609](C:\Users\CSY\AppData\Roaming\Typora\typora-user-images\image-20250905093849609.png)

### 2、启动Minio

下载好后，启动终端（Windows PowerShell），根据官网的代码进行操作

> PS> **Invoke-WebRequest -Uri "https://dl.minio.org.cn/server/minio/release/windows-amd64/minio.exe" -OutFile "D:\minio.exe"** 
> "D:\minio.exe" ：代表的是minio的程序路径
>
> 设置账号
> PS> **setx MINIO_ROOT_USER admin**
>
>  设置密码
> PS> **setx MINIO_ROOT_PASSWORD password**
>
>  启动Minio
> PS> **C:\minio.exe server F:\Data --console-address ":9001"**
> C:\minio.exe：代表minio的程序路径，可以配置环境变量简化代码
> F:\Data：代表数据存放路径

### 3、Minio可视化页面

启动Minio后，进入网址：http://127.0.0.1:9001/，并根据自己的账号密码登录（初始账号：minioadmin,初始密码：minioadmin）

进入后我们就可以可视化的创建桶和上传文件了！

![image-20250905095026397](C:\Users\CSY\AppData\Roaming\Typora\typora-user-images\image-20250905095026397.png)

## 三、在Java中使用Minio

### 1、自定义Utils工具类使用Minio

#### 1.配置MvcConfig,RootConfig,WebConfig

略

注意：在WebConfig配置类中必须启用文件上传

```java
/**
     * 自定义servlet配置 - 给DispatcherServlet
     * 例如：启用DispatcherServlet上传功能
     * @param registration
     */
    @Override
    protected void customizeRegistration(ServletRegistration.Dynamic registration) {
        //创建上传配置对象 - 设置上传的限制
        //参数一：上传的根目录
        //参数二：限制单个文件上传的大小（字节）
        //参数三：限制本次请求中所有文件的总大小
        //参数四：当达到指定大小时，将写入文件
        MultipartConfigElement configElement = new MultipartConfigElement("",20971520,
                1024L *1024*1024*2,2097152);
        //注册上传配置
        registration.setMultipartConfig(configElement);
        //让DispatcherServlet在启动web容器时就初始化 - 唯一
        registration.setLoadOnStartup(0);
    }
```

#### 2.完成BaseController和ResultVO

略

#### 3.完成MinioUtils

- 设置连接属性并初始化客户端

  ```java
  //连接属性
  private static final String HOST = "http://127.0.0.1:9001";
  //账号
  private static final String ACCOUNT = "csy";
  //密码
  private static final String PASSWORD = "csy11348336";
  
  //Minio客户端
  private static MinioClient client;
  
  /**
  * 使用静态代码块初始化客户端
  */
  static {
      client = MinioClient.builder()
          //设置主机地址
          .endpoint(HOST)
          //设置账号密码
          .credentials(ACCOUNT,PASSWORD)
          .build();
  }
  ```

- 判断桶是否存在

  ```java
  public static boolean hasBucket(String bucketName){
      try{
          //bucketExists:MinioClient对象自带的判断方法
          //BucketExistsArgs:判断参数
          //.bucket(桶名)
          return client.bucketExists(BucketExistsArgs
                                     .builder()
                                     //桶名
                                     .bucket(bucketName)
                                     .build())
      }catch(Exception e){
          throw new RunTimeException(e)
      }
  }
  ```

- 创建桶

  ```java
  public static void createBucket(String bucketName){
      try{
          client.makeBucket(MakeBucketArgs
                      .builder()
                      .bucket(bucketName)
                      .build());
      }catch(Exception e){
          throw new RunTimeException("create fail:"+e)
      }
  }
  ```

- 文件上传

  ```java
  public static void upload(String path,
                            String contentType,
                            long size,
                            InputStream is){
      try{
          client.putObject(PutObjectArgs.builder()
                           .bucket("myapp")
                           .object(path)
                           .contentType(contentType)
                           .stream(is,size,-1)
                           .build())
      }catch(Exception e){
          throw new RunTimeException("upload fail:"+e)
      }
  }
  ```

  > 参数解释：
  > path：代表对象路径，也就是“路径+文件名”，如：image/csy.jpg，如果路径不存在会自动创建
  >
  > contentType：上传的文件类型
  >
  > size：文件大小
  >
  > is：文件输入流，要上传的文件数据流
  >
  > 
  >
  > 方法解释：
  >
  > .bucket(桶名)
  >
  > .object(对象路径)
  >
  > .contentType(文件类型)
  >
  > .stream(输入流,文件大小,上传位置（-1表示文件末尾）)

#### 4.完成UploadController，使用MinioUtils

- 注入MinioOptions

  ```java
  @Autowired
  private MinioOptions options;
  ```

- 文件上传接口实现

  > 这里的 “接口实现” 并不是指 “Java 类实现接口（`implements`关键字）” 的语法概念，而是指 “**接口功能的具体实现逻辑**”—— 也就是你写的这段代码，是对 `/upload/{path}` 这个 HTTP 接口的功能实现。

  ```java
  @PostMapping("/upload/{path}")
  public ResultVO upload(@PathVariable("path") String path,
                             @RequestParam("file") MultipartFile[] files) throws Exception {
      //判断桶是否存在，不存在创建
      if (!MinioUtils.hasBucket("myapp")) {
      	MinioUtils.createBucket("myapp");
      }
      for (MultipartFile file : files) {
          //获取文件名
          String filename = file.getOriginalFilename();
          //获取文件类型
          String contentType = file.getContentType();
          //获取文件大小
          long size = file.getSize();
          //获取文件输入流
          InputStream in = file.getInputStream();
          //上传到minio的文件服务器
          MinioUtils.upload("myapp",path + "/" + filename,contentType,size,in);
      }
      return success();
  }
  ```

#### 5.前端注意事项

1. 必须是form表单
2. form标签必须设置enctype属性为multipart/form-data

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<script src="https://code.jquery.com/jquery-3.4.1.min.js"></script>
<body>
<h2 align="center">文件上传</h2>
<form id="myForm" enctype="multipart/form-data">
    文件：<input type="file" name="file" id="file" multiple/>
    <input type="button" value="上传"/>
</form>
<script>
    $(':button').on('click', function () {
        //构建formData封装表单数据
        let formData = new FormData($('#myForm')[0]);
        console.log(formData);
        $.ajax({
            url: 'upload/images',
            type: 'post',
            data: formData,
            processData: false,
            contentType: false,
            success: function (result) {
                if (result.code == 200) {
                    alert("上传成功")
                }else{
                    alert("上传失败")
                }
            }
        })
    })
</script>
</body>
</html>
```

### 2、spring手动整合Minio

#### 1.配置MvcConfig,WebInitializer,RootConfig

略

#### 2.编写MinioFactoryBean

> 用于构建MinioClient和初始化桶

```java
/**
* FactoryBean<MinioOptions>表示这个工厂是专门用于创建MinioOptions对象的
*/
public class MinioFactoryBean implements FactoryBean<MinioOptions>{
    /**
    * 文件服务器的链接url
    */
    private String host;
    
    /**
    * 账号
    */
    private String account;
    
    /**
    * 密码
    */
    private String password;
    
    /**
    * 桶名
    */
    private String bucketName;
    
    public void setHost(String host) {
        this.host = host;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void setBucketName(String bucketName) {
        this.bucketName = bucketName;
    }
    /**
    * 初始化MinioClient并纳入IOC容器中
    */
    @Override
    public MinioOptions getObject() throw Exception{
        //创建MinioClient
        MinioClient client = MinioClient
            .builder()
            //服务器地址设置
            .endpoint(host)
            //账号密码设置
            .credentials(account,password)
            .build();
        //初始化桶
        //在调用MinioOptions类的构造参数时，会执行初始化桶的方法来实现初始化桶
        MinioOptions options = new MinioOptions(client,bucketName);
        return options;
    }
    
    @Override
    public Class<?> getObjectType(){
        return MinioOptions.class;
    }
}
```

#### 3.编写MinioConfig配置类

> 编写MinioConfig配置类来装配MinioFactoryBean工厂并设置属性的值

```java
@Configuration
public class MinioConfig{
    /**
    * 装配MinioFactoryBean
    */
    @Bean
    public MinioFactoryBean minioClient(){
        MinioFactoryBean factoryBean = new MinioFactoryBean();
        minioFactoryBean.setHost("http://127.0.0.1:9000");
        minioFactoryBean.setAccount("csy");
        minioFactoryBean.setPassword("csy11348336");
        minioFactoryBean.setBucketName("myapp");
        return minioFactoryBean;
    }
}
```

#### 4.编写MinioOptions类

> 编写MinioOptions类用于提供上传文件和初始化桶的方法

```java
public class MinioOptions{
    /**
    * MinioClient对象，用于提供创建桶和文件上传API
    */
    private MinioClient client;
    /**
    * 桶名
    */
    private String bucketName;
    
    /**
    * 提供构造方法用于给两个属性初始化值和初始化桶
    */
    public MinioOptions(MinioClient client,String bucketName){
        this.client = client;
        this.bucketName = bucketName;
        initBucket();
    }
    
    /**
    * 文件上传方法
    * path : 上传的文件路径 如：image/head.jpg
    * contentType : 上传的文件类型
    * size : 上传的文件大小
    * input : 文件输入流
    */
    public void upload(String path,String contentType,long size,InputStream input){
        try{
            client.putObject(PutObjectArgs.builder()
                             .bucket(bucketName)
                             .object(path)
                             .contentType(contentType)
                             .stream(input,size,-1).build());
        }catch(Exception e){
            throw new RuntimeException("upload fail:"+e);
        }
    }
    
    /**
    * 初始化桶
    */
    protected void initBucket(){
        try{
            //指定桶不存在则创建
            if(!client.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())){
                client.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            }
        }catch(Exception e){
            throw new RuntimeException("initBucket fail:"+e);
        }
    }
}
```

#### 5.编写UploadController

> 实现上传接口

```java
@RestController
@AllArgsConstructor
public class UploadController extends BaseController {
    private MinioOptions options;

    @PostMapping("/upload/{path}")
    public ResultVO upload(@PathVariable("path") String path,
                           @RequestParam("file") MultipartFile[] files) throws Exception {
        for (MultipartFile file : files) {
            //获取文件名
            String filename = file.getOriginalFilename();
            //获取文件类型
            String contentType = file.getContentType();
            //获取文件大小
            long size = file.getSize();
            //获取文件输入流
            InputStream in = file.getInputStream();
            //上传到minio的文件服务器
            options.upload(path + "/" + filename,contentType,size,in);
        }
        return success();
    }

}
```