整合Minio

于 2024-08-10 18:26:47 发布
阅读量97 收藏
点赞数 2
文章标签： spring cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/geuejfwhje/article/details/141094433
版权

引入依赖

<minio.version>8.5.7</minio.version>

<!-- MinIO 依赖配置 -->
<dependency>
    <groupId>io.minio</groupId>
    <artifactId>minio</artifactId>
    <version>${minio.version}</version>
</dependency>

编写配置文件

image.png

/**
 * MinIO自定义配置条件
 *
 * @author Ccoo
 */
public class OssMinioCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String property = context.getEnvironment().getProperty("oss.minio.enable");
        return StringUtils.equals("true", property);
    }

}

/**
 * Minio配置属性
 *
 * @author Ccoo
 */
@Data
@ConfigurationProperties(prefix = "oss.minio")
public class MinioProperties {

    /**
     * 是否开启
     */
    private Boolean enable = false;

    /**
     * 域名（一定是协议前缀+ip+port）
     */
    private String endpoint;

    /**
     * 是否开启TLS
     */
    private Boolean enableTls = false;

    /**
     * 用户的 AccessKey
     */
    private String rootUser;

    /**
     * 用户的 SecretKey
     */
    private String rootPassword;

    /**
     * 桶名称
     */
    private String bucketName;

}

/**
 * MinIO配置
 *
 * @author Ccoo
 */
@Slf4j
@Configuration
@AllArgsConstructor
@Conditional(OssMinioCondition.class)
@EnableConfigurationProperties(MinioProperties.class)
public class MinioConfiguration {

    private final MinioProperties minioProperties;
    private static final String UNIAPP = "uniapp";
    private static final String SUFFIX = ".jpeg";

    /**
     * 获取小程序背景图列表
     * @return 小程序背景图列表
     */
    public List<UniappFile> uniappgetImageList() {

        MinioClient minioClient = getMinioClient();
        try {

            Iterable<Result<Item>> results = minioClient.listObjects(ListObjectsArgs.builder()
                    .bucket(minioProperties.getBucketName())
                    .prefix(UNIAPP + "/")
                    .build());

            if(results == null){
                throw new CustomizeFileException(ReturnCode.USER_FILE_GET_IS_ABNORMAL);
            }

            List<UniappFile> files = new ArrayList<>();
            for (Result<Item> result : results) {
                Item item = result.get();
                UniappFile uniappFile = new UniappFile();
                String fileName = item.objectName().split("/")[1].split("\\.")[0];
                uniappFile.setName(fileName);
                uniappFile.setUrl(Constantes.HTTP + minioProperties.getEndpoint() + "/" + minioProperties.getBucketName() + "/" + item.objectName());
                files.add(uniappFile);
            }
            return files;

        } catch (Exception e) {
            e.printStackTrace();
            throw new CustomizeFileException(ReturnCode.USER_FILE_GET_IS_ABNORMAL);
        }

    }

    /**
     * 修改小程序背景图
     * @param file 文件
     * @param name 文件名
     * @return 文件地址
     */
    public String uniappUpdateImage(MultipartFile file, String name) {

        MinioClient minioClient = getMinioClient();
        String key;
        InputStream inputStream = null;

        try {
            if (file == null) {
                throw new CustomizeFileException(ReturnCode.USER_DO_NOT_UPLOAD_FILE);
            }

            // 对象键(Key)是对象在存储桶中的唯一标识。
            key = StringUtils.isBlank(StringUtils.trim(name)) ? UNIAPP  + SUFFIX : UNIAPP + "/" + name + SUFFIX;

            inputStream = file.getInputStream();
            minioClient.putObject(PutObjectArgs.builder()
                    .bucket(minioProperties.getBucketName())
                    .object(key)
                    .stream(inputStream, inputStream.available(), 5 * 1024 * 1024).build());

        } catch (Exception e) {
            e.printStackTrace();
            throw new CustomizeFileException(ReturnCode.FILE_UPLOAD_EXCEPTION);
        } finally {
            IOUtils.closeQuietly(inputStream);
        }

        return (minioProperties.getEnableTls() ? Constantes.HTTPS : Constantes.HTTP)
                + minioProperties.getEndpoint() + "/" + minioProperties.getBucketName() + "/" + key;
    }


    /**
     * 获取小程序图片地址
     */
    public String uniappgetImage(String name) {

        MinioClient minioClient = getMinioClient();
        try {
            GetObjectResponse response = minioClient.getObject(GetObjectArgs.builder()
                    .bucket(minioProperties.getBucketName())
                    .object(UNIAPP + "/" + name + SUFFIX)
                    .build());
            if(response == null){
                throw new CustomizeFileException(ReturnCode.USER_FILE_ADDRESS_IS_ABNORMAL);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new CustomizeFileException(ReturnCode.USER_FILE_ADDRESS_IS_ABNORMAL);
        }

        String imageKey = UNIAPP + "/" + name + SUFFIX;
        return Constantes.HTTP + minioProperties.getEndpoint() + "/" + minioProperties.getBucketName() + "/" + imageKey;

    }

    /**
     * 小程序上传文件
     */
    public String uniappUpload(MultipartFile file, String name) {

        // http://159.75.111.41:9000/public/uniapp/name.jpeg

        MinioClient minioClient = getMinioClient();
        String key;
        InputStream inputStream = null;

        try {
            if (file == null) {
                throw new CustomizeFileException(ReturnCode.USER_DO_NOT_UPLOAD_FILE);
            }

            // 对象键(Key)是对象在存储桶中的唯一标识。
            key = StringUtils.isBlank(StringUtils.trim(name)) ? UNIAPP  + SUFFIX : UNIAPP + "/" + name + SUFFIX;

            inputStream = file.getInputStream();
            minioClient.putObject(PutObjectArgs.builder()
                    .bucket(minioProperties.getBucketName())
                    .object(key)
                    .stream(inputStream, inputStream.available(), 5 * 1024 * 1024).build());

        } catch (Exception e) {
            e.printStackTrace();
            throw new CustomizeFileException(ReturnCode.FILE_UPLOAD_EXCEPTION);
        } finally {
            IOUtils.closeQuietly(inputStream);
        }

        return (minioProperties.getEnableTls() ? Constantes.HTTPS : Constantes.HTTP)
                + minioProperties.getEndpoint() + "/" + minioProperties.getBucketName() + "/" + key;
    }

    /**
     * 上传文件到MinIO
     *
     * @param file     待上传的文件
     * @param rootPath 上传的路径
     * @return 文件所在路径
     */
    public String uploadToMinio(MultipartFile file, String rootPath) {

        // http://159.75.111.41:9000/public/rootPath/8991891fa872440a93cf3c9a7d8e7f5d1712931544483.jpeg

        MinioClient minioClient = getMinioClient();
        String key;
        InputStream inputStream = null;
        try {
            if (file == null) {
                throw new CustomizeFileException(ReturnCode.USER_DO_NOT_UPLOAD_FILE);
            }

            String originalName = StringUtils.isNotBlank(file.getOriginalFilename()) ? file.getOriginalFilename() : file.getName();
            String suffix = FilenameUtils.getExtension(originalName);

            if (StringUtils.isEmpty(suffix)) {
                suffix = "." + Constantes.UNKNOWN_FILE_TYPE_SUFFIX;
            } else {
                suffix = "." + suffix;
            }

            // 创建一个随机文件名称
            String fileName = UUID.randomUUID().toString().replaceAll("-", "") + System.currentTimeMillis() + suffix;
            // 对象键(Key)是对象在存储桶中的唯一标识。
            key = StringUtils.isBlank(StringUtils.trim(rootPath)) ? fileName : rootPath + "/" + fileName;

            inputStream = file.getInputStream();
            minioClient.putObject(PutObjectArgs.builder()
                    .bucket(minioProperties.getBucketName())
                    .object(key)
                    .stream(inputStream, inputStream.available(), 5 * 1024 * 1024).build());

        } catch (Exception e) {
            e.printStackTrace();
            throw new CustomizeFileException(ReturnCode.FILE_UPLOAD_EXCEPTION);
        } finally {
            IOUtils.closeQuietly(inputStream);
        }

        return (minioProperties.getEnableTls() ? Constantes.HTTPS : Constantes.HTTP)
                + minioProperties.getEndpoint() + "/" + minioProperties.getBucketName() + "/" + key;
    }

    /**
     * 上传文件到MinIO
     *
     * @param inputStream 待上传的文件流
     * @param suffix      文件后缀
     * @param rootPath    上传的路径
     * @return 文件所在路径
     */
    public String uploadToMinio(InputStream inputStream, String suffix, String rootPath) {
        MinioClient minioClient = getMinioClient();
        String key;
        try {
            if (ObjectUtils.isEmpty(inputStream)) {
                throw new CustomizeFileException(ReturnCode.USER_DO_NOT_UPLOAD_FILE);
            }
            if (StringUtils.isEmpty(suffix)) {
                suffix = "." + Constantes.UNKNOWN_FILE_TYPE_SUFFIX;
            } else {
                suffix = "." + suffix;
            }
            // 创建一个随机文件名称
            String fileName = UUID.randomUUID().toString().replaceAll("-", "") + System.currentTimeMillis() + suffix;
            // 对象键(Key)是对象在存储桶中的唯一标识。
            key = StringUtils.isBlank(StringUtils.trim(rootPath)) ? fileName : rootPath + "/" + fileName;
            minioClient.putObject(PutObjectArgs.builder()
                    .bucket(minioProperties.getBucketName())
                    .object(key)
                    .stream(inputStream, inputStream.available(), 5 * 1024 * 1024).build());
        } catch (Exception e) {
            e.printStackTrace();
            throw new CustomizeFileException(ReturnCode.FILE_UPLOAD_EXCEPTION);
        } finally {
            IOUtils.closeQuietly(inputStream);
        }
        return (minioProperties.getEnableTls() ? Constantes.HTTPS : Constantes.HTTP)
                + minioProperties.getEndpoint() + "/" + minioProperties.getBucketName() + "/" + key;
    }

    public String uploadToMinio(byte[] bytes, String suffix, String rootPath) {
        MinioClient minioClient = getMinioClient();
        String key;
        InputStream inputStream = null;
        try {
            if (ObjectUtils.isEmpty(bytes)) {
                throw new CustomizeFileException(ReturnCode.USER_DO_NOT_UPLOAD_FILE);
            }
            inputStream = new ByteArrayInputStream(bytes);
            if (StringUtils.isEmpty(suffix)) {
                suffix = "." + Constantes.UNKNOWN_FILE_TYPE_SUFFIX;
            } else {
                suffix = "." + suffix;
            }
            // 创建一个随机文件名称
            String fileName = UUID.randomUUID().toString().replaceAll("-", "") + System.currentTimeMillis() + suffix;
            // 对象键(Key)是对象在存储桶中的唯一标识。
            key = StringUtils.isBlank(StringUtils.trim(rootPath)) ? fileName : rootPath + "/" + fileName;
            minioClient.putObject(PutObjectArgs.builder()
                    .bucket(minioProperties.getBucketName())
                    .object(key)
                    .stream(inputStream, inputStream.available(), 5 * 1024 * 1024).build());
        } catch (Exception e) {
            e.printStackTrace();
            throw new CustomizeFileException(ReturnCode.FILE_UPLOAD_EXCEPTION);
        } finally {
            IOUtils.closeQuietly(inputStream);
        }
        return (minioProperties.getEnableTls() ? Constantes.HTTPS : Constantes.HTTP)
                + minioProperties.getEndpoint() + "/" + minioProperties.getBucketName() + "/" + key;
    }

    /**
     * 从MinIO中删除文件
     *
     * @param url 文件URL
     */
    public boolean deleteInMinio(String url) {
        MinioClient minioClient = getMinioClient();
        String[] split = url.split(minioProperties.getEndpoint() + "/" + minioProperties.getBucketName() + "/");

        if (split.length != 2) {
            throw new CustomizeReturnException(ReturnCode.USER_FILE_ADDRESS_IS_ABNORMAL);
        }

        String key = split[1];
        try {
            minioClient.removeObject(RemoveObjectArgs.builder()
                    .bucket(minioProperties.getBucketName())
                    .object(key).build());
        } catch (Exception e) {
            throw new CustomizeFileException(ReturnCode.USER_FILE_DELETION_IS_ABNORMAL);
        }
        return true;
    }

    /**
     * 获取MinioClient客户端
     *
     * @return 返回MinioClient客户端
     */
    private MinioClient getMinioClient() {
        try {
            String[] ipAndPort = minioProperties.getEndpoint().split(":");
            return MinioClient.builder()
                    .endpoint(ipAndPort[0], Integer.parseInt(ipAndPort[1]), minioProperties.getEnableTls())
//                    .credentials(minioProperties.getSecretId(), minioProperties.getSecretKey())
                    .credentials(minioProperties.getRootUser(), minioProperties.getRootPassword())
                    .build();
        } catch (Exception e) {
            log.error("MinIO服务器构建异常：{}", e.getMessage());
            throw new CustomizeFileException(ReturnCode.FILE_UPLOAD_EXCEPTION);
        }
    }

    /**
     * 依赖注入日志输出
     */
    @PostConstruct
    private void initDi() {
        log.info("############ {} Configuration DI.", this.getClass().getSimpleName());
    }

}

image.png

# 对象存储配置
oss:
  # MinIO OSS配置
  minio:
    # 是否开启（预先关闭）
    enable: true
    # 域名（格式：【ip:port】）
    endpoint: 159.xxx.xxx.xxx:9000
    # 用户的 RootUser
    rootUser: minio
    # 用户的 RootPassword
    rootPassword: ovoAdmin123
    # 是否开启TLS
    enable-tls: false
    # 桶名称
    bucket-name: public

编写工具类

image.png

/**
 * MinIO工具类
 *
 * @author Ccoo
 */
@Slf4j
public class MinioUtils {

    /**
     * 被封装的MinIO对象
     */
    private static final MinioConfiguration MINIO_CONFIGURATION = SpringContextHolder.getBean(MinioConfiguration.class);

    /**
     * 上传文件
     *
     * @param file     上传的文件数据
     * @param rootPath 文件根目录（注意不需要首尾斜杠，即如果保存文件到"/root/a/"文件夹中，只需要传入"root/a"字符串即可）
     * @return 文件所在路径
     */
    public static String upload(MultipartFile file, String rootPath) {
        return MINIO_CONFIGURATION.uploadToMinio(file, rootPath);
    }

    /**
     * 上传小程序背景图
     */
    public static String uniappUpload(MultipartFile file, String name) {
        return MINIO_CONFIGURATION.uniappUpload(file, name);
    }

    /**
     * 获取小程序背景图
     */
    public static String uniappgetImage(String name) {
        return MINIO_CONFIGURATION.uniappgetImage(name);
    }

    /**
     * 获取小程序背景图列表
     * @return 小程序背景图列表
     */
    public static List<UniappFile> uniappgetImageList() {
        return MINIO_CONFIGURATION.uniappgetImageList();
    }

    /**
     * 修改小程序背景图
     */
    public static String uniappUpdateImage(MultipartFile file, String name) {
        return MINIO_CONFIGURATION.uniappUpdateImage(file, name);
    }

    /**
     * 上传文件
     *
     * @param inputStream 待上传的文件流
     * @param suffix      文件后缀
     * @param rootPath    上传的路径
     * @return 文件所在路径
     */
    public static String upload(InputStream inputStream, String suffix, String rootPath) {
        return MINIO_CONFIGURATION.uploadToMinio(inputStream, suffix, rootPath);
    }

    /**
     * 上传文件
     *
     * @param bytes    待上传的文件字节数据
     * @param suffix   文件后缀
     * @param rootPath 上传的路径
     * @return 文件所在路径
     */
    public static String upload(byte[] bytes, String suffix, String rootPath) {
        return MINIO_CONFIGURATION.uploadToMinio(bytes, suffix, rootPath);
    }

    /**
     * 删除文件
     *
     * @param url 文件所在地址
     */
    public static boolean delete(String url) {
         return MINIO_CONFIGURATION.deleteInMinio(url);
    }

}

编写Controller

/**
 * @author Ccoo
 * 2024/2/20
 */
@Api(tags = "文件相关接口")
@Slf4j
@RestController
@RequestMapping(value = "/system/minio")
public class MinioController {

	@ApiOperation(value = "文件上传返回url")
	@PostMapping("/upload")
	public R<String> upload(@RequestParam(value = "file") MultipartFile file, String rootPath) {
		String objectName = MinioUtils.upload(file, rootPath);
		if (null != objectName) {
			return Re.ok(objectName);
		}
		return Re.fail("上传失败");
	}

	@ApiOperation(value = "删除文件", notes = "根据url地址删除文件")
	@PostMapping("/delete")
	public R<String> remove(String url) {
		boolean result = MinioUtils.delete(url);
		if (result) {
			return Re.ok("删除成功");
		}
		return Re.fail("删除失败");
	}

	@ApiOperation(value = "上传小程序背景图")
	@PostMapping("/uniapp/upload")
	public R<String> uniappUpload(@RequestParam(value = "file") MultipartFile file, @RequestParam(value = "name") String name) {
		String objectName = MinioUtils.uniappUpload(file, name);
		if (null != objectName) {
			return Re.ok("上传成功!", objectName);
		}
		return Re.fail("上传失败!");
	}

	@ApiOperation(value = "获取小程序背景图")
	@GetMapping("/uniapp/getImage")
	public R<String> uniappgetImage(@RequestParam(value = "name") String name) {
		String url = MinioUtils.uniappgetImage(name);
		if (null != url) {
			return Re.ok("获取成功!",url);
		}
		return Re.fail("获取失败!");
	}

	@ApiOperation(value = "获取小程序背景图列表")
	@GetMapping("/uniapp/getImageList")
	public R<List<UniappFile>> uniappgetImageList() {
		List<UniappFile> list = MinioUtils.uniappgetImageList();
		if (null != list) {
			return Re.ok("获取成功!", list);
		}
		return Re.fail("获取失败!");
	}

	@ApiOperation(value = "修改小程序背景图")
	@PostMapping("/uniapp/updateImage")
	public R<String> uniappUpdateImage(@RequestParam(value = "file") MultipartFile file, @RequestParam(value = "name") String name) {
		String objectName = MinioUtils.uniappUpdateImage(file, name);
		if (null != objectName) {
			return Re.ok("修改成功!", objectName);
		}
		return Re.fail("修改失败!");
	}

}
geuejfwhje
关注
【微服务】springboot整合minio详解
congge_study的博客
12-18 1万+
springboot整合MinIO使用详解
Minio对象存储及Springboot整合Minio分片上传文章-代码
02-23
在本文中，我们将深入探讨如何将Minio与Spring Boot应用程序整合，并实现分片上传功能。 首先，我们需要在项目中引入Minio的Java SDK依赖。在Maven的pom.xml文件中添加以下依赖： ```xml <groupId>io.minio ...
SpringBoot整合Minio
liyh722的博客
08-07 2252
SpringBoot整合Minio
SpringBoot整合MinIO
w1245247503的博客
02-27 1040
MinIO的安装和运行以及SpringBoot整合MinIO
springboot整合minio
哈
04-03 256
【代码】Minio入门示例。
SpringBoot整合minio
与海
03-31 440
SpringBoot整合minio1. 下载及安装1.1 windows版本1.2 Linux版本2. SpringBoot整合minio2.1 依赖2.2 配置文件2.3 配置类2.4 工具类2.5 测试1. 业务层2. 控制层 1. 下载及安装 1.1 windows版本 启动文件 标红的地方按实际安装地更改 1.2 Linux版本 待更新 2. SpringBoot整合minio 2.1 依赖 <dependency> <groupId&g
Springboot整合 Minio
有时间就写写代码
06-08 2257
【代码】Springboot整合 Minio。
spring boot整合minio
weixin_46424243的博客
12-10 248
minio整合springboot以及使用POI导出模板
SpringBoot整合minio服务（超详细）
热门推荐
yueyue763184的博客
06-10 1万+
创建一个名为public的存储桶（名字可自定义），上传文件。在application.yml文件中编写相关配置。http://ip:9000/存储桶名/文件名。开发中上传接口用得较多，其他接口可自行测试。可以将存储桶的访问权限设置为public.# npm下载element-ui。// 引入ElementUI。
SpringBoot 整合 MinIO
04-23 225
MinIO是一款开源的对象存储服务，兼容 Amazon S3 云存储服务接口，适用于存储大容量非结构化数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等。SpringBoot 可以轻松地与 MinIO 集成，实现文件上传、下载、删除等功能。添加依赖在你的pom.xml文件中添加MinIO客户端库的依赖。
kotliin整合Minio
forever_u_wzx的博客
06-15 401
MinIO 提供高性能、兼容 S3 的对象存储。 MinIO 原生于 Kubernetes，是每个公共云、每个 Kubernetes 发行版、私有云和 边缘上唯一可用的对象存储套件。 MinIO 是软件定义的，在 GNU AGPL v3 下是 100% 开源的。.........
Spring boot整合MinIO客户端实现文件管理
06-27
MinIO 是一个基于Apache License v2.0开源协议的对象存储服务。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和...Spring boot整合MinIO客户端实现文件管理
SpringBoot(31) 整合MinIO实现文件上传与下载
08-17
整合SpringBoot和MinIO，我们需要以下步骤： 1. **添加依赖**：在SpringBoot的`pom.xml`文件中，添加MinIO的客户端SDK依赖。当前版本可能为`io.minio:minio:latest.release`。同时，确保SpringBoot的相关依赖也已...
jdk-1.8(8u211-windows-x64)
10-07
jdk-8u211-windows-x64
光储并网直流微电网simulink仿真模型，光伏采用mppt实现最大功率输出 储能由蓄电池和超级电容构成的混合储能系统 为了
10-07
光储并网直流微电网simulink仿真模型，光伏采用mppt实现最大功率输出。 储能由蓄电池和超级电容构成的混合储能系统。 为了确保微网并网时电能质量，采用二阶低通滤波法对光伏输出功率进行抑制，
失物招领信息交互平台 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS）.zip
最新发布
10-07
失物招领信息交互平台 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS） 启动教程：https://www.bilibili.com/video/BV1GK1iYyE2B
GTT2602-VB一种N-Channel沟道SOT23-6封装MOS管
10-07
30V;6A;RDS(ON)=30mΩ@VGS=10V;VGS=20V;Vth=1.2V
基于51单片机的水箱液位远程监测系统源代码+原理图+流程图+程序说明
10-07
1、使用单片机串口与模块通信；接法如下 STC单片机 GPRS模块 P3.0(RXD)->TXD P3.1(TXD)->RXD GND ->GND 晶振选用11.05926MHz 2、更改服务器地址，包括IP和端口号，要与实际服务器地址对应上。 3、测试此功能时，确保您的服务器是可用的。
spring整合minio
07-29
要在Spring中整合MinIO，你需要进行以下几个步骤： 1. 首先，在你的项目的pom.xml文件中添加MinIO的依赖。你可以使用以下代码片段作为参考： ``` <groupId>io.minio <artifactId>minio <version>8.4.6 ``` 这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值