华为云OBS配置及Java代码访问

最新推荐文章于 2023-12-04 13:51:23 发布
最新推荐文章于 2023-12-04 13:51:23 发布
阅读量978 收藏 1
点赞数
文章标签： java 华为云 spring spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adminstate/article/details/129854475
版权

文章目录

maven依赖

   <dependency>
        <groupId>com.huaweicloud</groupId>
        <artifactId>esdk-obs-java</artifactId>
        <version>3.20.6.1</version>
    </dependency>

yml文件中的配置

#新华为云OSS配置
huaweiobs:
endPoint: https://obs.*****.myhuaweicloud.com
ak: *************
sk: ***************
bucketName: ***********

工具类

package cn.com.yuanquanyun.utils.upload;

import cn.com.jit.cloud.common.MD5Util;
import cn.com.yuanquanyun.common.utils.HmacSha1Util;
import cn.com.yuanquanyun.common.utils.sign.Base64;
import cn.com.yuanquanyun.utils.Des3Util;
import cn.hutool.core.io.IoUtil;
import com.obs.services.model.ObjectMetadata;
import com.obs.services.ObsClient;
import com.obs.services.model.HttpMethodEnum;
import com.obs.services.model.ObsObject;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.*;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * 华为云OBS
 */
@Component
public class OSSUtil {
    static String endPoint;
    static String ak;
    static String sk;
    static String bucketName;
    private final static String KEY_MD5 = "x-obs-meta-plain-md5";

    @Value("${huaweiobs.endPoint}")
    public void setEndPoint(String endPoint) {
        OSSUtil.endPoint = endPoint;
    }
    @Value("${huaweiobs.ak}")
    public void setAk(String ak) {
        OSSUtil.ak = ak;
    }
    @Value("${huaweiobs.sk}")
    public void setSk(String sk) {
        OSSUtil.sk = sk;
    }
    @Value("${huaweiobs.bucketName}")
    public void setBucketName(String bucketName) {
        OSSUtil.bucketName = bucketName;
    }


    public static void upload(String objectName, byte[] content) throws IOException {
        ObsClient obsClient = null;
        try{
            // 构建metadata对象参数
            ObjectMetadata objectMetadata = genMetadata(null, content);
            // 创建ObsClient实例
            obsClient = new ObsClient(ak, sk, endPoint);
            // 使用访问OBS
            obsClient.putObject(bucketName, objectName, new ByteArrayInputStream(Des3Util.encodeBytes(content)),objectMetadata);//带MD5校验
            //obsClient.putObject(bucketName, objectName, new ByteArrayInputStream(Des3Util.encodeBytes(content)));//上传文件时不带MD5，那么下载时，也就不用校验MD5.
            // 关闭obsClient
            obsClient.close();
        }catch (Exception ex){

        }finally {
            if(obsClient != null)
                obsClient.close();
        }

    }

    public static String getUrl(String objectName) {
        // 创建ObsClient实例
        ObsClient obsClient = new ObsClient(ak, sk, endPoint);
        Date expiryTime = new Date(System.currentTimeMillis() + 3600 * 1000);
        String url = obsClient.createSignedUrl(HttpMethodEnum.getValueFromStringCode("GET"),bucketName, objectName, null,expiryTime,null,null);
        return url;
    }


    public static byte[] downloadByte(String objectName) {
        ObsClient obsClient = null;
        try{
            // 创建ObsClient实例
            obsClient = new ObsClient(ak, sk, endPoint);

            ObsObject obsObject = obsClient.getObject(bucketName, objectName);

            InputStream inputStream = obsObject.getObjectContent();
            byte[] content = getBytes(inputStream);
            byte[] decodeBytes = Des3Util.decodeBytes(content);
            return decodeBytes;
        }catch (Exception ex){
            System.err.println(ex);
        } finally {
            if(obsClient != null)
                try{
                    obsClient.close();
                }catch (Exception ex){
                    System.err.println(ex);
                }

        }
        return null;
    }

    public static byte[] getBytes(InputStream fis) {
        byte[] buffer = null;
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            byte[] b = new byte[1024];
            int n;
            while ((n = fis.read(b)) != -1) {
                bos.write(b, 0, n);
            }
            fis.close();
            bos.close();
            buffer = bos.toByteArray();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return buffer;
    }

    public static void deleteLoad(String fileAddress) {
        ObsClient obsClient = null;
        try{
            // 创建ObsClient实例
            obsClient = new ObsClient(ak, sk, endPoint);
            obsClient.deleteObject(bucketName,fileAddress);
        }catch (Exception ex){
            System.err.println(ex);
        } finally {
            if(obsClient != null)
                try{
                    obsClient.close();
                }catch (Exception ex){
                    System.err.println(ex);
                }

        }

    }

    public static String downloadBase64(String objectName) throws IOException {
        ObsClient obsClient = null;
        try{
            // 创建ObsClient实例
            obsClient = new ObsClient(ak, sk, endPoint);

            ObsObject obsObject = obsClient.getObject(bucketName, objectName);

            InputStream inputStream = obsObject.getObjectContent();
            byte[] content = getBytes(inputStream);
            byte[] decodeBytes = Des3Util.decodeBytes(content);
            // MD5 校验 开始
            String savedMd5 = obsObject.getMetadata().getMetadata().get(KEY_MD5).toString();
            System.out.println("savedMd5=="+savedMd5);
            if (StringUtils.isNotBlank(savedMd5)) {
                //
                String calMd5 = MD5Util.MD5(decodeBytes);
                if (!savedMd5.equals(calMd5)) {
                    System.out.println("校验失败！");
                    throw new Exception(objectName + " 数据对象完整性校验失败");
                }else {
                    System.out.println("校验成功！");
                }
            }
            // MD5 校验 开始
            return Base64.encode(decodeBytes);
        }catch (Exception ex){
            System.err.println(ex);
        } finally {
            if(obsClient != null)
                try{
                    obsClient.close();
                }catch (Exception ex){
                    System.err.println(ex);
                }

        }
        return null;
    }

    public static boolean objectExist(String objectName){
        ObsClient obsClient = null;
        try{
            // 创建ObsClient实例
            obsClient = new ObsClient(ak, sk, endPoint);
            boolean exist = obsClient.doesObjectExist(bucketName, objectName);
            obsClient.close();
            return exist;
        }catch (Exception ex){
            System.err.println(ex);
        } finally {
            if(obsClient != null)
                try{
                    obsClient.close();
                }catch (Exception ex){
                    System.err.println(ex);
                }
        }
        return false;
    }

    /**
     * 构建OSS对象属性信息，并对原文做MD5
     *
     * @param map
     * @return
     * @throws Exception
     */
    private static ObjectMetadata genMetadata(Map<String, String> map, byte[] content) {
        // ADD MD5
        if (map == null) {
            map = new HashMap<>();
        }
        String md5val = MD5Util.MD5(content);
        map.put(KEY_MD5, md5val);
        ObjectMetadata objectMetadata = new ObjectMetadata();
        for (Map.Entry<String, String> entry : map.entrySet()) {
            String mapKey = entry.getKey();
            String mapValue = entry.getValue();
            objectMetadata.addUserMetadata(mapKey, mapValue);
        }
        return objectMetadata;
    }

}


package cn.com.yuanquanyun.utils;
import cn.com.yuanquanyun.common.utils.Base64;
import org.apache.commons.lang3.StringUtils;

import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.lang.reflect.Field;
import java.security.Key;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;


public class Des3Util {

    // 向量
    private final static String iv = "097889273";
    // 加解密统一使用的编码方式
    private final static String encoding = "UTF-8";
    // 加密key TODO 做一下非对称的加密
    private final static String secretKey = "dhfkdhdfkliieirtutuj";

    /**
     * 3DES加密
     *
     * @param plainText 普通文本
     * @return
     * @throws Exception
     */
    public static String encode(String plainText) {
        try {
            if (StringUtils.isBlank(plainText)) {
                return plainText;
            }
            Key deskey = null;
            DESedeKeySpec spec = new DESedeKeySpec(secretKey.getBytes());
            SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
            deskey = keyfactory.generateSecret(spec);

            Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
            IvParameterSpec ips = new IvParameterSpec(iv.getBytes());
            cipher.init(Cipher.ENCRYPT_MODE, deskey, ips);
            byte[] encryptData = cipher.doFinal(plainText.getBytes(encoding));
            return Base64.encodeBytes(encryptData);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return plainText;
    }

    /**
     * 3DES解密
     *
     * @param encryptText 加密文本
     * @return
     * @throws Exception
     */
    public static String decode(String encryptText) {
        try {
            if (StringUtils.isBlank(encryptText)) {
                return encryptText;
            }
            Key deskey = null;
            DESedeKeySpec spec = new DESedeKeySpec(secretKey.getBytes());
            SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
            deskey = keyfactory.generateSecret(spec);
            Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
            IvParameterSpec ips = new IvParameterSpec(iv.getBytes());
            cipher.init(Cipher.DECRYPT_MODE, deskey, ips);

            byte[] decryptData = cipher.doFinal(Base64.decode(encryptText));
            return new String(decryptData, encoding);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return encryptText;
    }


    /**
     * 3DES加密
     *
     * @param plainText 普通文本，加密文本为字节数组
     * @return 返回加密后的字节数组
     * @throws Exception
     */
    public static byte[] encodeBytes(byte[] plainText) {
        try {
            if (plainText == null) {
                return null;
            }
            Key deskey = null;
            DESedeKeySpec spec = new DESedeKeySpec(secretKey.getBytes());
            SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
            deskey = keyfactory.generateSecret(spec);

            Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
            IvParameterSpec ips = new IvParameterSpec(iv.getBytes());
            cipher.init(Cipher.ENCRYPT_MODE, deskey, ips);
            byte[] encryptData = cipher.doFinal(plainText);
            return encryptData;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return plainText;
    }

    /**
     * 3DES解密
     *
     * @param encryptText 加密文本，byte[] 为加密原文未经过任何转码
     * @return
     * @throws Exception
     */
    public static byte[] decodeBytes(byte[] encryptText) {
        try {
            if (encryptText == null) {
                return null;
            }
            Key deskey = null;
            DESedeKeySpec spec = new DESedeKeySpec(secretKey.getBytes());
            SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
            deskey = keyfactory.generateSecret(spec);
            Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
            IvParameterSpec ips = new IvParameterSpec(iv.getBytes());
            cipher.init(Cipher.DECRYPT_MODE, deskey, ips);

            byte[] decryptData = cipher.doFinal(encryptText);
            return decryptData;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return encryptText;
    }


    /**
     * 对listMap中的指定字段进行解密
     *
     * @param listMap
     * @return
     */
    public static List<Map<String, Object>> decodeListMap(List<Map<String, Object>> listMap, String... keys) {
        if (listMap != null && listMap.size() > 0 && keys != null && keys.length > 0) {
            for (Map<String, Object> map : listMap) {
                for (int i = 0; i < keys.length; i++) {
                    String key = keys[i];
                    map.put(key, decode((String) map.get(key)));
                }
            }
        }
        return listMap;
    }

    /**
     * 对listMap中的指定字段进行解密
     *
     * @param map
     * @return
     */
    public static Map<String, Object> decodeMap(Map<String, Object> map, String... keys) {
        if (map != null && keys != null && keys.length > 0) {
            for (int i = 0; i < keys.length; i++) {
                String key = keys[i];
                map.put(key, decode((String) map.get(key)));
            }
        }
        return map;
    }

    /**
     * 解密List下对象指定的属性值
     *
     * @param listBean
     * @param keys
     */
    public static <T> List<T> decodeListBean(List<T> listBean, String... keys) {
        if (listBean != null && listBean.size() > 0 && keys != null && keys.length > 0) {
            for (T bean : listBean) {
                decodeBean(bean, keys);
            }
        }
        return listBean;
    }

    /**
     * 解密List下对象指定的属性值
     *
     * @param bean
     * @param keys
     */
    public static <T> T decodeBean(T bean, String... keys) {
        if (bean!= null && keys != null && keys.length > 0) {
            Class<?> bc = bean.getClass();
            for (int i = 0; i < keys.length; i++) {
                Field field = null;
                try {
                    field = bc.getDeclaredField(keys[i]);
                    field.setAccessible(true);
                    String val = (String) field.get(bean);
                    field.set(bean, decode(val));
                } catch (NoSuchFieldException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
        return bean;
    }


    private String aa;

    public String getAa() {
        return aa;
    }

    public void setAa(String aa) {
        this.aa = aa;
    }

    public static void main(String[] args) {

        String text = "17600198405";
        String encryptData = encode(text);
        System.out.println("原始字符串：" + text);
        System.out.println("加密后的值：" + encryptData);


        //
        String jiami = "G/JhLvch4w22Wgn1kRQ334i23migvMZa";
        String decryptorData = decode(jiami);
        System.out.println("解密字符串：" + jiami);
        System.out.println("解密后的值：" + decryptorData);

        List<Des3Util> list  = new ArrayList<>();
        Des3Util d = new Des3Util();
        d.setAa("aWGVfeAnVO9QSN0ZXRZ46f3/apZOOuZP");
        list.add(d);
        decodeListBean(list, "aa");
        System.out.println(d.getAa());


        String temp = "R0uiBsi9kEY=";
        System.out.println(temp.split(",").length);

    }

}
scx_link
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【对象存储】SpringBoot集成华为云OBS对象存储
Infinity的博客
04-25 763
总体思路是后端向华为云OBS服务器申请授权信息并设置过期时间，后端再将授权信息以Map形式发给前端，前端将文件和授权信息直接发给华为云OBS服务器。
华为云obs参考代码以及demo
07-18
稳定 通过多级可靠性架构，保障数据持久性高达99.999999999%（11个9），业务连续性高达99.99% 安全 OBS通过可信云认证，支持服务端加密、防盗链、VPC网络隔离、日志审计、细粒度权限控制，保障数据安全可信 高效 OBS通过智能调度，并结合传输加速、大数据垂直优化，为用户提供高并发、大带宽、稳定低时延的数据访问体验 易用 OBS支持REST API，提供多种语言的SDK，兼容主流的客户端工具，您可以随时随地通过网络上传、下载、管理您的数据
华为云OBS连接Java
m0_66519237的博客
09-18 1025
以上就是连接华为云OBS的基本步骤，具体操作还需根据需求进行相应调整。下载OBS Java SDK，并将SDK添加到项目中。创建OBSClient对象，以便与OBS服务器交互。
java对接华为云obs
HUHAO987654321的博客
11-29 975
log.error("上传失败文件为空或者超过200M:{}", LogExceptionStackUtil.logExceptionStack(e));log.error("obs上传失败:{}", LogExceptionStackUtil.logExceptionStack(e));log.error("文件下载失败{}", LogExceptionStackUtil.logExceptionStack(e));log.info("生成的文件访问名：{}", objectKey);
java操作华为OBS对象存储服务器
热门推荐
wozuhani的博客
11-19 1万+
华为OBS对象存储 一.SDK概述 对象存储服务软件开发工具包（OBS SDK，Object Storage Service Software Development Kit）是对OBS服务提供的REST API进行的封装，以简化用户的开发工作。用户直接调用OBS SDK提供的接口函数即可实现使用OBS服务业务能力的目的。相关开发包请从华为云OBS开发工具包（SDK）（https://develo...
Java - 华为云存储&Ftp文件存储
Mryfl的博客
12-04 719
这个配置类至关重要，为了解决文件无法直接访问的问题。上面这种写法可以扩展多种文件存储。
华为云 OBS esdk-obs-java
最新发布
12-26
华为云 后端 OBS 上传图片，文件 sdk maven 引入 <groupId>com.huaweicloud</groupId> <artifactId>esdk-obs-java <version>3.21.11 </dependency>
华为云 Obs C# 上传代码
10-27
接下来，配置华为云OBS的访问密钥。在华为云控制台获取AccessKey ID和Secret Access Key，并在代码中创建一个` OBSClient`实例，如下所示： ```csharp using HuaweiCloud.SDK.Core.Auth; using HuaweiCloud.SDK.OBS...
华为云OBS的上传下载删除的工具类
02-01
最近做项目遇到了，直接弄个工具类记录一下，包含了华为云的上传，下载，删除的工具类，记得添加hOBS的包 <groupId>com.huaweicloud</groupId> <artifactId>esdk-obs-java-bundle [3.21.11,) </dependency>
华为云、移动云文件服务OBS Browser
05-10
**华为云、移动云文件服务OBS Browser** 华为云与移动云提供的OBS（Object Storage Service）Browser是一款高效、安全的文件管理工具，专为云存储用户设计，旨在简化对象存储的操作，提升工作效率。OBS Browser支持...
华为云鲲鹏服务器部署文档-java微服务.pdf
05-09
华为云鲲鹏服务器部署java微服务的基础软件环境，所有操作均实测通过。包括CentOS 7.6 64bit ARM版基础操作，JDK设置，maven，camke，gcc，node.js，zookeeper，redis，mysql 8.0.17，nginx，golang等等的安装与设置。
esdk-obs-java-3.20.3.zip
06-16
对象存储服务 OBS 对象存储服务（Object Storage Service）是一款稳定、安全、高效、易用的云存储服务，具备标准Restful API接口，可存储任意数量和形式的非结构化数据
华为云obs在java中的使用
12-01 913
下载后，请在java项目里面以本地形式引入。1、申请obs服务。
Java集成华为云对象存储
青春不打烊的博客
07-06 1918
java封装华为云对象存储
如何使用Java在华为云OBS上传大文件？
网络技术联盟站
08-25 1563
在上面的代码中，我们首先定义了OBS服务的端点、AK/SK密钥、OBS桶的名称和要上传的对象的对象键。在使用华为云OBS上传大文件时，我们可以使用Java代码实现，本文将介绍利用Java代码上传大文件至华为云OBS的方法。在本文中，我们介绍了华为云OBS的概念和特点，以及如何使用Java代码将大文件上传到OBS。通过学习和使用OBS，我们可以更好地管理和存储大量的数据，提高数据的安全性和可靠性，提高工作效率和服务质量。上述代码中，首先配置了OBS连接信息，创建OBS客户端，并创建上传请求。
e java sdk,esdk-obs-java 扩展包
weixin_39684454的博客
03-18 440
本SDK是对华为OBS原生SDK(com.huawei.storage:esdk-obs-java)包装，在其基础上，提供断点上传、断点下载、回调、进度速率监控等特性。因此，本SDK不是原生SDK的替代，而是对原生SDK的补充。开发者应首先参考原生SDK的用户手册，在熟悉原生SDK的基础上再使用本SDK。一、功能1. 断点上传将整个上传任务转化为分段上传，每上传完一分段，在断点文件中记录完成分段上...
华为云的obs之自定义springboot-starter
baidu_21349635的专栏
06-01 916
文章目录一、自定义的starter封装好的几个常用方法:一.桶的操作二.对象的操作三.文件夹的操作springboot(华为云的obs)的starter核心工具类代码如何使用starter前提 请注意使用步骤1.引入自定义obs的starter使用步骤2.配置文件设置参数使用步骤3.在springboot的启动类上加上启动注解项目中调用示例springboot(华为云的obs)starter开源项目地址 一、自定义的starter封装好的几个常用方法: 一.桶的操作 查询所有桶 桶的新增 桶的删除 设置桶
华为云OBS文件上传下载工具类
山路曲折盘旋，但毕竟朝着顶峰延伸
07-04 8112
出错原因 ： idea为了能够更快的使用共享索引，会下载JDK和Maven库的共享索引，给你的的项目代码构建共享索引。但是由于国内的网络环境，导致下载索引速度过慢，idea无法成功下载这个索引就会导致这个问题。解决问题： 打开idea的设置，.........
java华为云obs上传
06-28
Java华为云OBS上传是一种方便快捷的云存储服务，可以实现将本地文件或流直接上传至华为云OBS中。使用Java SDK可快速构建OBS上传功能，使用流程如下： 1. 导入Java SDK依赖包，并初始化OBSClient对象； 2. 创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值