还在用FastDFS?快来试试MinIO

最近在做一个项目，需要用到文件服务做文件存储和共享，之前就听说过MinIO，一直没尝试过，用过给我最大的感受就是部署真是方便了，提供了一个UI界面，操作很方便，发现真香

什么是MinIO

具体介绍看网站介绍MinIO | 高性能, Kubernetes 原生对象存储

安装部署

安装部署比较简单，可以用docker也可以下载安装包，我这里用ubuntu，官网地址比较慢，用中国的镜像站，MinIO中国加速站的使用用办法：将官网下载地址中的dl.min.io改为dl.minio.org.cn

1. 下载安装包
2. 安装minio
3. 启动minio服务，设置文件存储路径为：/opt/minio/data ，并设置UI控制台端口号9001，注意MinIO服务端口默认为9000，客户端接入时连接端口是9000，别成控制台端口9001

wget https://dl.minio.org.cn/server/minio/release/linux-amd64/minio_20230227181045.0.0_amd64.deb
dpkg -i minio_20230227181045.0.0_amd64.deb
sudo nohup minio server /opt/minio/data --console-address ":9001" 2>&1 &

启动后，通过浏览器访问127.0.0.1:9001，可以进入控制台，默认用户和密码是minioadmin

MinIO控制台

那怎么传文件了？首先，创建一个Bucket（存储桶），然后选择这个bucket可以上传了，bucket可以理解为一个容器，文件放在bucket里，可以按需建，比如不同类型或者不同模块的文件，放在不同的bucket里，这里创建一个public的bucket

bucket创建好之后，就可以往bucket里上传文件了

上传后，点击文件可以下载、在线预览，分享，删除

配置密钥，客户端接入时使用

SpringBoot集成MinIO

前面介绍MinIO的一些基本操作，下面来通过代码来演示，springboot怎么集成MinIO

首先创建maven项目，引入MinIO的客户端

 
            io.minio
            minio
            8.5.2

在配置文件里添加MinIO的接入参数

minio:
  #minio服务地址
  endpoint: http://192.168.19.130:9000
  #认证
  accessKey: jDLyzTvkq3HsKleF
  #认证密钥
  secretKey: n3QC5VYcicQGPqKQVYksZalkBRZxUDSa
  #默认存储桶
  bucket: public

添加MinIO配置类

@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();
    }
}

编写MinIO工具类

@Component
public class MinioHelper {


    @Value("${minio.bucket}")
    private String defaultBucketName;

    @Autowired
    private MinioClient minioClient;

    /**
     * 存储桶是否存在
     *
     * @param bucketName 存储桶名字
     * @return
     */
    public boolean bucketExists(String bucketName) {
        try {
            return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 创建bucket
     *
     * @param bucketName 存储桶名字
     */
    public boolean createBucket(String bucketName) {
        try {
            if (!bucketExists(bucketName)) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 删除bucket
     *
     * @param bucketName 存储桶名字
     * @return
     */
    public boolean removeBucket(String bucketName) {
        try {
            if (!bucketExists(bucketName)) {
                minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 上传文件
     *
     * @param bucketName  存储桶名字
     * @param inputStream 输入流
     * @param filePath    文件路径，可以是文件名，也可以带上需要存储的路径，例如年月 2023/03/upload.txt
     * @return true成功false失败
     */
    public ObjectWriteResponse upload(String bucketName, InputStream inputStream, String filePath) {
        if (StringUtils.isBlank(bucketName)) {
            bucketName = defaultBucketName;
        }
        createBucket(bucketName);
        try {
            return minioClient.putObject(PutObjectArgs.builder().bucket(bucketName).object(filePath).stream(inputStream, inputStream.available(), -1).build());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 下载文件
     *
     * @param bucketName 存储桶名字
     * @param filePath   文件路径
     * @return 文件输入流
     */
    public InputStream download(String bucketName, String filePath) {
        try {
            if (StringUtils.isBlank(bucketName)) {
                bucketName = defaultBucketName;
            }
            return minioClient.getObject(GetObjectArgs.builder().bucket(bucketName).object(filePath).build());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 删除文件
     *
     * @param bucketName 存储桶名字
     * @param filePath   文件路径
     * @return true成功false失败
     */
    public boolean removeFile(String bucketName, String filePath) {
        try {
            if (StringUtils.isBlank(bucketName)) {
                bucketName = defaultBucketName;
            }
            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(filePath).build());
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 列出存储桶里所有文件，包括文件夹中的子文件
     *
     * @param bucketName 存储桶名字
     * @return 文件列表
     */
    public Iterable> list(String bucketName) {
        return minioClient.listObjects(ListObjectsArgs.builder().bucket(bucketName).recursive(true).build());
    }
}

编写测试用例，进行测试

@SpringBootTest
public class MinioHelperTest {
    @Autowired
    MinioHelper minioHelper;

    @Test
    void createBucket() {
        minioHelper.createBucket("test");
    }

    @Test
    void removeBucket() {
        minioHelper.removeBucket("test");
    }

    @Test
    void upload() throws FileNotFoundException {
        FileInputStream fileInputStream = new FileInputStream("C:minioupload.png");
        minioHelper.upload("public", fileInputStream, "2023/03/upload.png");
    }

    @Test
    void download() throws IOException {
        InputStream inputStream = minioHelper.download("public", "2023/03/upload.png");
        FileOutputStream outputStream = new FileOutputStream("d:upload.png");
        outputStream.write(IOUtils.toByteArray(inputStream));
    }

    @Test
    void removeFile() {
        minioHelper.removeFile("public", "2023/03/upload.png");
    }

    @Test
    void list() throws Exception {
        Iterable> iterable = minioHelper.list("public");
        for (Result result : iterable) {
            System.out.println("result = " + result.get().objectName());
        }
    }
}

全文结束，谢谢阅读，用你发财的小手，点赞收藏吧！