minio 操作记录

创建目录

cd /usr/local
mkdir minio #创建源文件目录
cd minio
mkdir data #创建图片存储目录

或者
mkdir /usr/local/minio #创建源文件目录
mkdir /usr/local/minio/data #创建图片存储目录

下载源文件

# 下载安装文件
wget https://dl.min.io/server/minio/release/linux-amd64/minio
# 赋予可执行权限
chmod +x minio

# 启动minio server服务，指定数据存储目录/usr/local/minio/data
./minio server /usr/local/minio/data

密码修改

#临时启动后,进入文件存储目录
cd /usr/local/minio/data
ll -a  #显示隐藏文件夹

#进入密码配置文件页面
cd .minio.sys/config

#vim 修改保存密码
vim config.json
:wq! #保存退出

指定端口&后台进程启动

nohup /usr/local/minio/minio server --console-address ":9001" /usr/local/minio/data > minio.log 2>&1 &

spring boot 整合

#maven 配置
    <dependency>
         <groupId>io.minio</groupId>
         <artifactId>minio</artifactId>
         <version>8.0.3</version>
     </dependency>
     
#yml配置
minio:
  # 地址
  endpoint: http://localhost:9000
  # 账号
  accessKey: minioadmin
  # 密码
  secretKey: minioadmin

#config 文件配置
package com.lx.boardroom.config;

import io.minio.MinioClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

@Configuration
public class MinioConfig {

    @Value("${minio.endpoint}")
    private String endpoint;
    @Value("${minio.accessKey}")
    private String accessKey;
    @Value("${minio.secretKey}")
    private String secretKey;

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

}

package com.lx.boardroom.service.minio;

import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import io.minio.messages.Item;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.FastByteArrayOutputStream;
import org.springframework.web.multipart.MultipartFile;

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


/**
 * 
 * @author lbb
 */
@Component
public class MinioService {
	
	private static final Logger log = LoggerFactory.getLogger(MinioService.class);

	private String bucketName="mybucket";

	@Autowired
	MinioClient minioClient;

	/**
	 * 查看存储bucket是否存在
	 * @return boolean
	 */
	public Boolean bucketExists(String bucketName) {
		Boolean found;
		try {
			found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
		} catch (Exception e) {
			return false;
		}
		return found;
	}

	/**
	 * 创建存储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
	 * @return Boolean
	 */
	public Boolean removeBucket(String bucketName) {
		try {
			minioClient.removeBucket(RemoveBucketArgs.builder()
					.bucket(bucketName)
					.build());
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	/**
	 * 获取全部bucket
	 */
	public List<Bucket> getAllBuckets() {
		try {
			return minioClient.listBuckets();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 文件上传
	 * @param file 文件
	 * @return Boolean
	 */
	public Boolean upload(MultipartFile file) {
		// 修饰过的文件名 非源文件名
		String fileName = "2021-07/21/";
		fileName = fileName+file.getOriginalFilename();
		try {
			PutObjectArgs objectArgs = PutObjectArgs.builder().bucket(bucketName).object(fileName)
					.stream(file.getInputStream(),file.getSize(),-1).contentType(file.getContentType()).build();
			//文件名称相同会覆盖
			minioClient.putObject(objectArgs);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	/**
	 * 预览图片
	 * @param fileName
	 * @return
	 */
	public String preview(String fileName){
		// 查看文件地址
		GetPresignedObjectUrlArgs build = new GetPresignedObjectUrlArgs().builder().bucket(bucketName).object(fileName).method(Method.GET).build();
		try {
			String url = minioClient.getPresignedObjectUrl(build);
			return url;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 文件下载
	 * @param fileName 文件名称
	 * @param res response
	 * @return Boolean
	 */
	public void download(String fileName, HttpServletResponse res) {
		GetObjectArgs objectArgs = GetObjectArgs.builder().bucket(bucketName)
				.object(fileName).build();
		try (GetObjectResponse response = minioClient.getObject(objectArgs)){
			byte[] buf = new byte[1024];
			int len;
			try (FastByteArrayOutputStream os = new FastByteArrayOutputStream()){
				while ((len=response.read(buf))!=-1){
					os.write(buf,0,len);
				}
				os.flush();
				byte[] bytes = os.toByteArray();
				res.setCharacterEncoding("utf-8");
				//设置强制下载不打开
				//res.setContentType("application/force-download");
				res.addHeader("Content-Disposition", "attachment;fileName=" + fileName);
				try (ServletOutputStream stream = res.getOutputStream()){
					stream.write(bytes);
					stream.flush();
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 查看文件对象
	 * @return 存储bucket内文件对象信息
	 */
	public List<Item> listObjects() {
		Iterable<Result<Item>> results = minioClient.listObjects(
				ListObjectsArgs.builder().bucket(bucketName).build());
		List<Item> items = new ArrayList<>();
		try {
			for (Result<Item> result : results) {
				items.add(result.get());
			}
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
		return items;
	}

	/**
	 * 删除
	 * @param fileName
	 * @return
	 * @throws Exception
	 */
	public boolean remove(String fileName){
		try {
			minioClient.removeObject( RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build());
		}catch (Exception e){
			return false;
		}
		return true;
	}

	/**
	 * 批量删除文件对象（没测试）
	 * @param objects 对象名称集合
	 */
	public Iterable<Result<DeleteError>> removeObjects(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;
	}
}