docker安装minio,并在springboot中引入依赖,创建服务

一、Docker 安装 MinIO 部署

1.官方链接

名称	地址
官方文档	[https://www.minio.org.cn/docs/minio/container/index.html

2. 拉取镜像

docker pull minio/minio:latest

3. 创建挂载目录

mkdir -p /mydata/minio/{data,config}

4. 创建和启动容器

docker run -d \
  --restart always \
  -p 9800:9800 \
  -p 9801:9801 \
  --name minio \
  -v /mydata/minio/data:/data \
  -v /mydata/minio/config:/root/.minio \
  -e "MINIO_ROOT_USER=<设置账户名称>" \
  -e "MINIO_ROOT_PASSWORD=<设置账号密码>" \
  minio/minio server /data --console-address ":9001"

• -e "MINIO_ROOT_USER=<设置账户名称>" ： MinIO控制台用户名
• -e "MINIO_ROOT_PASSWORD=<设置账号密码>" ：MinIO控制台密码

5. 访问MinIO控制台

控制台地址： http://192.168.10.100:9001(opens new window)

用户名/密码： minioadmin/minioadmin

6.设置开机启动

docker restart minio
 
docker update minio --restart=always

二、创建 spring-minio 服务

1. pom.xml相关依赖

• spring-boot版本 2.7.14
• spring-cloud版本 2021.0.8
• spring-cloud-alibaba版本 2021.1
• knife4j版本 4.1.0

	<!-- minio依赖 -->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.5.5</version>
        </dependency>
 
        <!-- https://mvnrepository.com/artifact/me.tongfei/progressbar -->
        <dependency>
            <groupId>me.tongfei</groupId>
            <artifactId>progressbar</artifactId>
            <version>0.9.5</version>
        </dependency>
 
        <!-- https://mvnrepository.com/artifact/com.squareup.okhttp3/okhttp -->
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>4.10.0</version>
        </dependency>
		
	<!-- 读取配置 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
        </dependency>

2.在 config 包下面创建 minio 的 client

• 创建引用yml的配置, MinioProperties 的 class 文件

@Data
@Component
@ConfigurationProperties(prefix = "minio")
public class MinioProperties {
 
    @ApiModelProperty("端点")
    private String endpoint;
 
    @ApiModelProperty("访问秘钥key")
    private String accessKey;
 
    @ApiModelProperty("秘密密钥key")
    private String secretKey;
}

• 创建 MinioConfiguration 的 class文件,引用在yml文件中配置的依赖

@Configuration
public class MinioConfiguration {
 
    private @Resource MinioProperties properties;
 
    @Bean
    public MinioClient minioClient() {
 
        return MinioClient.builder().endpoint(properties.getEndpoint())
                .credentials(properties.getAccessKey(), properties.getSecretKey())
                .build();
    }
}

3.在 common 包下面创建响应体等公共依赖

• 创建 Fileinfo 的 class 文件

@Data
@ApiModel("查询时，返回上传的文件路径与是否为目录")
public class Fileinfo {
 
	/**
	 * 文件名称
	 */
	private String filename;
 
	/**
	 * 目录
	 */
	private Boolean directory;
 
}

• 创建 统一响应结构体 Res

@Data
public class Res<T> implements Serializable {
 
    private String code;
 
    private T data;
 
    private String msg;
 
}

4.编写相关的 Impl 创建实现方法

 private @Resource MinioProperties properties;
 
private @Resource MinioClient minioClient;
 
@Value("${minio.bucketName}")
private String bucketName;
 
@Value("${minio.groupName}")
private String groupName;
 
    /**
     * 查看目录
     * @return
     */
    @Override
    public List<Object> listItem() {
 
        Iterable<Result<Item>> myObjects = minioClient.listObjects(ListObjectsArgs.builder()
                .bucket(bucketName).recursive(true)
                .build());
	// 递归方式，查询到相关的 buckets 下面的图片
        List<Object> infos = new ArrayList<>();
        for (Result<Item> r : myObjects) {
            Fileinfo info = new Fileinfo();
            try {
                Item item = r.get();
                info.setFilename(item.objectName());
                info.setDirectory(item.isDir());
 
                infos.add(info);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
 
        return infos;
    }
 
    /**
     * 文件上传
     * @return
     */
    @Override
    public Res upload(MultipartFile[] file) {
 
        if (file == null  || 0 == file.length ) {
            return Res.failed("上传文件不能为空");
        }
 
        List<String> list = new ArrayList<>(file.length);
 
        for (MultipartFile multipartFile : file) {
 
            String originalFilename = multipartFile.getOriginalFilename();
 
            try {
 
                //文件上传
                InputStream in = multipartFile.getInputStream();
 
                String dateTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd"));
 
                String newName = groupName + "/" + dateTime + "/" +UUID.randomUUID().toString().replaceAll("-", "")
                        + originalFilename.substring(originalFilename.lastIndexOf("."));
 
                minioClient.putObject(
                        PutObjectArgs.builder().bucket(bucketName).object(newName)
 
                                .stream(
                                        in, multipartFile.getSize(), -1)
                                .contentType(multipartFile.getContentType())
                                .build());
                in.close();
		／／ 生成uri路径
                String uri = properties.getEndpoint() + "/" + bucketName + "/" + newName;
                list.add(uri);
 
            } catch (Exception e) {
                log.error(e.getMessage());
                return Res.failed("上传失败");
            }
        }
 
        Map<String, Object> map = new HashMap<>();
        map.put("bucketName", bucketName );
        map.put("fileName", list);
 
        return Res.success(map);
 
    }
 
    /**
     * 下载文件
     * @return
     */
    @Override
    public void downloadFileName(HttpServletResponse response, String fileName) {
 
        InputStream in = null;
 
        try {
            StatObjectResponse stat = minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(fileName).build());
 
            response.setContentType(stat.contentType());
            response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
 
            //文件下载
            in = minioClient.getObject(
                    GetObjectArgs.builder()
                            .bucket(bucketName)
                            .object(fileName)
                            .build());
            IOUtils.copy(in, response.getOutputStream());
 
        } catch (Exception e) {
 
            log.error(e.getMessage());
 
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    log.error(e.getMessage());
                }
            }
        }
    }
 
    /**
     * 删除文件
     * @return
     */
    @Override
    public Res delFileName(String fileName) {
        try {
            minioClient.removeObject(
                    RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build());
        } catch (Exception e) {
            log.error(e.getMessage());
            return Res.failed("删除失败");
        }
        return Res.success("删除成功");
 
    }