docker安装minio，springboot操作minio上传下载
1、下载镜像
下载指定版本需要去版本库查询下 https://hub.docker.com/r/minio/minio/tags
#下载最新版
docker pull minio/minio
docker pull minio/minio:RELEASE.2019-12-30T05-45-39Z
2、启动
这里会有不同版本的问题
22版以后的启动命令：
docker run -p 9000:9000 -p 9001:9001 --name minio \
-d --restart=always \
-e "MINIO_ROOT_USER=minioadmin" \ 账号
-e "MINIO_ROOT_PASSWORD=minioadmin" \ 密码
-v /opt/docker_minio/data:/data \ 数据挂载地址
-v /opt/docker_minio/config:/root/.minio \ 配置文件挂载地址
minio/minio:RELEASE.2022-01-08T03-11-54Z server /data \ 版本号地址
--console-address ":9000" --address ":9001" 监控端口
22版以前的启动命令
docker run -p 8900:9000 --name minio2019 \
-d --restart=always \
-e "MINIO_ACCESS_KEY=minioadmin" \
-e "MINIO_SECRET_KEY=minioadmin" \
-v /opt/docker_minio/data:/data \
-v /opt/docker_minio/config:/root/.minio \
minio/minio:RELEASE.2019-12-30T05-45-39Z server /data \
--address ":9000"
3.验证
ip+端口
这里也分为两种版本的jar包，整体区别不大。
**
旧版
**
1.引入jar
<!--minio-->
<dependency>
<groupId>io.minio</groupId>
<artifactId>minio</artifactId>
<version>7.0.2</version>
</dependency>
2.创建连接配置
import io.minio.MinioClient;
import javax.crypto.SecretKey;
import java.io.InputStream;
import java.security.KeyPair;
public interface MinioClientService {
/**
* 获取连接
* @return
*/
MinioClient getClient();
/**
* 以流的形式下载一个对象。
*/
void getFileInputStream(String fileName);
/**
* 下载对象指定区域的字节数组做为流。（断点下载）
* @param fileName
* @param offset 是起始字节的位置
* @param length 是要读取的长度 (可选，如果无值则代表读到文件结尾)。
*/
void getFileInputStream(String fileName, Long offset, Long length);
/**
* 下载并将文件保存到本地。
* @param fileName 目标名
* @param downloadFileName 下载文件名
*/
void getLocalFile(String fileName,String downloadFileName);
/**
* 在给定的存储桶中获取整个加密对象的数据作为InputStream，然后用传入的master key解密和加密对象关联的content key。
* 然后创建一个含有InputStream和Cipher的CipherInputStream。这个Cipher被初始为用于使用content key进行解密，
* 所以CipherInputStream会在返回数据前，尝试读取数据并进行解密。所以read()方法返回的是处理过的原始对象数据。
* CipherInputStream必须用完关闭，否则连接不会被释放。
* @param fileName
* @param key SecretKey类型的数据。
*/
void getMasterKeyFile( String fileName, SecretKey key);
/**
* 在给定的存储桶中获取整个加密对象的数据作为InputStream，然后用传入的master keyPair解密和加密对象关联的content key。
* 然后创建一个含有InputStream和Cipher的CipherInputStream。这个Cipher被初始为用于使用content key进行解密，
* 所以CipherInputStream会在返回数据前，尝试读取数据并进行解密。所以read()方法返回的是处理过的原始对象数据。
*
* CipherInputStream必须用完关闭，否则连接不会被释放。
* @param fileName
* @param key
*/
void getKeyPairFile(String fileName, KeyPair key);
/**
* 上传文件到桶-流
* @param stream
* @param
* @return
*/
String putFileForInputStream(String fileName, InputStream stream);
/**
* 获取连接前缀名称（到文件夹桶）
* @return
*/
String getClientPrefix();
}
import io.minio.MinioClient;
import io.minio.PutObjectOptions;
import io.minio.ServerSideEncryption;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
@Configuration
public class MinioClientServiceImpl implements MinioClientService {
@Value("${minio.url}")
public String url;
@Value("${minio.userName}")
public String userName;
@Value("${minio.password}")
public String password;
@Value("${minio.bucketName}")
public String bucketName;
/**
* 获取连接
* @return
*/
@Override
public MinioClient getClient(){
MinioClient minioClient = null ;
try {
// 使用MinIO服务的URL，端口，Access key和Secret key创建一个MinioClient对象
minioClient = new MinioClient(url, userName, password);
// 检查存储桶是否已经存在
boolean isExist = minioClient.bucketExists(bucketName);
if(!isExist) {
// 创建一个名为asiatrip的存储桶，用于存储照片的zip文件。
minioClient.makeBucket("weapon");
}
} catch(Exception e) {
System.out.println("Error occurred: " + e);
}
return minioClient;
}
/**
* 以流的形式下载一个对象。
*/
@Override
public void getFileInputStream(String fileName){
try {
MinioClient minioClient = getClient();
// 调用statObject()来判断对象是否存在。
// 如果不存在, statObject()抛出异常,
// 否则则代表对象存在。
minioClient.statObject(bucketName, fileName);
/**
* bucketName String 存储桶名称。
* objectName String 存储桶里的对象名称。
*/
InputStream stream = minioClient.getObject(bucketName, fileName);
// 读取输入流直到EOF并打印到控制台。
byte[] buf = new byte[16384];
int bytesRead;
while ((bytesRead = stream.read(buf, 0, buf.length)) >= 0) {
System.out.println(new String(buf, 0, bytesRead));
}
// 关闭流，此处为示例，流关闭最好放在finally块。
stream.close();
} catch (Exception e) {
System.out.println("Error occurred: " + e);
}
}
/**
* 下载对象指定区域的字节数组做为流。（断点下载）
* @param fileName
* @param offset 是起始字节的位置
* @param length 是要读取的长度 (可选，如果无值则代表读到文件结尾)。
*/
@Override
public void getFileInputStream(String fileName, Long offset, Long length){
try {
MinioClient minioClient = getClient();
// 调用statObject()来判断对象是否存在。
// 如果不存在, statObject()抛出异常,
// 否则则代表对象存在。
minioClient.statObject(bucketName, fileName);
// 获取指定offset和length的"myobject"的输入流。
InputStream stream = minioClient.getObject(bucketName, fileName, offset, length);
// 读取输入流直到EOF并打印到控制台。
byte[] buf = new byte[16384];
int bytesRead;
while ((bytesRead = stream.read(buf, 0, buf.length)) >= 0) {
System.out.println(new String(buf, 0, bytesRead));
}
// 关闭流。
stream.close();
} catch (Exception e) {
System.out.println("Error occurred: " + e);
}
}
/**
* 下载并将文件保存到本地。
* @param fileName 目标名
* @param downloadFileName 下载文件名
*/
@Override
public void getLocalFile(String fileName,String downloadFileName){
try {
MinioClient minioClient = getClient();
// 调用statObject()来判断对象是否存在。
// 如果不存在, statObject()抛出异常,
// 否则则代表对象存在。
minioClient.statObject(bucketName, fileName);
// 获取myobject的流并保存到photo.jpg文件中。
minioClient.getObject(bucketName, fileName, downloadFileName);
} catch (Exception e) {
System.out.println("Error occurred: " + e);
}
}
/**
* 在给定的存储桶中获取整个加密对象的数据作为InputStream，然后用传入的master key解密和加密对象关联的content key。
* 然后创建一个含有InputStream和Cipher的CipherInputStream。这个Cipher被初始为用于使用content key进行解密，
* 所以CipherInputStream会在返回数据前，尝试读取数据并进行解密。所以read()方法返回的是处理过的原始对象数据。
* CipherInputStream必须用完关闭，否则连接不会被释放。
* @param fileName
* @param key SecretKey类型的数据。
*/
@Override
public void getMasterKeyFile( String fileName, SecretKey key){
try {
MinioClient minioClient = getClient();
// 调用statObject()来判断对象是否存在。
// 如果不存在, statObject()抛出异常,
// 否则则代表对象存在。
minioClient.statObject(bucketName, fileName);
//生成256位AES key。
KeyGenerator symKeyGenerator = KeyGenerator.getInstance("AES");
symKeyGenerator.init(256);
SecretKey symKey = symKeyGenerator.generateKey();
// 获取对象数据并保存到photo.jpg
InputStream stream = minioClient.getObject(bucketName, fileName, ServerSideEncryption.withCustomerKey(symKey));
// 读流到EOF，并输出到控制台。
byte[] buf = new byte[16384];
int bytesRead;
while ((bytesRead = stream.read(buf, 0, buf.length)) >= 0) {
System.out.println(new String(buf, 0, bytesRead, StandardCharsets.UTF_8));
}
// 关闭流。
stream.close();
} catch (Exception e) {
System.out.println("Error occurred: " + e);
}
}
/**
* 在给定的存储桶中获取整个加密对象的数据作为InputStream，然后用传入的master keyPair解密和加密对象关联的content key。
* 然后创建一个含有InputStream和Cipher的CipherInputStream。这个Cipher被初始为用于使用content key进行解密，
* 所以CipherInputStream会在返回数据前，尝试读取数据并进行解密。所以read()方法返回的是处理过的原始对象数据。
*
* CipherInputStream必须用完关闭，否则连接不会被释放。
* @param fileName
* @param key
*/
@Override
public void getKeyPairFile(String fileName, KeyPair key){
try {
MinioClient minioClient = getClient();
// 调用statObject()来判断对象是否存在。
// 如果不存在, statObject()抛出异常,
// 否则则代表对象存在。
minioClient.statObject("mybucket", "myobject");
KeyPairGenerator keyGenerator = KeyPairGenerator.getInstance("RSA");
keyGenerator.initialize(1024, new SecureRandom());
KeyPair keypair = keyGenerator.generateKeyPair();
// 获取对象数据并保存到photo.jpg
//InputStream stream = minioClient.getObject("testbucket", "my-objectname", keypair);
// 读流到EOF，并输出到控制台。
// byte[] buf = new byte[16384];
// int bytesRead;
// while ((bytesRead = stream.read(buf, 0, buf.length)) >= 0) {
// System.out.println(new String(buf, 0, bytesRead, StandardCharsets.UTF_8));
// }
// 关闭流。
//stream.close();
} catch (Exception e) {
System.out.println("Error occurred: " + e);
}
}
/**
* 上传文件到桶-流
* @param stream
* @param
* @return
*/
@Override
public String putFileForInputStream(String fileName, InputStream stream){
String urlName = null ;
try {
// 使用MinIO服务的URL，端口，Access key和Secret key创建一个MinioClient对象
MinioClient minioClient = getClient();
PutObjectOptions options = new PutObjectOptions(stream.available(), -1);
minioClient.putObject(bucketName, fileName, stream, options);
urlName = "/" + fileName;
stream.close();
} catch(Exception e) {
}
return urlName;
}
@Override
public String getClientPrefix() {
return url+bucketName;
}
// public static void main(String[] args) {
// /**
// * 将 Json 形式的字符串转换为 Map
// */
// String str = "{\"name\":\"cy\",\"age\":22}";
// JSONObject jsonObject = JSONObject.fromObject(str);
// Map<String, Object> map = (Map<String, Object>) JSONObject.toBean(jsonObject, Map.class);
// System.out.println(map);
//
// /**
// * 将 Json 形式的字符串转换为 JavaBean
// */
// str = "{\"id\":\"100101\",\"name\":\"zhangsan\"}";
// jsonObject = JSONObject.fromObject(str);
// System.out.println(jsonObject);
// Person person = (Person) JSONObject.toBean(jsonObject, Person.class);
// System.out.println(person);
// }
}
新版
maven
<dependency>
<groupId>io.minio</groupId>
<artifactId>minio</artifactId>
<version>8.2.1</version>
</dependency>
获取MinioClient
/**
* 获取连接
* @return
*/
@Override
public MinioClient getClient(){
MinioClient minioClient = null ;
try {
// 新版获取方式
minioClient = MinioClient.builder()
.endpoint(url)
.credentials(userName, password)
.build();
// 检查存储桶是否已经存在
boolean isExist = minioClient.bucketExists(bucketName);
if(!isExist) {
// 创建一个名为asiatrip的存储桶，用于存储照片的zip文件。
minioClient.makeBucket("weapon");
}
} catch(Exception e) {
System.out.println("Error occurred: " + e);
}
return minioClient;
}
新版部分方法
/**
* 创建bucket
*/
public void createBucket(String bucketName) throws Exception {
if (!minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
}
}
/**
* 获取全部bucket信息
*
* @return
*/
public List<Bucket> getAllBuckets() throws Exception {
return minioClient.listBuckets();
}
/**
* 根据bucketName删除信息
*
* @param bucketName bucket名称
*/
public void removeBucket(String bucketName) throws Exception {
minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
}
/**
* 上传文件
*
* @param file 文件名
* @return
*/
public String upload(String fileName,MultipartFile file) throws Exception {
//判断文件是否为空
if (null == file || 0 == file.getSize()) {
return null;
}
//判断存储桶是否存在 不存在则创建
createBucket(bucketName);
//开始上传
minioClient.putObject(
PutObjectArgs.builder().bucket(bucketName).object(fileName).stream(
file.getInputStream(), file.getSize(), -1)
.contentType(file.getContentType())
.build());
return "/"+fileName;
}
/**
* 获取文件外链
*
* @param bucketName
* @param region
* @param fileName
* @return
*/
public String getObjectUrl(String bucketName, String region, String fileName) throws Exception {
return minioClient.getPresignedObjectUrl(
GetPresignedObjectUrlArgs.builder()
.method(Method.GET)
.bucket(bucketName)
.region(region)
.object(fileName)
.build());
}
/**
* 删除⽂件
*
* @param bucketName bucket名称
* @param objectName ⽂件名称
*/
public void removeObject(String bucketName, String objectName) throws Exception {
minioClient.removeObject(
RemoveObjectArgs.builder()
.bucket(bucketName)
.object(objectName)
.build()
);
}
yml配置文件
minio:
url: http://192.168.1.242:9000/
userName: ****
password: ****
bucketName: weapon
如果有些方法没有可以看一下官方全部的文档
http://docs.minio.org.cn/docs/master/java-client-quickstart-guide
minio官方文档
http://docs.minio.org.cn/docs/master/java-client-api-reference
minio官方API文档
spring的方式也是一样注册一个bean，配置minio参数。