# minio-study

**Repository Path**: juneforgitee/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**: 2024-04-02
- **Last Updated**: 2024-05-31

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 一、安装

1.  通过docker 安装minio

```shell
docker pull minio/minio
```

2.  创建挂载点

   ```shell
   mkdir -p /opt/docker/minio/data
   ```

3.  启动

   ```shell
   #浏览器colsole:9001端口，api端口:9000,MINIO_ROOT_USER和MINIO_ROOT_PASSWORD指定账号密码
   docker run -d \-p 9000:9000 \-p 9001:9001 \--name minio --restart=always --privileged=true \-v /opt/docker/minio/data:/data \-e "MINIO_ROOT_USER=minio" \-e "MINIO_ROOT_PASSWORD=minio123" \minio/minio server /data --console-address ":9001"
   ```
   
4. 其他说明

   ```tex
   OPTIONS参数说明：
   -a stdin: 指定标准输入输出内容类型，可选 STDIN/STDOUT/STDERR 三项；
   -d: 后台运行容器，并返回容器ID；
   -i: 以交互模式运行容器，通常与 -t 同时使用；
   -P: 随机端口映射，容器内部端口随机映射到主机的端口
   -p: 指定端口映射，格式为：主机（宿主）端口:容器端口
   -t: 为容器重新分配一个伪输入终端，通常与 -i 同时使用；
   name=“nginx-lb”: 为容器指定一个名称；
   dns 8.8.8.8: 指定容器使用的DNS服务器，默认和宿主一致；
   dns-search example.com: 指定容器DNS搜索域名，默认和宿主一致；
   -h “mars”: 指定容器的hostname；
   -e username=“ritchie”: 设置环境变量；
   env-file=[]: 从指定文件读入环境变量；
   cpuset=“0-2” or cpuset=“0,1,2”: 绑定容器到指定CPU运行；
   -m :设置容器使用内存最大值；
   net=“bridge”: 指定容器的网络连接类型，支持 bridge/host/none/container: 四种类型；
   link=[]: 添加链接到另一个容器；
   expose=[]: 开放一个端口或一组端口；
   volume , -v: 绑定一个卷
   例如，使用docker镜像nginx:latest以后台模式启动一个容器,并将容器命名为mynginx：
   docker run name mynginx -d nginx:latest
   使用镜像nginx:latest以后台模式启动一个容器,并将容器的80端口映射到主机随机端口：
   docker run -P -d nginx:latest
   使用镜像 nginx:latest，以后台模式启动一个容器,将容器的 80 端口映射到主机的 80 端口,主机的目录 /data 映射到容器的 /data：
   docker run -p 80:80 -v /data:/data -d nginx:latest
   绑定容器的 8080 端口，并将其映射到本地主机 127.0.0.1 的 80 端口上：
   docker run -p 127.0.0.1:80:8080/tcp ubuntu bash
   使用镜像nginx:latest以交互模式启动一个容器,在容器内执行/bin/bash命令：
   docker run -it nginx:latest /bin/bash
   ```

# 二、SpringBoot整合Minio

## 1. 依赖

```xml
 <!--minio-->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>8.4.0</version>
</dependency>
<!--hutool-->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.26</version>
</dependency>
<!--swagger-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>3.0.0</version>
</dependency>
```

## 2. yml配置

```yml
minio:
  endpoint: http://127.0.0.1:9000 #Minio服务所在地址
  bucketName: tulaoda #存储桶名称
  accessKey:  #访问的key
  secretKey:  #访问的秘钥
```

## 3.配置类

```java
@Data
@Configuration
@ConfigurationProperties(prefix = "minio")
public class MinioConfig {

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

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

## 4.minio工具类

```java
import io.minio.messages.Bucket;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.stream.Collectors;

/**
 * File: MinioController
 * Author: QiYue WU
 * Date: 2024/4/2 13:51
 * Description:
 */
@Api(tags = "文件相关接口")
@RestController
@RequiredArgsConstructor
@RequestMapping("/minio")
public class MinioController {

    private final MinioUtil minioUtil;

    private final MinioConfig minioConfig;

    @ApiOperation(value = "查看存储bucket是否存在")
    @GetMapping("/bucketExists")
    public AjaxResult bucketExists(@RequestParam("bucketName") String bucketName) {
        return AjaxResult.success(bucketName + ":" + (minioUtil.bucketExists(bucketName) ? "存在" : "不存在"));
    }

    @ApiOperation(value = "创建存储bucket")
    @GetMapping("/makeBucket")
    public AjaxResult makeBucket(String bucketName) {
        return AjaxResult.success("bucketName", minioUtil.makeBucket(bucketName));
    }

    @ApiOperation(value = "删除存储bucket")
    @GetMapping("/removeBucket")
    public AjaxResult removeBucket(String bucketName) {
        return AjaxResult.success("bucketName", minioUtil.removeBucket(bucketName));
    }

    @ApiOperation(value = "获取全部bucket")
    @GetMapping("/getAllBuckets")
    public AjaxResult getAllBuckets() {
        List<Bucket> allBuckets = minioUtil.getAllBuckets();
        //查询name
        List<String> buckets = allBuckets.stream().
                map(Bucket::name).collect(Collectors.toList());
        return AjaxResult.success("allBuckets", buckets);
    }

    @ApiOperation(value = "文件上传返回url")
    @PostMapping("/upload")
    public AjaxResult upload(@RequestParam("file") MultipartFile file) {
        String objectName = minioUtil.upload(file);
        if (null != objectName) {
            return AjaxResult.success("url", (minioConfig.getEndpoint() + "/" + minioConfig.getBucketName() + "/" + objectName));
        }
        return AjaxResult.error("上传失败");
    }

    @ApiOperation(value = "图片/视频预览")
    @GetMapping("/preview")
    public AjaxResult preview(@RequestParam("fileName") String fileName) {
        return AjaxResult.success("filleName", minioUtil.preview(fileName));
    }

    @ApiOperation(value = "文件下载")
    @GetMapping("/download")
    public AjaxResult download(@RequestParam("fileName") String fileName, HttpServletResponse res) {
        minioUtil.download(fileName, res);
        return AjaxResult.success("文件下载成功");
    }

    @ApiOperation(value = "删除文件", notes = "根据url地址删除文件")
    @PostMapping("/delete")
    public AjaxResult remove(String url) {
        String objName = url.substring(url.lastIndexOf(minioConfig.getBucketName() + "/") + minioConfig.getBucketName().length() + 1);
        minioUtil.remove(objName);
        return AjaxResult.success("objName", objName);
    }


}
```

## 5.接口

```java
import io.minio.messages.Bucket;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.util.List;

/**
 * File: MinioController
 * Author: QiYue WU
 * Date: 2024/4/2 13:51
 * Description:
 */
@Api(tags = "文件相关接口")
@RestController
@RequiredArgsConstructor
@RequestMapping("/minio")
public class MinioController {

    private final MinioUtil minioUtil;

    private final MinioConfig minioConfig;

    @ApiOperation(value = "查看存储bucket是否存在")
    @GetMapping("/bucketExists")
    public AjaxResult bucketExists(@RequestParam("bucketName") String bucketName) {
        return AjaxResult.success("bucketName",minioUtil.bucketExists(bucketName));
    }

    @ApiOperation(value = "创建存储bucket")
    @GetMapping("/makeBucket")
    public AjaxResult makeBucket(String bucketName) {
        return AjaxResult.success("bucketName",minioUtil.makeBucket(bucketName));
    }

    @ApiOperation(value = "删除存储bucket")
    @GetMapping("/removeBucket")
    public AjaxResult removeBucket(String bucketName) {
        return AjaxResult.success("bucketName",minioUtil.removeBucket(bucketName));
    }

    @ApiOperation(value = "获取全部bucket")
    @GetMapping("/getAllBuckets")
    public AjaxResult getAllBuckets() {
        List<Bucket> allBuckets = minioUtil.getAllBuckets();
        return AjaxResult.success("allBuckets",allBuckets);
    }

    @ApiOperation(value = "文件上传返回url")
    @PostMapping("/upload")
    public AjaxResult upload(@RequestParam("file") MultipartFile file) {
        String objectName = minioUtil.upload(file);
        if (null != objectName) {
            return AjaxResult.success("url",(minioConfig.getEndpoint() + "/" + minioConfig.getBucketName() + "/" + objectName));
        }
        return AjaxResult.error("上传失败");
    }

    @ApiOperation(value = "图片/视频预览")
    @GetMapping("/preview")
    public AjaxResult preview(@RequestParam("fileName") String fileName) {
        return AjaxResult.success("filleName",minioUtil.preview(fileName));
    }

    @ApiOperation(value = "文件下载")
    @GetMapping("/download")
    public AjaxResult download(@RequestParam("fileName") String fileName, HttpServletResponse res) {
        minioUtil.download(fileName,res);
        return AjaxResult.success("文件下载成功");
    }

    @ApiOperation(value = "删除文件", notes = "根据url地址删除文件")
    @PostMapping("/delete")
    public AjaxResult remove(String url) {
        String objName = url.substring(url.lastIndexOf(minioConfig.getBucketName()+"/") + minioConfig.getBucketName().length()+1);
        minioUtil.remove(objName);
        return AjaxResult.success("objName",objName);
    }

}
```

# 三、其他

## 1. 文件过大无法上传

```yaml
spring:
  servlet:
    multipart:
      max-file-size: 100MB
      max-request-size: 100MB
```

## 2.accesskey和secret

通过访问`9001`端口，依次找到：`Administrator->Identity->Users->createUser`

创建用户并授权，保存key和密钥到本地,保存到yaml文件

## 3.AjaxResult

```java
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class AjaxResult implements Serializable {
    private Integer status;

    private String msg;

    private Object data;

    public static AjaxResult success(){
        return new AjaxResult(200, "success", null);
    }

    public static AjaxResult success(Object data){
        return new AjaxResult(200, "success", data);
    }

    public static AjaxResult success(String msg, Object data){
        return new AjaxResult(200, msg, data);
    }

    public static AjaxResult success(Integer status, String msg, Object data){
        return new AjaxResult(status, msg, data);
    }

    public static AjaxResult error(String msg){
        return new AjaxResult(500, msg, null);
    }

    public static AjaxResult error(Integer status, String msg){
        return new AjaxResult(status, msg, null);
    }
}
```

## 4.文件无法访问

进入Colsole,依次找到:`Administrator->Bucket->你的桶名称->Summary->Access Policy`

将访问权限改成public后所有人可访问