Java整合MinIO实现文件管理

左手的ㄟ右手 2023-10-12 17:12 61阅读 0赞

## `MinIo` ##

MinIO基于Apache License 2.0开源协议的对象存储服务。它兼容Amazon S3云存储接口。适合存储非结构化数据，如图片，音频，视频，日志等。

### `MinIo`基础概念 ###

*  `Object`:存储到`Minio`的基本对象，如文件字节流，Anything
 *  `Bucket`:用来存储`Object`的逻辑空间。每个`Bucket`之间的数据是相互隔离的。对于客户端而言，就相当于一个存放文件的顶层文件夹。
 *  `Drive`:即存储数据的磁盘，在`MiniO`启动时，以参数的方式传入。`Minio`中所有的对象数据都会存储在Drive里
 *  `Set`:即-组`Drive`的集合，分布式部署根据集群规模自动划分一个或多个`Set`，每个`Set`中的`Drive`分布在不同位置。一个对象存  
    储在一个`Set`上。一个对象存储在一个`Set`上，一个集群划分为多个`Set`，一个`Set`包含的`Drive`数量是固定的，默认由系统根据集群规模自动计算得出  
    一个`Set`中的`Drive`尽可能分布在不同的节点上。

### `docker`运行 ###

本次直接基于`Docker`来运行`MinIo`

#### 拉取镜像 ####

docker pull minio/minio

#### 运行镜像 ####

docker run --privileged -d -it -p 9000:9000 -p 9111:9111
    --name minio -e "MINIO_ROOT_USER=minioadmin" --privileged=true
    -e "MINIO_ROOT_PASSWORD=minio@123456"
    -v /Users/wangyupeng/data/minio/data:/data
    -v /Users/wangyupeng/data/minio/config:/root/.minio minio/minio server /data
    --console-address ":9111" -address ":9000"

*  运行命令，重要参数说明

1、`--privileged`

> `container`内的`root`拥有真正的`root`权限。否则，`container`内的`root`只是外部的一个普通用户权限。  
> `privileged`启动的容器，可以看到很多`host`上的设备，并且可以执行`mount`。甚至允许你在`docker`容器中启动`docker`容器。

2、`MINIO_ROOT_USER`

> 登陆管理界面的用户名

3、`MINIO_ROOT_PASSWORD`

> 登陆管理页面密码

4、`-V`

> 第一个`-v` 是设置数据存放目录，第二个`-v`是配置目录

5、`--console-address`

> 管理界面 端口设置，一定要和其中一个`-p`参数的端口对上,不指定的话会随机分配端口

6、`-address`

> `api`访问端口

7、`--name`

> 容器运行的名字

#### 查看运行日志 ####

docker logs minio

*  出现下面的日志，表示容器运行成功  
    ![a929837ca5c956c038610c85a8b840b3.png][]

#### 访问`minio` ####

浏览器输入`http://127.0.0.1:9111`,输入设置的`MINIO_ROOT_USER`和`MINIO_ROOT_PASSWORD`就能登录了，到此我们已经将`minio`运行起来了。

![9a5390a1ea4f07abb4a9827b9718857e.png][]

### `SpringBoot`整合`MinIO` ###

#### 引入依赖 ####

<dependency>
        <groupId>io.minio</groupId>
        <artifactId>minio</artifactId>
        <version>8.5.2</version>
    </dependency>

#### 配置 ####

server:
      port: 9999
    
    spring:
      servlet:
        multipart:
          max-file-size: 10MB
          max-request-size: 10MB
      minio:
        access-key: minioadmin      #key就是docker初始化是设置的，密钥相同
        secret-key: minio@123456
        url: http://localhost:9000
        bucket-name: admin   # 登陆minio创建的文件桶

#### 构建配置类 ####

package org.triumphxx.minio.config;
    
    import io.minio.MinioClient;
    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * @author:triumphxx
     * @Date:2023/5/28
     * @Time:20:54
     * @微信公众号：北漂码农有话说
     * @网站：https://blog.triumphxx.com.cn
     * @GitHub https://github.com/triumphxx
     * @Desc: minio配置类
     **/
    @Configuration
    @ConfigurationProperties(prefix = "spring.minio")
    @Data
    public class MinioConfiguration {
        
        /**
         * 用户名
         */
        private String accessKey;
        /**
         * 密码
         */
        private String secretKey;
        /**
         * Minio 服务端 api地址
         */
        private String url;
        /**
         * 存储桶名字
         */
        private String bucketName;
    
        /**
         * 构建 操作Minio的客户端
         * @return
         */
        @Bean
        public MinioClient minioClient() {
        
            return MinioClient.builder()
                    .endpoint(url)
                    .credentials(accessKey, secretKey)
                    .build();
        }
    
    }

#### 构建操作minio的服务类 ####

package org.triumphxx.minio.service;
    
    import io.minio.GetPresignedObjectUrlArgs;
    import io.minio.MinioClient;
    import io.minio.PostPolicy;
    import io.minio.PutObjectArgs;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.web.multipart.MultipartFile;
    import org.triumphxx.minio.config.MinioConfiguration;
    import io.minio.http.Method;
    
    import java.io.InputStream;
    import java.time.ZonedDateTime;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @author:triumphxx
     * @Date:2023/5/28
     * @Time:20:59
     * @微信公众号：北漂码农有话说
     * @网站：https://blog.triumphxx.com.cn
     * @GitHub https://github.com/triumphxx
     * @Desc: 操作minio的服务
     **/
    @Service
    @Slf4j
    public class MinIoService {
        
        @Autowired
        private MinioClient minioClient;
    
        @Autowired
        private MinioConfiguration configuration;
    
    
        /**
         * 获取上传文件临时签名，作用是：前端获取到签名信息后可以直接将文件上传到minio
         * @param fileName
         * @param time
         * @return
         */
        public Map getPolicyUrl(String fileName, ZonedDateTime time) {
        
            PostPolicy postPolicy = new PostPolicy(configuration.getBucketName(), time);
            postPolicy.addEqualsCondition("key", fileName);
            try {
        
                Map<String, String> map = minioClient.getPresignedPostFormData(postPolicy);
                HashMap<String, String> policyMap = new HashMap<>();
                map.forEach((k,v)->{
        
                    policyMap.put(k.replaceAll("-",""),v);
                });
                policyMap.put("host",configuration.getUrl()+"/"+configuration.getBucketName());
                return policyMap;
            }  catch (Exception e) {
        
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         *
         * @param objectName
         * @param time
         * @param timeUnit
         * @return
         */
        public String getFileUrl(String objectName,int time, TimeUnit timeUnit) {
        
            try {
        
                return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                        .method(Method.GET)
                        .bucket(configuration.getBucketName())
                        .object(objectName)
                        .expiry(time, timeUnit).build());
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 针对前端直接上传的是文件的格式
         * @param file 文件
         */
        public void uploadToFile(MultipartFile file) {
        
            // 使用putObject上传一个文件到存储桶中。
            try {
        
                InputStream inputStream = file.getInputStream();
                String fileName = file.getOriginalFilename();
                log.info("上传的文件名为：{}",fileName);
                minioClient.putObject(PutObjectArgs.builder()
                        .bucket(configuration.getBucketName())
                        .object(fileName.substring(0,fileName.indexOf(".")))
                        .stream(inputStream, file.getSize(), -1)
                        .contentType(file.getContentType())
                        .build());
            } catch (Exception e){
        
                e.printStackTrace();
            }
        }
    
        /**
         * 根据文件名访问指定有效期的文件访问链接
         * @param objectName
         * @param time
         * @param timeUnit
         * @return
         */
        public String getUrl(String objectName, int time, TimeUnit timeUnit) {
        
            String url = null;
            try {
        
                url = minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
                        .method(Method.GET)
                        .bucket(configuration.getBucketName())
                        .object(objectName)
                        .expiry(time, timeUnit).build());
            }catch (Exception e){
        
                e.printStackTrace();
            }
            return url;
        }
    }

#### 创建测试类 ####

package org.triumphxx.minio.controller;
    
    import org.springframework.web.bind.annotation.*;
    import org.springframework.web.multipart.MultipartFile;
    import org.triumphxx.minio.service.MinIoService;
    
    import javax.annotation.Resource;
    import java.time.ZonedDateTime;
    import java.util.Map;
    import java.util.concurrent.TimeUnit;
    
    /**
     * @author:triumphxx
     * @Date:2023/5/28
     * @Time:20:58
     * @微信公众号：北漂码农有话说
     * @网站：https://blog.triumphxx.com.cn
     * @GitHub https://github.com/triumphxx
     * @Desc: 文件上传
     **/
    @RestController
    public class MinIoController {
        
        @Resource
        MinIoService minIoService;
    
        /**
         * 针对于前端的直接上传文件格式的接口
         * @param file
         */
        @PostMapping("/upload")
        public void uploadToFile(@RequestParam("file") MultipartFile file){
        
            minIoService.uploadToFile(file);
        }
        /**
         * 针对于后端文件流的形式上传文件
         * @param file
         */
        @PostMapping("/uploadToFileInputStream")
        public void uploadToFileInputStream(@RequestParam("file") MultipartFile file){
        
            minIoService.uploadToFile(file);
        }
        /**
         * 获取 一定有效期的图片连接
         * @param name 文件名称
         * @param time 时间 单位：天
         * @return
         */
        @GetMapping("/getFileUrl")
        public String getFileUrl(@RequestParam("name") String name , @RequestParam("time") int time){
        
           return minIoService.getUrl(name,time, TimeUnit.DAYS);
        }
    
        /**
         * 获取 文件签名
         * @param name 文件名称
         * @return
         */
        @PostMapping("/getPolicyUrl")
        public Map getPolicyUrl(@RequestParam("name") String name){
        
            return minIoService.getPolicyUrl(name, ZonedDateTime.now());
        }
    
        /**
         * 获取 临时文件连接
         * @param name 文件名称
         * @return
         */
        @PostMapping("/getTempFileUrl")
        public String getTempFileUrl(@RequestParam("name") String name, @RequestParam("time") int time){
        
            return minIoService.getFileUrl(name, time,TimeUnit.DAYS);
        }
    }

#### 使用postman测试 ####

![433bfb39b3cd9196fffbf93c6338e8ff.png][]

#### 查看上传的图片 ####

看到如下图片表示上传成功！  
![f1d4621b6b3ba8937d4a39736175eee8.png][]

### 小结 ###

本篇文章，一起探讨了使用`docker`运行`minio`,并且使用`springboot`整合，实现文件的上传。 源码地址[源码传送门][Link 1]

![在这里插入图片描述][5e102b6ee4554da5a889ef1c28de52e0.jpeg_pic_center]

[a929837ca5c956c038610c85a8b840b3.png]: https://img-blog.csdnimg.cn/img_convert/a929837ca5c956c038610c85a8b840b3.png
[9a5390a1ea4f07abb4a9827b9718857e.png]: https://img-blog.csdnimg.cn/img_convert/9a5390a1ea4f07abb4a9827b9718857e.png
[433bfb39b3cd9196fffbf93c6338e8ff.png]: https://img-blog.csdnimg.cn/img_convert/433bfb39b3cd9196fffbf93c6338e8ff.png
[f1d4621b6b3ba8937d4a39736175eee8.png]: https://img-blog.csdnimg.cn/img_convert/f1d4621b6b3ba8937d4a39736175eee8.png
[Link 1]: https://gitee.com/triumphxx/learning/tree/master/files-handle/file-storage-minio
[5e102b6ee4554da5a889ef1c28de52e0.jpeg_pic_center]: https://img-blog.csdnimg.cn/5e102b6ee4554da5a889ef1c28de52e0.jpeg#pic_center