devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

云存储解决方案-华为云OBS存储服务案例_slf4j配置华为云obs

作者：凡人多烦事01 | 2024-05-21 18:47:10

赞

踩

slf4j配置华为云obs

需求


我们在日常的业务需求中，会大量的遇到视频，图片，文件等等的存储需求，目前接触到工具有：minio，obs，ftp等等。

本文主要介绍：华为云对象存储服务（Object Storage Service，简称OBS）为您提供基于网络的数据存取服务。使用OBS，您可以通过网络随时存储和调用包括文本、图片、音频和视频等在内的各种非结构化数据文件。

步骤

1.开通obs并官方文档配置obs。
2.参考官方api，在springboot集成obs。

一、开通obs并官方文档配置obs

登录华为云官网，在产品标签处直接搜索obs。

 具体购买流程和购买后的配置请参考文档：

https://support.huaweicloud.com/sdk-java-devg-obs/obs_21_0001.html
华为云官方文档


二、springboot集成obs

1.创建测试工程，引入依赖。


2.在springBoot中集成OBS。

将密钥、 地址、桶名配置到application-dev.yml文件中，方便后期的更改。

创建对应的配置文件中华为账户对应的实体类。

分离出初始化obs方法。

结合官方文档封装自己的obs工具类。

  1. package com.richstonedt.smartcity.xaytsccommoncs.util;
  2. import com.obs.services.ObsClient;
  3. import com.obs.services.ObsConfiguration;
  4. import com.obs.services.exception.ObsException;
  5. import com.obs.services.internal.ObsService;
  6. import com.obs.services.model.*;
  7. import com.richstonedt.smartcity.xaytsccommoncs.annotation.ObsClientAnnotation;
  8. import org.slf4j.Logger;
  9. import org.slf4j.LoggerFactory;
  10.  
  11. import java.io.*;
  12. import java.nio.ByteBuffer;
  13. import java.nio.channels.Channels;
  14. import java.nio.channels.ReadableByteChannel;
  15. import java.nio.channels.WritableByteChannel;
  16. import java.util.HashMap;
  17. import java.util.List;
  18. import java.util.Map;
  19. import java.util.UUID;
  20.  
  21. /**
  22.  * <b><code>ObsUtil</code></b>
  23.  * <p/>
  24.  * Description OBS工具类
  25.  * <p/>
  26.  * <b>Creation Time:</b> 2022/3/29 15:56:45
  27.  *
  28.  * @author tangjiahuan
  29.  * @since xaytsc-common-be
  30.  */
  31. public class ObsUtil {
  32.     private final static Logger logger = LoggerFactory.getLogger(ObsService.class);
  33.  
  34.     private ObsClient obsClient;
  35.     private String bucketName;
  36.     private String bucketLoc;
  37.     private ObsConfiguration config;
  38.  
  39.     public ObsUtil() {
  40.     }
  41.  
  42.     public ObsUtil(String bucketName, String bucketLoc, ObsConfiguration config) {
  43.         this.bucketName = bucketName;
  44.         this.bucketLoc = bucketLoc;
  45.         this.config = config;
  46.     }
  47.  
  48.     public ObsUtil( String bucketLoc, ObsConfiguration config) {
  49.         this.bucketLoc = bucketLoc;
  50.         this.config = config;
  51.     }
  52.  
  53.     /**
  54.      * 查询所有桶
  55.      *
  56.      * @return 桶的列表
  57.      */
  58. //    @ObsClientAnnotation
  59.     public List<ObsBucket> listBuckets() {
  60.         ListBucketsRequest request = new ListBucketsRequest();
  61.         request.setQueryLocation(true);
  62.         List<ObsBucket> buckets = obsClient.listBuckets(request);
  63.         return buckets;
  64.     }
  65.  
  66.     /**
  67.      * 桶的新增
  68.      *
  69.      * @param bucketName 桶的名称
  70.      * @return 桶对象信息
  71.      */
  72. //    @ObsClientAnnotation
  73.     public ObsBucket createBucket(String bucketName) {
  74.         ObsBucket obsBucket = new ObsBucket(bucketName, bucketLoc);
  75.         obsBucket.setBucketName(bucketName);
  76.         return obsClient.createBucket(obsBucket);
  77.     }
  78.  
  79.     /**
  80.      * 桶的删除
  81.      *
  82.      * @param bucketName 桶的名称
  83.      * @return 响应对象
  84.      */
  85. //    @ObsClientAnnotation
  86.     public HeaderResponse deleteBucket(String bucketName) {
  87.         return obsClient.deleteBucket(bucketName);
  88.     }
  89.  
  90.     /**
  91.      * 设置桶内指定前缀的文件对象 过期时间
  92.      *
  93.      * @param prefix         什么前缀的文件过期（比如/tmp）
  94.      * @param expirationDays 几天后过期
  95.      */
  96.     @ObsClientAnnotation
  97.     public HeaderResponse setLiftConfig(String prefix, Integer expirationDays) {
  98.         LifecycleConfiguration config = new LifecycleConfiguration();
  99.         LifecycleConfiguration.Rule rule = config.new Rule();
  100.         rule.setEnabled(true);
  101.         //过期规则名称
  102.         rule.setId(String.valueOf(UUID.randomUUID()));
  103.         rule.setPrefix(prefix);
  104.         LifecycleConfiguration.Expiration expiration = config.new Expiration();
  105.         // 指定满足前缀的对象创建x天后过期
  106.         expiration.setDays(expirationDays);
  107.         LifecycleConfiguration.NoncurrentVersionExpiration noncurrentVersionExpiration = config.new NoncurrentVersionExpiration();
  108.         // 指定满足前缀的对象成为历史版本x天后过期
  109.         noncurrentVersionExpiration.setDays(expirationDays);
  110.         rule.setNoncurrentVersionExpiration(noncurrentVersionExpiration);
  111.         config.addRule(rule);
  112.         return obsClient.setBucketLifecycle(bucketName, config);
  113.     }
  114.  
  115.     /**
  116.      * 查询桶的所有对象
  117.      *
  118.      * @return 桶内对象集合（关键属性getObjectKey）
  119.      */
  120. //    @ObsClientAnnotation
  121.     public ObjectListing listObjects() {
  122.         ObjectListing objects = obsClient.listObjects(bucketName);
  123.         return objects;
  124.     }
  125.  
  126.     /**
  127.      * 上传对象时指定预定义访问策略为公共读(很重要)
  128.      *
  129.      * @param objectKey   对象的key
  130.      * @param inputStream 要上传的文件流
  131.      * @return 响应对象
  132.      */
  133. //    @ObsClientAnnotation
  134.     public PutObjectResult putObjectAndSetPreAccessStrategy(String objectKey, InputStream inputStream) {
  135.         PutObjectRequest request = new PutObjectRequest();
  136.         request.setBucketName(bucketName);
  137.         //对象的key 如:  objectname1/text
  138.         request.setObjectKey(objectKey);
  139.         request.setInput(inputStream);
  140.         //设置对象访问权限为公共读
  141.         request.setAcl(AccessControlList.REST_CANNED_PUBLIC_READ);
  142.         return obsClient.putObject(request);
  143.     }
  144.  
  145.     /**
  146.      * 上传对象时指定预定义访问策略为公共读(很重要)
  147.      * @param isImage 是否为图片
  148.      * @param objectKey   对象的key
  149.      * @param file 要上传的文件
  150.      * @return 响应对象
  151.      */
  152. //    @ObsClientAnnotation
  153.     public PutObjectResult putObjectAndSetPreAccessStrategy(String objectKey, File file,Integer isImage) {
  154.         PutObjectRequest request = new PutObjectRequest();
  155.         request.setBucketName(bucketName);
  156.         //对象的key 如:  objectname1/text
  157.         request.setObjectKey(objectKey);
  158.         request.setFile(file);
  159.         //设置元数据 isImage  0:1：文件
  160.         ObjectMetadata metadata = new ObjectMetadata();
  161.         metadata.addUserMetadata("isImage", isImage.toString());
  162.         request.setMetadata(metadata);
  163.         //图片设置为公共读
  164.        /* if(isImage == 0){
  165.             //设置对象访问权限为公共读
  166.             request.setAcl(AccessControlList.REST_CANNED_PUBLIC_READ);
  167.         }*/
  168.         return obsClient.putObject(request);
  169.     }
  170.  
  171.     /**
  172.      * 上传某个对象并设置对象自定义元数据
  173.      *
  174.      * @param objectKey   要上传的key
  175.      * @param metadata    元数据对象
  176.      * @param inputStream 要上传的文件流
  177.      * @return 上传结果
  178.      * //  ObjectMetadata metadata = new ObjectMetadata();
  179.      * //  metadata.addUserMetadata("property1", "property-value1");
  180.      * //  metadata.getMetadata().put("property2", "property-value2");
  181.      * //  C:\\Users\\hufanglei\\Pictures\\timg.jpg"
  182.      */
  183. //    @ObsClientAnnotation
  184.     public PutObjectResult putObjectAndSetMeta(String objectKey, ObjectMetadata metadata, InputStream inputStream) {
  185.         return obsClient.putObject(bucketName, objectKey, inputStream, metadata);
  186.     }
  187.  
  188.     /**
  189.      * 获取某个对象
  190.      *
  191.      * @param objectKey 对象的key
  192.      * @return 对象的信息
  193.      */
  194. //    @ObsClientAnnotation
  195.     public ObsObject getObject(String objectKey) {
  196.         return obsClient.getObject(bucketName, objectKey, null);
  197.     }
  198.  
  199.     /**
  200.      * 获取某个对象的流
  201.      *
  202.      * @param objectKey 对象的key
  203.      * @return 对象的流
  204.      */
  205. //    @ObsClientAnnotation
  206.     public InputStream getObjectInpuStream(String objectKey) {
  207.         ObsObject obsObject = obsClient.getObject(bucketName, objectKey, null);
  208.         return obsObject.getObjectContent();
  209.     }
  210.  
  211.     /**
  212.      * 查询对象元数据(查询某个对象的具体信息)
  213.      *
  214.      * @param objectKey 要查询的key
  215.      * @return 对象元数据
  216.      */
  217. //    @ObsClientAnnotation
  218.     public ObjectMetadata getObjectMetadata(String objectKey) {
  219.         //获取对象元数据
  220.         return obsClient.getObjectMetadata(bucketName, objectKey, null);
  221.     }
  222.  
  223.     /**
  224.      * 拷贝对象(也可以从一个桶拷贝到另一个桶，这里目前桶和原始文件桶都设置成了配置文件中的桶)
  225.      *
  226.      * @param sourceObjectKey 原始key
  227.      * @param destObjectKey   目标key
  228.      * @return 响应结果
  229.      */
  230. //    @ObsClientAnnotation
  231.     public CopyObjectResult copyObject(String sourceObjectKey, String destObjectKey) {
  232.         String sourceBucketName = bucketName;
  233.         String destBucketName = bucketName;
  234.         return obsClient.copyObject(sourceBucketName, sourceObjectKey, destBucketName, destObjectKey);
  235.     }
  236.  
  237.     /**
  238.      * 删除单个对象
  239.      *
  240.      * @param objectKey 要删除的key
  241.      * @return 响应结果
  242.      */
  243. //    @ObsClientAnnotation
  244.     public DeleteObjectResult deletObj(String objectKey) {
  245.         return obsClient.deleteObject(bucketName, objectKey);
  246.     }
  247.  
  248.     /**
  249.      * 删除 对象
  250.      * @param objectKey 对象key
  251.      * @return 是否删除成功
  252.      */
  253.     public boolean deleteObject(String objectKey){
  254.         if(obsClient.doesObjectExist(bucketName,objectKey)){
  255.             obsClient.deleteObject(bucketName,objectKey);
  256.             return true;
  257.         }
  258.         return false;
  259.     }
  260.  
  261.     public boolean isExistObject(String bucketName,String objectKey){
  262.        return obsClient.doesObjectExist(bucketName,objectKey);
  263.     }
  264.     /**
  265.      * 下载某个对象到本地
  266.      *
  267.      * @param objectKey     对象的key
  268.      * @param localFilePath 本地文件路径
  269.      * @throws ObsException
  270.      * @throws IOException
  271.      */
  272. //    @ObsClientAnnotation
  273.     public void downloadToLocalFile(String objectKey, String localFilePath) throws ObsException, IOException {
  274.         File localFile = new File(localFilePath);
  275.         if (!localFile.getParentFile().exists()) {
  276.             localFile.getParentFile().mkdirs();
  277.         }
  278.         ObsObject obsObject = obsClient.getObject(bucketName, objectKey, null);
  279.         ReadableByteChannel rchannel = Channels.newChannel(obsObject.getObjectContent());
  280.         ByteBuffer buffer = ByteBuffer.allocate(4096);
  281.         WritableByteChannel wchannel = Channels.newChannel(new FileOutputStream(new File(localFilePath)));
  282.         while (rchannel.read(buffer) != -1) {
  283.             buffer.flip();
  284.             wchannel.write(buffer);
  285.             buffer.clear();
  286.         }
  287.         rchannel.close();
  288.         wchannel.close();
  289.     }
  290.  
  291.     /**
  292.      * 创建一个文件夹，必须带有/后缀
  293.      *
  294.      * @param keySuffixWithSlash1 文件夹名称（必须带有/后缀）
  295.      * @return 响应对象
  296.      */
  297. //    @ObsClientAnnotation
  298.     public PutObjectResult createEmptyFolder(String bucketName,String keySuffixWithSlash1) {
  299.         return obsClient.putObject(bucketName, keySuffixWithSlash1, new ByteArrayInputStream(new byte[0]));
  300.     }
  301.  
  302.  
  303.     /**
  304.      * 判断对象是否是文件夹
  305.      * @param keySuffixWithSlash1 文件夹名: 如:   "MyObjectKey1/"
  306.      * @return 布尔值
  307.      */
  308. //    @ObsClientAnnotation
  309.     public boolean isEmptyFolder(String keySuffixWithSlash1)  {
  310.         ObsObject object = obsClient.getObject(bucketName, keySuffixWithSlash1, null);
  311.         if (object != null) {
  312.             return object.getMetadata().getContentLength() == 0L;
  313.         }
  314.         return false;
  315.     }
  316.  
  317.     /**
  318.      * 列举某个文件夹下的所有对象
  319.      *
  320.      * @param folderPrefix 件夹名（必须/结尾）
  321.      * @return 对象集合
  322.      */
  323. //    @ObsClientAnnotation
  324.     public ObjectListing listObjectsByFolder(String folderPrefix) {
  325.         ListObjectsRequest request = new ListObjectsRequest(bucketName);
  326.         // 设置文件夹对象名"dir/"为前缀
  327.         // request.setPrefix("dir/");
  328.         request.setPrefix(folderPrefix);
  329.         //列举文件个数
  330.         request.setMaxKeys(1000);
  331.         ObjectListing result;
  332.         do {
  333.             result = obsClient.listObjects(request);
  334.             for (ObsObject obsObject : result.getObjects()) {
  335.                 logger.info("\t" + obsObject.getObjectKey());
  336.                 logger.info("\t" + obsObject.getOwner());
  337.             }
  338.             request.setMarker(result.getNextMarker());
  339.         } while (result.isTruncated());
  340.         return result;
  341.     }
  342.  
  343.     /**
  344.      * 删除某个文件夹下的所有对象
  345.      *
  346.      * @param folderPrefix 文件夹名（必须/结尾）
  347.      * @return 是否删除成功
  348.      */
  349. //    @ObsClientAnnotation
  350.     public boolean deleteListObjectsByFolder(String folderPrefix) {
  351.         ListObjectsRequest request = new ListObjectsRequest(bucketName);
  352.         // 设置文件夹对象名"/xx/xxx/"为前缀
  353.         request.setPrefix(folderPrefix);
  354.         //列举文件个数
  355.         request.setMaxKeys(1000);
  356.         ObjectListing result;
  357.         do {
  358.             result = obsClient.listObjects(request);
  359.             for (ObsObject obsObject : result.getObjects()) {
  360.                 logger.info("\t" + obsObject.getObjectKey());
  361.                 logger.info("\t" + obsObject.getOwner());
  362.                 //执行删除
  363.                 obsClient.deleteObject(bucketName, obsObject.getObjectKey());
  364.             }
  365.             request.setMarker(result.getNextMarker());
  366.         } while (result.isTruncated());
  367.         return true;
  368.     }
  369.  
  370.     /**
  371.      * 批量删除
  372.      * @param objectKeys 文件key集合
  373.      * @param bucketName 桶名
  374.      * @return 删除结果
  375.      */
  376.     public DeleteObjectsResult deleteBatch(String bucketName,List<String> objectKeys){
  377.         DeleteObjectsRequest deleteObjectsRequest = new DeleteObjectsRequest();
  378.         for (String key:objectKeys) {
  379.             deleteObjectsRequest.addKeyAndVersion(key);
  380.         }
  381.         deleteObjectsRequest.setBucketName(bucketName);
  382.         return obsClient.deleteObjects(deleteObjectsRequest);
  383.     }
  384.  
  385.     public void outputErrorInfo(ObsException e){
  386.         logger.info("HTTP Code: " + e.getResponseCode());
  387.         logger.info("Error Code:" + e.getErrorCode());
  388.         logger.info("Error Message: " + e.getErrorMessage());
  389.         logger.info("Request ID:" + e.getErrorRequestId());
  390.         logger.info("Host ID:" + e.getErrorHostId());
  391.     }
  392.  
  393. }

调用OBS工具类以及方法，将上传的文件传入到华为云OBS中。

上传obs成功后的资源如何如何访问。

测试​​​​​​​​​​​​​​

查看obs中是否上传成功。

查看obs上传成功后的返回地址是否可以访问。

- End-
收藏、点赞、转发，是对我最大的鼓励。您的支持就是我坚持下去的最大动力！

另外我的公众号也在同步更新文章。后续会更新SpringCloud alibaba开发实战、Elasticsearch+Logstash+Kibana实战、nginx+ssl+域名实战、日常开发问题闭坑集锦等等....


 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/604109
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号