minio安装配置教程及整合springboot（史上最强保姆级教程---minio入门）
Posted 月熙_
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了minio安装配置教程及整合springboot（史上最强保姆级教程---minio入门）相关的知识，希望对你有一定的参考价值。
minio安装配置教程及整合springboot
- 1、进入minio官网
- 2、选择放置minio文件路径
- 3、根据命令行提示访问minio面板
- 4、minio配置（yaml文件版）
- 5、编写minio的配置文件MinIoClientConfig
- 6、新建minio工具类需要的实体类ObjectItem
- 7、编写minio的工具类MinioUtils
- 8、编写minio的Controller层MinioController
- 9.通过接口测试工具测试
1、进入minio官网
https://www.minio.org.cn/
点击下载（Download），选择自己需要的版本即可
2、选择放置minio文件路径
在此路径下，
新建文件夹minioData（与minio.exe处于同一路径）
在minio.exe文件夹的路径处输入cmd进入命令行界面（该exe文件不能双击运行）
输入命令：minio.exe server minioData全路径
例如：minio.exe server E:\\software\\minioData
后面路径为创建的minioData文件夹的路径
（如果上面命令执行的时候，命令框在疯狂跳动，就关闭该命令框，以管理员方式开启cmd窗口，进入自己的minio文件夹，执行上面的命令即可）
3、根据命令行提示访问minio面板
有多个url可以访问，但是其中固定的是127.0.0.1:9000
第一次访问，会进入登录页面，登录账户和密码均为minioadmin，
进入点击Create Bucket，bucket Name 建议设定为项目的名字，再点击Create Bucket即可，注意如果需要后期通过访问url预览，需要在新建的bucket Name点击Manage，点击AccessPolicy后面的icon（图标），将访问权限改为Public即可，在项目运行中必须开启minio服务，否则无法使用minion。
4、minio配置（yaml文件版）
spring:
# 配置文件上传大小限制（minio文件上传）
servlet:
multipart:
max-file-size: 200MB
max-request-size: 200MB
minio:
endpoint: http://127.0.0.1:9000
accessKey: minioadmin
secretKey: minioadmin
bucketName: community-web
如果前面有spring配置，只需要将spring的配置minio文件限制复制贴贴到spring下即可。
5、编写minio的配置文件MinIoClientConfig
package com.example.config;
import io.minio.MinioClient;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
@Data
@Component
public class MinIoClientConfig
@Value("$minio.endpoint")
private String endpoint;
@Value("$minio.accessKey")
private String accessKey;
@Value("$minio.secretKey")
private String secretKey;
/**
* 注入minio 客户端
*
* @return
*/
@Bean
public MinioClient minioClient()
return MinioClient.builder()
.endpoint(endpoint)
.credentials(accessKey, secretKey)
.build();
6、新建minio工具类需要的实体类ObjectItem
package com.example.sys.entity;
import lombok.Data;
@Data
public class ObjectItem
private String objectName;
private Long size;
7、编写minio的工具类MinioUtils
package com.example.utils;
import com.example.sys.entity.ObjectItem;
import io.minio.*;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import io.minio.messages.Item;
import org.apache.tomcat.util.http.fileupload.IOUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @description： minio工具类
* @version：1.0
*/
@Component
public class MinioUtils
@Autowired
private MinioClient minioClient;
@Value("$minio.bucketName")
private String bucketName;
/**
* description: 判断bucket是否存在，不存在则创建
*
* @return: void
*/
public void existBucket(String name)
try
boolean exists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(name).build());
if (!exists)
minioClient.makeBucket(MakeBucketArgs.builder().bucket(name).build());
catch (Exception e)
e.printStackTrace();
/**
* 创建存储bucket
*
* @param bucketName 存储bucket名称
* @return Boolean
*/
public Boolean makeBucket(String bucketName)
try
minioClient.makeBucket(MakeBucketArgs.builder()
.bucket(bucketName)
.build());
catch (Exception e)
e.printStackTrace();
return false;
return true;
/**
* 删除存储bucket
*
* @param bucketName 存储bucket名称
* @return Boolean
*/
public Boolean removeBucket(String bucketName)
try
minioClient.removeBucket(RemoveBucketArgs.builder()
.bucket(bucketName)
.build());
catch (Exception e)
e.printStackTrace();
return false;
return true;
/**
* description: 上传文件
*
* @param multipartFile
* @return: java.lang.String
*/
public List<String> upload(MultipartFile[] multipartFile)
List<String> names = new ArrayList<>(multipartFile.length);
for (MultipartFile file : multipartFile)
String fileName = file.getOriginalFilename();
String[] split = fileName.split("\\\\.");
if (split.length > 1)
fileName = split[0] + "_" + System.currentTimeMillis() + "." + split[1];
else
fileName = fileName + System.currentTimeMillis();
InputStream in = null;
try
in = file.getInputStream();
minioClient.putObject(PutObjectArgs.builder()
.bucket(bucketName)
.object(fileName)
.stream(in, in.available(), -1)
.contentType(file.getContentType())
.build()
);
catch (Exception e)
e.printStackTrace();
finally
if (in != null)
try
in.close();
catch (IOException e)
e.printStackTrace();
names.add(fileName);
return names;
/**
* description: 下载文件
*
* @param fileName
* @return: org.springframework.http.ResponseEntity<byte [ ]>
*/
public ResponseEntity<byte[]> download(String fileName)
ResponseEntity<byte[]> responseEntity = null;
InputStream in = null;
ByteArrayOutputStream out = null;
try
in = minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(fileName).build());
out = new ByteArrayOutputStream();
IOUtils.copy(in, out);
//封装返回值
byte[] bytes = out.toByteArray();
HttpHeaders headers = new HttpHeaders();
try
headers.add("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
catch (UnsupportedEncodingException e)
e.printStackTrace();
headers.setContentLength(bytes.length);
headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
headers.setAccessControlExposeHeaders(Arrays.asList("*"));
responseEntity = new ResponseEntity<byte[]>(bytes, headers, HttpStatus.OK);
catch (Exception e)
e.printStackTrace();
finally
try
if (in != null)
try
in.close();
catch (IOException e)
e.printStackTrace();
if (out != null)
out.close();
catch (IOException e)
e.printStackTrace();
return responseEntity;
/**
* 查看文件对象
*
* @param bucketName 存储bucket名称
* @return 存储bucket内文件对象信息
*/
public List<ObjectItem> listObjects(String bucketName)
Iterable<Result<Item>> results = minioClient.listObjects(
ListObjectsArgs.builder().bucket(bucketName).build());
List<ObjectItem> objectItems = new ArrayList<>();
try
for (Result<Item> result : results)
Item item = result.get();
ObjectItem objectItem = new ObjectItem();
objectItem.setObjectName(item.objectName());
objectItem.setSize(item.size());
objectItems.add(objectItem);
catch (Exception e)
e.printStackTrace();
return null;
return objectItems;
/**
* 批量删除文件对象
*
* @param bucketName 存储bucket名称
* @param objects 对象名称集合
*/
public Iterable<Result<DeleteError>> removeObjects(String bucketName, List<String> objects)
List<DeleteObject> dos = objects.stream().map(e -> new DeleteObject(e)).collect(Collectors.toList());
Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(dos).build());
return results;
8、编写minio的Controller层MinioController
package com.example.sys.controller;
import com.example.utils.MinioUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;
@RestController
@Slf4j
public class MinioController
@Autowired
private MinioUtils minioUtils;
@Value("$minio.endpoint")
private String address;
@Value("$minio.bucketName")
private String bucketName;
@PostMapping("/upload")
public Object upload(MultipartFile file)
List<String> upload = minioUtils.upload(new MultipartFile[]file);
return address + "/" + bucketName + "/" + upload.get(0);
9.通过接口测试工具测试
1）新建一个请求（Request）
2）请求方式修改为post
3）请求的url，项目访问路径/upload
例如：http://127.0.0.1:8080/upload
4)选择Body
5）选择Form-Data
6）填写key和value
第一个键值
key—>file
参数类型为file
value—>点击Select Files按钮，选择文件（建议图片）
第二个键值
key—>bucketName
参数类型：选择String
value—>个人设置的桶（bucketName）的名称
最后点击send，发送即可
通过响应的url，复制到浏览器，打开即可，一般打开即可预览到图片，有些电脑会直接下载图片。
对象存储服务MinIO安装，编写Starter整合，及永久链接配置
(目录)
对象存储服务MinIO
1 MinIO简介
MinIO兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几kb到最大5T不等。
S3 （ Simple Storage Service简单存储服务）
基本概念：
官网文档：http://docs.minio.org.cn/docs/
2 MinIO特点
3 开箱使用
3.1 安装启动
拉取minio镜像
docker pull minio/minio:RELEASE.2021-06-14T01-29-23Z
使用docker进行环境部署和启动
docker run -p 9090:9000 --name minio -d --restart=always -e "MINIO_ACCESS_KEY=minio" -e "MINIO_SECRET_KEY=minio123" -v /home/data:/data -v /home/config:/root/.minio minio/minio:RELEASE.2021-06-14T01-29-23Z server /data
3.2 管理控制台
进入系统后可以看到主界面
点击右下角的“+”号 ，点击下面的图标，创建一个桶
开启 读写权限
4 封装MinIO为starter
4.1 编写file-spring-boot-starter模块
新增依赖
<dependency>
<groupId>io.minio</groupId>
<artifactId>minio</artifactId>
<version>7.1.0</version>
</dependency>
4.2 编写配置类
MinIOConfig
import io.minio.MinioClient;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Data
@Configuration
@EnableConfigurationProperties(MinIOConfigProperties.class)
//当引入FileStorageService接口时
@ConditionalOnClass(FileStorageService.class)
public class MinIOConfig
@Autowired
private MinIOConfigProperties minIOConfigProperties;
@Bean
public MinioClient buildMinioClient()
return MinioClient
.builder()
.credentials(minIOConfigProperties.getAccessKey(),
minIOConfigProperties.getSecretKey())
.endpoint(minIOConfigProperties.getEndpoint())
.build();
MinIOConfigProperties
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import java.io.Serializable;
@Data
@ConfigurationProperties(prefix = "file.minio") // 文件上传 配置前缀file.minio
public class MinIOConfigProperties implements Serializable
private String accessKey;
private String secretKey;
private String bucket;
private String endpoint;
private String readPath;
4.3 编写 Service
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
/**
*
* @Description 文件上传接口
*/
public interface FileStorageService
/**
* @Description 文件上传
* @param prefix 文件上传前缀
* @param filename 文件名称
* @param inputStream 文件流
* @return pathUrl 全路径
*/
String store(String prefix, String filename, InputStream inputStream);
/**
* @Description 文件上传
* @param prefix 文件上传前缀
* @param filename 文件名称
* @param contentType 文件类型 "image/jpg" 或"text/html"
* @param inputStream 文件流
* @return pathUrl 全路径
*/
String store(String prefix, String filename,String contentType, InputStream inputStream);
/**
* @Description 文件删除
* @param pathUrl 全路径
* @throws Exception
*/
void delete(String pathUrl);
/**
* @Description 批量文件删除
* @param pathUrls 全路径集合
* @throws Exception
*/
void deleteBatch(List<String> pathUrls);
/**
* @Description 下载文件
* @param pathUrl 全路径
* @return
*/
InputStream downloadFile(String pathUrl);
/**
* @Description 获取文件文本内容
* @param pathUrl 全路径
* @return
* @throws IOException
*/
String getFileContent(String pathUrl) throws IOException;
4.4 编写实现类
import com.heima.file.config.MinIOConfig;
import com.heima.file.config.MinIOConfigProperties;
import com.heima.file.service.FileStorageService;
import io.minio.GetObjectArgs;
import io.minio.MinioClient;
import io.minio.PutObjectArgs;
import io.minio.RemoveObjectArgs;
import io.minio.RemoveObjectsArgs;
import io.minio.messages.DeleteObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Import;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
@Slf4j
@EnableConfigurationProperties(MinIOConfigProperties.class)
@Import(MinIOConfig.class)
@Component("minIOFileStorageService")
// 创建bean对象，bean name=minIOFileStorageService
public class MinIOFileStorageService implements FileStorageService
@Autowired
private MinioClient minioClient;
@Autowired
private MinIOConfigProperties minIOConfigProperties;
private final static String separator = "/";
/**
* @param dirPath
* @param filename yyyy/mm/dd/file.jpg
* @return
*/
public String builderFilePath(String dirPath,String filename)
StringBuilder stringBuilder = new StringBuilder(50);
if(!StringUtils.isEmpty(dirPath))
stringBuilder.append(dirPath).append(separator);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
String todayStr = sdf.format(new Date());
stringBuilder.append(todayStr).append(separator);
stringBuilder.append(filename);
return stringBuilder.toString();
/**
* 上传图片文件
* @param prefix 文件前缀
* @param filename 文件名
* @param contentType 文件类型 图片："image/jpg" html："text/html"
* @param inputStream 文件流
* @return 文件全路径
*/
@Override
public String store(String prefix, String filename, String contentType, InputStream inputStream)
String filePath = builderFilePath(prefix, filename);
try
PutObjectArgs putObjectArgs = PutObjectArgs.builder()
.object(filePath)
.contentType(contentType)
.bucket(minIOConfigProperties.getBucket()).stream(inputStream,inputStream.available(),-1)
.build();
minioClient.putObject(putObjectArgs);
StringBuilder urlPath = new StringBuilder();
urlPath.append(minIOConfigProperties.getBucket());
urlPath.append(separator);
urlPath.append(filePath);
return urlPath.toString();
catch (Exception ex)
log.error("minio put file error.",ex);
throw new RuntimeException("上传文件失败");
/**
* @param prefix 文件上传前缀
* @param filename 文件名称
* @param inputStream 文件流
* @return pathUrl 全路径
* @Description 文件上传
*/
@Override
public String store(String prefix, String filename, InputStream inputStream)
return this.store(prefix,filename,"image/jpg",inputStream);
/**
* 上传html文件
* @param prefix 文件前缀
* @param filename 文件名
* @param inputStream 文件流
* @return 文件全路径
*/
public String uploadHtmlFile(String prefix, String filename,InputStream inputStream)
String filePath = builderFilePath(prefix, filename);
try
PutObjectArgs putObjectArgs = PutObjectArgs.builder()
.object(filePath)
.contentType("text/html")
.bucket(minIOConfigProperties.getBucket()).stream(inputStream,inputStream.available(),-1)
.build();
minioClient.putObject(putObjectArgs);
StringBuilder urlPath = new StringBuilder(minIOConfigProperties.getReadPath());
urlPath.append(minIOConfigProperties.getBucket());
urlPath.append(separator);
urlPath.append(filePath);
return urlPath.toString();
catch (Exception ex)
log.error("minio put file error.",ex);
ex.printStackTrace();
throw new RuntimeException("上传文件失败");
/**
* 删除文件
* @param pathUrl 文件全路径
*/
@Override
public void delete(String pathUrl)
String key = pathUrl.replace(minIOConfigProperties.getEndpoint(),"");
int index = key.indexOf(separator);
String bucket = key.substring(0,index);
String filePath = key.substring(index+1);
// 删除Objects
RemoveObjectArgs removeObjectArgs = RemoveObjectArgs.builder()
.bucket(bucket).object(filePath).build();
try
minioClient.removeObject(removeObjectArgs);
catch (Exception e)
log.error("minio remove file error. pathUrl:",pathUrl);
e.printStackTrace();
/**
* @param pathUrls 全路径集合
* @throws Exception
* @Description 批量文件删除
*/
@Override
public void deleteBatch(List<String> pathUrls)
List<DeleteObject> objects = new LinkedList<>();
for (String pathUrl : pathUrls)
String key = pathUrl.replace(minIOConfigProperties.getEndpoint(),"");
int index = key.indexOf(separator);
// String bucket = key.substring(0,index);
String filePath = key.substring(index+1);
objects.add( new DeleteObject(filePath));
try
minioClient.removeObjects(
RemoveObjectsArgs.builder()
.bucket(minIOConfigProperties.getBucket())
.objects(objects).build());
catch (Exception e)
log.error("minio remove file error.");
e.printStackTrace();
/**
* 下载文件
* @param pathUrl 文件全路径
* @return 文件流
*
*/
@Override
public InputStream downloadFile(String pathUrl)
String key = pathUrl.replace(minIOConfigProperties.getEndpoint(),"");
int index = key.indexOf(separator);
String bucket = key.substring(0,index);
String filePath = key.substring(index+1);
InputStream inputStream = null;
try
inputStream = minioClient.getObject(GetObjectArgs.builder().bucket(minIOConfigProperties.getBucket()).object(filePath).build());
catch (Exception e)
log.error("minio down file error. pathUrl:",pathUrl);
e.printStackTrace();
return inputStream;
/**
* @param pathUrl 全路径
* @return
* @throws IOException
* @Description 获取文件文本内容
*/
@Override
public String getFileContent(String pathUrl) throws IOException
return null;
4.5 加入自动配置
在resources中新建META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\\
com.heima.file.service.impl.OSSAliyunFileStorageService,com.heima.file.service.impl.MinIOFileStorageService
4.6 其他微服务使用
第一，导入file-spring-boot-starter的依赖
第二，在配置中心 share-file.yml 中添加minio所需要的配置
#OSS配置
file:
oss:
bucket-name: <!-- 存储空间 -->
access-key-id: <!-- OSS密钥key -->
access-key-secret: <!-- OSS密钥 -->
endpoint: oss-cn-shanghai.aliyuncs.com
web-site: <!-- OSS访问前缀 -->
proxy-username: aliyun-sdk-java
socket-timeout: 10000
idle-connection-time: 10000
connection-request-timeout: 4000
max-connections: 2048
max-error-retry: 5
white-list: 127.0.0.1
connection-timeout: 10000
prefix: material
# minIO配置
minio:
accessKey: minio
secretKey: minio123
bucket: <!-- minIO中 bucket -->
endpoint: http://$spring.profiles.ip:9090/
readPath: http://$spring.profiles.ip:9090/
prefix: article
第三，在对应使用的业务类中注入FileStorageService，样例如下：
package com.heima.wemedia;
import com.heima.file.service.FileStorageService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import javax.annotation.Resource;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
@SpringBootTest
@RunWith(SpringRunner.class)
public class MinIoTest
// 指定MinIo实现
@Resource(name = "minIOFileStorageService")
FileStorageService fileStorageService;
// 不指定 beanName 注入的是OSS的实现
@Autowired
FileStorageService fileStorageService2;
@Test
public void uploadToMinIo() throws FileNotFoundException
System.out.println(fileStorageService);
System.out.println(fileStorageService2);
// 准备好一个静态页
FileInputStream fileInputStream = new FileInputStream("D://list.html");
// 将静态页上传到minIO文件服务器中 文件名称 文件类型 文件流
fileStorageService.store("test","list.html","text/html",fileInputStream);
上传成功并成功预览：
永久有效链接配置
1.Docker 获取 minio/mc容器
docker pull minio/mc:RELEASE.2021-06-13T17-48-22Z
2.Docker 启动 minio/mc容器
docker run -it --entrypoint=/bin/sh minio/mc:RELEASE.2021-06-13T17-48-22Z
启动之后 会直接 进入 sh-4.4# 输入mc version 查看版本信息
3.minio/mc 绑定 minio server服务
mc config host add <ALIAS> <YOUR-S3-ENDPOINT> <YOUR-ACCESS-KEY> <YOUR-SECRET-KEY> [--api API-SIGNATURE]
mc config host add minio http://IP地址:9000 admin adminminio --api S3v4
解释：
比如：
# 从MinIO服务获得URL、access key和secret key。
mc config host add minio http://192.168.200.130:9000 minio minio123 --api S3v4
绑定成功
4.mc命令
mc ls minio
5.设置桶或者目录的访问权限为public（设置公开访问 永久访问链接）
//将minio中，test-bucket存储桶下的public目录设置为公开可访问
mc policy set public minio/test-bucket/public
//将minio中，test-bucket2存储桶设置为公开可访问
mc policy set public minio/test-bucket2
mc policy set public minio/test
http://IP地址:9000/test/demo.png
以上是关于minio安装配置教程及整合springboot（史上最强保姆级教程---minio入门）的主要内容，如果未能解决你的问题，请参考以下文章