centos服务器常用网站部署工具安装（docker），包含minio工具类

目录

redis安装

minio文件服务器

rabbitmq安装

mysql安装

 

nginx安装

docker的基本使用

导出和导入容器

minio版本7.0.2（springboot）

 

---

官方脚本安装docker

curl -fsSL https://get.docker.com | bash -s docker --mirror aliyun

redis安装

docker安装radis并配置密码和自启动

docker run --name redis -p 6379:6379 -d --restart=always redis:latest redis-server --appendonly yes --requirepass "123456"

 

minio文件服务器

-minio的相当于自己搭配的oss服务器

1.搜索镜像

docker search minio

2.拉取镜像

docker pull minio/minio

 3.自定义用户名和密码 并设置自启动

docker search minio
docker pull minio/minio
docker run -p 9000:9000 --name minio \
-d --restart=always \
-e "MINIO_ACCESS_KEY=superchen" \
-e "MINIO_SECRET_KEY=superchen" \
-v /home/data:/data \
-v /home/config:/root/.minio \
minio/minio server /data
# -p 端口映射  将外部端口 映射到 容器内部端口  
# --name 自定义容器名称
# -di 后台运行的方式运行
# --restart=always  一旦docker重启或者开启时，也自动启动镜像
# -e 设置系统变量  在这里是设置Minio的ACCESS_KEY和SECRET_KEY
# -v 挂载文件  将系统文件  映射到  容器内部对应的文件夹

4.查看安装logs信息

docker logs dockerid

5.登录

http://ip地址:9000

rabbitmq安装

拉取rabbitmq镜像（rabbitmq 后面不带management，启动rabbitmq后是无法打开管理界面的，所以我们要下载带management插件的rabbitmq）

docker pull rabbitmq:management

docker run -d --hostname my-rabbit --name rabbit -v /data/rabbitmq:/var/lib/rabbitmq -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin -p 15672:15672 -p 5672:5672 rabbitmq:management

去除设置账号和密码(默认账号guest,密码guest)

docker run -d --hostname my-rabbit --name rabbit -v /data/rabbitmq:/var/lib/rabbitmq -p 15672:15672 -p 5672:5672 rabbitmq:management

设置自启动 

docker update rabbitmq --restart=always

 

mysql安装

 docker pull mysql:latest

设置root密码为123456

docker run -itd --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=chenjing123! mysql

进入容器

docker exec -it mysql bash

登录mysql

mysql -u root -p
ALTER USER 'root'@'localhost' IDENTIFIED BY 'chenjing123!';

 

添加远程登录用户 

CREATE USER 'admin'@'%' IDENTIFIED WITH mysql_native_password BY 'chenjing123!';
GRANT ALL PRIVILEGES ON *.* TO 'admin'@'%';

nginx安装

拉取最新nginx

docker pull nginx:latest

 安装nginx

docker run --name nginx -p 8080:80 -d nginx

--name nginx-test：容器名称。
-p 8080:80： 端口进行映射，将本地 8080 端口映射到容器内部的 80 端口。
-d nginx： 设置容器在在后台一直运行。

设置docker自启动 

docker update nginx --restart=always

后续可以自行进入容器进行编辑配置操作 

docker的基本使用

docker pull 镜像

查看本地镜像

docker images

 查看被停止的容器

docker ps -a

进入容器id为 243c32535da7 并达到/bin/bash文件夹

docker exec -it 243c32535da7 /bin/bash

启动已被停止的容器myrunoob （此为name）或者使用docker ps 使用镜像id 

docker start myrunoob

停止运行中的容器myrunoob

docker stop myrunoob

重启容器myrunoob

docker restart myrunoob

删除容器

 docker rm -f myrunoob

导出和导入容器

导出容器

如果要导出本地某个容器，可以使用 docker export 命令。

docker export 1e560fca3906 > ubuntu.tar

导出容器 1e560fca3906 快照到本地文件 ubuntu.tar。

这样将导出容器快照到本地文件。

导入容器快照

可以使用 docker import 从容器快照文件中再导入为镜像，以下实例将快照文件 ubuntu.tar 导入到镜像 test/ubuntu:v1:

cat docker/ubuntu.tar | docker import - test/ubuntu:v1

此外，也可以通过指定 URL 或者某个目录来导入，例如：

docker import http://example.com/exampleimage.tgz example/imagerepo

minio版本7.0.2（springboot）

        
                io.minio
            minio
            7.0.2
        

采用网站的mvc结构，不建议用过新版本minio，考虑云成本和个别公司需要自己搭建文件服务器的采用minio

package com.example.server.controller;

import cn.hutool.core.util.StrUtil;
import com.example.server.config.MinioConfig;
import com.example.server.pojo.RespBean;
import com.example.server.service.MinioService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
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.annotation.Resource;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;

/**
 * 文件操作
 *
 * @author 小陈
 * @date 2021/3/30 17:49
 */
@Api(value="文件controller",tags={"文件操作"})
@RestController("/file")
public class UploadController {
    @Resource
    private MinioService minioService;

    @Resource
    private MinioConfig minioConfig;

    @ApiOperation(value = "上传文件")
    @PostMapping("/uploadFile")
    public RespBean uploadFile(@ApiParam(name = "file", value = "上传的文件", required = true)
                               @RequestParam("file") MultipartFile file,
                               @ApiParam(name = "bucketName", value = "对象存储桶名称")
                               @RequestParam(value = "bucketName",required = false) String bucketName,
                               @ApiParam(name = "isPublic", value = "对象存储桶的策略 是否是公共的文件桶")
                               @RequestParam(value = "isPublic",required = false) Boolean isPublic) {
        try {
            bucketName = StrUtil.isNotBlank(bucketName) ? bucketName : minioConfig.getBucketName();
            if (!minioService.bucketExists(bucketName)) {
                minioService.makeBucket(bucketName);
            }
            if (isPublic!=null&&isPublic==true) {
                String policy="{\"Version\":\"2012-10-17\",\"Statement\":" +
                        "[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]}" +
                        ",\"Action\":[\"s3:GetBucketLocation\",\"s3:ListBucket\",\"s3:ListBucketMultipartUploads\"]," +
                        "\"Resource\":[\"arn:aws:s3:::"+bucketName+"\"]}," +
                        "{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]}," +
                        "\"Action\":[\"s3:AbortMultipartUpload\",\"s3:DeleteObject\"," +
                        "\"s3:GetObject\",\"s3:ListMultipartUploadParts\",\"s3:PutObject\"]," +
                        "\"Resource\":[\"arn:aws:s3:::"+bucketName+"/*\"]}]}";
                minioService.setBucketPolicy(bucketName,policy);
            }
            String fileName = file.getOriginalFilename();
            String objectName = new SimpleDateFormat("yyyy/MM/dd/").format(new Date()) + UUID.randomUUID().toString().replaceAll("-", "")
                    + fileName.substring(fileName.lastIndexOf("."));

            InputStream inputStream = file.getInputStream();
            minioService.putObject(bucketName, objectName, inputStream);
            inputStream.close();
            return RespBean.success("上传成功！",minioService.getObjectUrl(bucketName, objectName));
        } catch (Exception e) {
            e.printStackTrace();
            return RespBean.error("上传失败！");
        }
    }
    @ApiOperation(value = "删除minio文件")
    @DeleteMapping("/deleteFile")
    public R deleteFile(@ApiParam(name = "objectName", value = "上传的文件的全路径", required = true) @RequestParam("objectName") String objectName,@ApiParam(name = "bucketName", value = "对象存储桶名称") @RequestParam(value = "bucketName",required = false)  String bucketName) {
        try {
            bucketName = StringUtils.isNotBlank(bucketName) ? bucketName : minioConfig.getBucketName();
            return RespBean.success( minioService.removeObject(bucketName, objectName));
        } catch (Exception e) {
            e.printStackTrace();
            return RespBean.error("删除失败");
        }
    }
    @ApiOperation(value = "下载minio文件")
    @PostMapping("/downloadFile")
    public R downloadFile(@ApiParam(name = "bucketName", value = "对象存储桶名称", required = false) @RequestParam(value = "bucketName",required = false) String bucketName, @ApiParam(name = "fileName", value = "文件路径",required = true) @RequestParam(value = "fileName") String fileName,HttpServletResponse response) {
        try {
            bucketName = StringUtils.isNotBlank(bucketName) ? bucketName : minioConfig.getBucketName();
            minioService.downloadFile(bucketName, fileName,response);
            return RespBean.success( );
        } catch (Exception e) {
            e.printStackTrace();
            return RespBean.error("删除失败");
        }
    }

    @ApiOperation(value = "列出所有存储桶")
    @GetMapping("/listBuckets")
    public R listBuckets() {
        try {
            List bucketList=minioService.listBuckets();
            return RespBean.success(bucketList.stream().map(Bucket::name).toArray());
        } catch (Exception e) {
            e.printStackTrace();
            return RespBean.error("列出所有存储桶失败");
        }
    }

    @ApiOperation(value = "列出存储桶中的所有对象名称")
    @GetMapping("/listObjectNames")
    public R listObjectNames(@ApiParam(name = "bucketName", value = "对象存储桶名称", required = true) @RequestParam(value = "bucketName") String bucketName) {
        try {
            return RespBean.success(minioService.listObjectNames(bucketName));
        } catch (Exception e) {
            e.printStackTrace();
            return RespBean.error("列出存储桶中的所有对象名称失败");
        }
    }
    @ApiOperation(value = "获取存储桶的策略")
    @GetMapping("/getBucketPolicy")
    public R getBucketPolicy(@ApiParam(name = "bucketName", value = "对象存储桶名称", required = true) @RequestParam(value = "bucketName") String bucketName) {
        try {
            return RespBean.success(minioService.getBucketPolicy(bucketName));
        } catch (Exception e) {
            e.printStackTrace();
            return RespBean.error("获取存储桶的策略失败");
        }
    }
    @ApiOperation(value = "获取文件链接")
    @GetMapping("/presignedGetObject")
    public R presignedGetObject(@ApiParam(name = "bucketName", value = "对象存储桶名称", required = true) @RequestParam(value = "bucketName") String bucketName,@ApiParam(name = "objectName", value = "存储桶里的对象名称", required = true) @RequestParam(value = "objectName") String objectName,@ApiParam(name = "expires", value = "过期时间") @RequestParam(value = "expires",required = false) Integer expires) {
        try {
            expires=expires!=null? expires : (60 * 60 * 24 * 7);
            return RespBean.success(minioService.presignedGetObject(bucketName,objectName,expires));
        } catch (Exception e) {
            e.printStackTrace();
            return RespBean.error("获取存储桶的策略失败");
        }
    }
}

package com.example.server.common.utils;

import io.minio.MinioClient;
import io.minio.ObjectStat;
import io.minio.PutObjectOptions;
import io.minio.Result;
import io.minio.errors.ErrorResponseException;
import io.minio.errors.InvalidExpiresRangeException;
import io.minio.messages.Bucket;
import io.minio.messages.DeleteError;
import io.minio.messages.Item;
import lombok.SneakyThrows;
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.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;

/**
 * minio util
 *
 * @author chen
 * @date 2020/8/18
 */
@Component
public class MinioUtils {

    @Autowired
    private MinioClient minioClient;

    private final int DEFAULT_EXPIRY_TIME = 7 * 24 * 3600;

    /**
     * 检查存储桶是否存在
     *
     * @param bucketName 存储桶名称
     * @return
     */
    @SneakyThrows
    public boolean bucketExists(String bucketName) {
        boolean flag = false;
        flag = minioClient.bucketExists(bucketName);
        if (flag) {
            return true;
        }
        return false;
    }

    /**
     * 创建存储桶
     *
     * @param bucketName 存储桶名称
     */
    @SneakyThrows
    public boolean makeBucket(String bucketName) {
        boolean flag = bucketExists(bucketName);
        if (!flag) {
            minioClient.makeBucket(bucketName);
            return true;
        } else {
            return false;
        }
    }

    /**
     * 列出所有存储桶名称
     *
     * @return
     */
    @SneakyThrows
    public List listBucketNames() {
        List bucketList = listBuckets();
        List bucketListName = new ArrayList<>();
        for (Bucket bucket : bucketList) {
            bucketListName.add(bucket.name());
        }
        return bucketListName;
    }

    /**
     * 列出所有存储桶
     *
     * @return
     */
    @SneakyThrows
    public List listBuckets() {
        return minioClient.listBuckets();
    }

    /**
     * 删除存储桶
     *
     * @param bucketName 存储桶名称
     * @return
     */
    @SneakyThrows
    public boolean removeBucket(String bucketName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            Iterable> myObjects = listObjects(bucketName);
            for (Result result : myObjects) {
                Item item = result.get();
                // 有对象文件，则删除失败
                if (item.size() > 0) {
                    return false;
                }
            }
            // 删除存储桶，注意，只有存储桶为空时才能删除成功。
            minioClient.removeBucket(bucketName);
            flag = bucketExists(bucketName);
            if (!flag) {
                return true;
            }

        }
        return false;
    }

    /**
     * 列出存储桶中的所有对象名称
     *
     * @param bucketName 存储桶名称
     * @return
     */
    @SneakyThrows
    public List listObjectNames(String bucketName) {
        List listObjectNames = new ArrayList<>();
        boolean flag = bucketExists(bucketName);
        if (flag) {
            Iterable> myObjects = listObjects(bucketName);
            for (Result result : myObjects) {
                Item item = result.get();
                listObjectNames.add(item.objectName());
            }
        }
        return listObjectNames;
    }

    /**
     * 列出存储桶中的所有对象
     *
     * @param bucketName 存储桶名称
     * @return
     */
    @SneakyThrows
    public Iterable> listObjects(String bucketName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            return minioClient.listObjects(bucketName);
        }
        return null;
    }

    /**
     * 通过文件上传到对象
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     * @param fileName   File name
     * @return
     */
    @SneakyThrows
    public boolean putObject(String bucketName, String objectName, String fileName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            minioClient.putObject(bucketName, objectName, fileName, null);
            ObjectStat statObject = statObject(bucketName, objectName);
            if (statObject != null && statObject.length() > 0) {
                return true;
            }
        }
        return false;

    }

    /**
     * 文件上传
     *
     * @param bucketName
     * @param multipartFile
     */
    @SneakyThrows
    public void putObject(String bucketName, MultipartFile multipartFile, String filename) {
        PutObjectOptions putObjectOptions = new PutObjectOptions(multipartFile.getSize(), PutObjectOptions.MIN_MULTIPART_SIZE);
        putObjectOptions.setContentType(multipartFile.getContentType());
        minioClient.putObject(bucketName, filename, multipartFile.getInputStream(), putObjectOptions);
    }

    /**
     * 通过InputStream上传对象
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     * @param stream     要上传的流
     * @return
     */
    @SneakyThrows
    public boolean putObject(String bucketName, String objectName, InputStream stream) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            minioClient.putObject(bucketName, objectName, stream, new PutObjectOptions(stream.available(), -1));
            ObjectStat statObject = statObject(bucketName, objectName);
            if (statObject != null && statObject.length() > 0) {
                return true;
            }
        }
        return false;
    }

    /**
     * 以流的形式获取一个文件对象
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     * @return
     */
    @SneakyThrows
    public InputStream getObject(String bucketName, String objectName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            ObjectStat statObject = statObject(bucketName, objectName);
            if (statObject != null && statObject.length() > 0) {
                InputStream stream = minioClient.getObject(bucketName, objectName);
                return stream;
            }
        }
        return null;
    }

    /**
     * 以流的形式获取一个文件对象（断点下载）
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     * @param offset     起始字节的位置
     * @param length     要读取的长度 (可选，如果无值则代表读到文件结尾)
     * @return
     */
    @SneakyThrows
    public InputStream getObject(String bucketName, String objectName, long offset, Long length) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            ObjectStat statObject = statObject(bucketName, objectName);
            if (statObject != null && statObject.length() > 0) {
                InputStream stream = minioClient.getObject(bucketName, objectName, offset, length);
                return stream;
            }
        }
        return null;
    }

    /**
     * 下载并将文件保存到本地
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     * @param fileName   File name
     * @return
     */
    @SneakyThrows
    public boolean getObject(String bucketName, String objectName, String fileName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            ObjectStat statObject = statObject(bucketName, objectName);
            if (statObject != null && statObject.length() > 0) {
                minioClient.getObject(bucketName, objectName, fileName);
                return true;
            }
        }
        return false;
    }

    /**
     * 删除一个对象
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     */
    @SneakyThrows
    public boolean removeObject(String bucketName, String objectName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            minioClient.removeObject(bucketName, objectName);
            return true;
        }
        return false;
    }
    /**
     * 设置存储桶的策略
     *
     * @param bucketName 存储桶名称
     */
    @SneakyThrows
    public void setBucketPolicy(String bucketName,String policy) {
        minioClient.setBucketPolicy(bucketName, policy);
    }
    /**
     * 获取存储桶的策略
     *
     * @param bucketName 存储桶名称
     */
    @SneakyThrows
    public String getBucketPolicy(String bucketName) {
        return minioClient.getBucketPolicy(bucketName);
    }

    /**
     * 删除指定桶的多个文件对象,返回删除错误的对象列表，全部删除成功，返回空列表
     *
     * @param bucketName  存储桶名称
     * @param objectNames 含有要删除的多个object名称的迭代器对象
     * @return
     */
    @SneakyThrows
    public List removeObject(String bucketName, List objectNames) {
        List deleteErrorNames = new ArrayList<>();
        boolean flag = bucketExists(bucketName);
        if (flag) {
            Iterable> results = minioClient.removeObjects(bucketName, objectNames);
            for (Result 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
     */
    @SneakyThrows
    public String presignedGetObject(String bucketName, String objectName, Integer expires) {
        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);
            }
            url = minioClient.presignedGetObject(bucketName, objectName, expires);
        }
        return url;
    }

    /**
     * 生成一个给HTTP PUT请求用的presigned URL。
     * 浏览器/移动端的客户端可以用这个URL进行上传，即使其所在的存储桶是私有的。这个presigned URL可以设置一个失效时间，默认值是7天。
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     * @param expires    失效时间（以秒为单位），默认是7天，不得大于七天
     * @return
     */
    @SneakyThrows
    public String presignedPutObject(String bucketName, String objectName, Integer expires) {
        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);
            }
            url = minioClient.presignedPutObject(bucketName, objectName, expires);
        }
        return url;
    }

    /**
     * 获取对象的元数据
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     * @return
     */
    @SneakyThrows
    public ObjectStat statObject(String bucketName, String objectName) {
        boolean flag = bucketExists(bucketName);
        if (flag) {
            ObjectStat statObject = minioClient.statObject(bucketName, objectName);
            return statObject;
        }
        return null;
    }

    /**
     * 文件访问路径
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     * @return
     */
    @SneakyThrows
    public String getObjectUrl(String bucketName, String objectName) {
        boolean flag = bucketExists(bucketName);
        String url = "";
        if (flag) {
            url = minioClient.getObjectUrl(bucketName, objectName);
        }
        return url;
    }



    public void downloadFile(String bucketName, String fileName,  HttpServletResponse response) {
        try {

            InputStream file = minioClient.getObject(bucketName, fileName);
            String filename = new String(fileName.getBytes("ISO8859-1"), StandardCharsets.UTF_8);
            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) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

 

package com.example.server.service;
import io.minio.messages.Bucket;
import org.springframework.web.multipart.MultipartFile;

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

/**
 * minio service
 *
 * @author 小陈
 * @date 2021/3/30 2:43
 */

public interface MinioService {


    /**
     * 判断 bucket是否存在
     *
     * @param bucketName
     * @return
     */
    boolean bucketExists(String bucketName);

    /**
     * 创建 bucket
     *
     * @param bucketName
     */
    void makeBucket(String bucketName);
    /**
     * 设置bucket的策略
     *
     * @param bucketName
     * @param policy
     */
    void setBucketPolicy(String bucketName,String policy);
    /**
     * 文件上传
     *
     * @param bucketName
     * @param objectName
     * @param filename
     */
    void putObject(String bucketName, String objectName, String filename);

    /**
     * 文件上传
     *
     * @param bucketName
     * @param objectName
     * @param stream
     */
    void putObject(String bucketName, String objectName, InputStream stream);

    /**
     * 文件上传
     *
     * @param bucketName
     * @param multipartFile
     */
    void putObject(String bucketName, MultipartFile multipartFile, String filename);

    /**
     * 删除文件
     * @param bucketName
     * @param objectName
     */
    boolean removeObject(String bucketName, String objectName);

    /**
     * 下载文件
     *
     * @param fileName
     * @param response
     */
    void downloadFile(String bucketName, String fileName, HttpServletResponse response);

    /**
     * 获取文件路径
     * @param bucketName
     * @param objectName
     * @return
     */
    String getObjectUrl(String bucketName, String objectName);
    /**
     * 列出所有存储桶
     *
     * @return
     */
    List listBuckets();
    /**
     * 列出存储桶中的所有对象名称
     *
     * @param bucketName 存储桶名称
     * @return
     */
    List listObjectNames(String bucketName);
    /**
     * 获取存储桶的策略
     *
     * @param bucketName 存储桶名称
     */
    String getBucketPolicy(String bucketName) ;
    /**
     * 获取文件链接
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     * @param expires 超过期时间
     */
    String presignedGetObject(String bucketName, String objectName, Integer expires);
}

package com.example.server.service.impl;

import com.example.server.service.MinioService;
import com.example.server.common.utils.MinioUtils;
import io.minio.messages.Bucket;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

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

/**
 * mini 实现
 *
 * @author 小陈
 * @date 2021/3/30 2:45
 */

@Service
public class MinioServiceImpl implements MinioService {

    @Autowired
    private MinioUtils minioUtil;

    /**
     * 判断 bucket是否存在
     *
     * @param bucketName
     * @return
     */
    @Override
    public boolean bucketExists(String bucketName) {
        return minioUtil.bucketExists(bucketName);
    }

    /**
     * 创建 bucket
     *
     * @param bucketName
     */
    @Override
    public void makeBucket(String bucketName) {
        minioUtil.makeBucket(bucketName);

    }
    /**
     * 设置bucket的策略
     *
     * @param bucketName
     * @param policy
     */
    @Override
    public void setBucketPolicy(String bucketName, String policy) {
        minioUtil.setBucketPolicy(bucketName,policy);
    }
    /**
     * 获取存储桶的策略
     *
     * @param bucketName 存储桶名称
     */
    @Override
    public String getBucketPolicy(String bucketName) {
        return minioUtil.getBucketPolicy(bucketName);
    }
    /**
     * 获取文件链接
     *
     * @param bucketName 存储桶名称
     * @param objectName 存储桶里的对象名称
     * @param expires 超过期时间
     */
    @Override
    public String presignedGetObject(String bucketName, String objectName, Integer expires) {
        return minioUtil.presignedGetObject(bucketName,objectName,expires);
    }

    /**
     * 文件上传
     *
     * @param bucketName
     * @param objectName
     * @param filename
     */
    @Override
    public void putObject(String bucketName, String objectName, String filename) {
        minioUtil.putObject(bucketName, objectName, filename);
    }


    @Override
    public void putObject(String bucketName, String objectName, InputStream stream) {
        minioUtil.putObject(bucketName, objectName, stream);
    }

    /**
     * 文件上传
     *
     * @param bucketName
     * @param multipartFile
     */
    @Override
    public void putObject(String bucketName, MultipartFile multipartFile, String filename) {
        minioUtil.putObject(bucketName, multipartFile, filename);
    }

    /**
     * 删除文件
     * @param bucketName
     * @param objectName
     */
    @Override
    public boolean removeObject(String bucketName,String objectName) {
        return minioUtil.removeObject(bucketName,objectName);
    }

    /**
     * 下载文件
     *
     * @param fileName
     * @param response
     */
    @Override
    public void downloadFile(String bucketName, String fileName,  HttpServletResponse response) {
        minioUtil.downloadFile(bucketName,fileName, response);
    }

    /**
     * 获取文件路径
     * @param bucketName
     * @param objectName
     * @return
     */
    @Override
    public String getObjectUrl(String bucketName,String objectName) {
        return minioUtil.getObjectUrl(bucketName,objectName);
    }

    /**
     * 列出存储桶中的所有对象名称
     *
     * @param bucketName 存储桶名称
     * @return
     */
    @Override
    public List listObjectNames(String bucketName) {
        return minioUtil.listObjectNames(bucketName);
    }

    /**
     * 列出所有存储桶
     *
     * @return
     */
    @Override
    public List listBuckets() {
        return minioUtil.listBuckets();
    }

}