精华内容
下载资源
问答
  • COS对象存储

    2020-12-31 18:51:20
    最近公司有用到COS对象存储,接下来和大家一起聊聊对象存储,实际上存储这一块在我之前的博客中有提到,博客中讲述了分布式文件系统存储、块存储和对象存储的相关工作原理及三者之间的区别,大家感兴趣的话可以去看...


    前言

    最近公司有用到COS对象存储,接下来和大家一起聊聊对象存储,实际上存储这一块在我之前的博客中有提到,博客中讲述了分布式文件系统存储、块存储和对象存储的相关工作原理及三者之间的区别,大家感兴趣的话可以去看一看我这篇博客《Ceph分布式存储》

    一、COS概述

    COS 对象存储是在云上提供无层次结构的分布式存储产品,为用户提供单价较低且快速可靠的数据存储方案。COS 以冗余的方式跨多个可用区存储用户数据,并允许多个不同的客户端或应用程序线程同时对这些数据进行读或写操作。同时可通过云服务器实例或互联网使用 Web API 接口存储和检索数据。

    1、对象存储和文件存储的区别?

    • 对象存储

      无目录层次结构、无数据格式限制,可存储任意数量的数据,存储桶空间无容量上限,无需分区管理。数据支持高可用架构部署,设计保障数据最终一致性,不支持文件锁等特性。API 使用 HTTP/HTTPS 的协议访问,并提供 SDK 和工具等方式与业务集成,上传到 COS 的对象可通过 URL 地址直接访问或下载。

    • 文件存储

      使用常用的网络文件传输协议,可创建文件系统并实现大规模扩展,需挂载在云服务器中使用。文件存储可为网站、在线发行、存档各种应用存储。 计算吞吐量高,具有极高的可用性和持久性,也适用于并发较高或需要共享存储的需求。

    2、对象存储和云硬盘的区别?

    • 对象存储

      对象存储具备无文件系统、目录结构、文件数量和空间上限的特性,需通过 Web API 接口管理和访问存储,提供了 SDK 和工具等集成,可以不依托云服务器单独使用。对象存储支持大规模数据的访问,但不适合毫秒级响应或随机读写的场景。

    • 云硬盘

      云硬盘需要搭配云服务器,使用文件系统分区或格式化后,才可以被挂载使用。根据云硬盘不同的类型,针对不同的性能指标提供了区别 IOPS 和吞吐性能的产品,可满足单机使用的不同场景。

    3、应用场景

    对于COS对象存储来说,它又可分为:标准存储、低频存储、归档存储。

    • 标准存储

      标准存储(默认)适用于实时访问大量热点文件、频繁的数据交互等业务场景。

    • 低频存储

      低频存储数据取回会产生费用,适用于较低访问频率(例如平均每月访问频率1到2次)的业务场景。

    • 归档存储

      归档存储提供了最低的存储单价,但读取数据时需要较长解冻时间,因而适合需要长期保存数据的业务场景。

    二、基本概念

    • 存储桶(bucket):是对象的载体,可理解为存放对象的“容器”。
    • 对象(Object):是对象存储的基本单元,可理解为任何格式类型的数据,例如图片、文档和音视频文件等。
    • 地域(Region):是腾讯云托管机房的分布地区,对象存储 COS 的数据存放在这些地域的存储桶中。
    • 访问域名(Endpoint):对象被存放到存储桶中,用户可通过访问域名访问和下载对象。

    三、COS优点

    • 稳定持久

      腾讯云对象存储提供数据跨多架构、多设备冗余存储,为用户数据提供异地容灾和资源隔离功能。

    • 安全可靠

      COS 提供防盗链功能,可屏蔽恶意来源的访问;支持数据 SSL 加密传输,控制每个单独文件的读写权限。

    • 成本最优

      使用 COS,无需传统硬件的采购、部署和运维,节省了运维工作和托管成本。

    • 简单易用

      COS 提供图形化程序、命令行工具、协议工具等多种途径对存储对象进行批量操作,让使用更为简单。

    • 接入便捷

      COS 提供丰富的 SDK 接入工具,简单且可靠,同时COS 提供无缝迁移工具进行迁移和接入。

    • 服务集成

      COS 支持与其他腾讯云产品联动,包括 CDN 加速、数据万象图片处理、音视频转码、文件预览等组件。

    四、COS管理

    4.1 基本概念

    • 存储桶(bucket):是对象的载体,可理解为存放对象的“容器”。
    • 对象(Object):是对象存储的基本单元,可理解为任何格式类型的数据,例如图片、文档和音视频文件等。
    • 地域(Region):是腾讯云托管机房的分布地区,对象存储 COS 的数据存放在这些地域的存储桶中。

    4.2 基本操作

    1、创建存储桶

    我们需要创建一个用于存放对象的存储桶:

    (1)在对象存储控制台左侧导航栏中单击【存储桶列表】,进入存储桶管理页。

    (2)单击【创建存储桶】,输入以下配置信息,其他配置保持默认即可。

    • 名称:输入存储桶名称。名称设置后不可修改。
    • 所属地域:存储桶所属地域,选择与您业务最近的一个地区,例如广州地域。
    • 访问权限:存储桶访问权限,此处我们保持默认为“私有读写”。

    (3)单击【确定】,即可创建完成。

    2、上传对象

    从本地选择文件上传到存储桶:

    (1)单击存储桶名称,进入存储桶列表页。

    (2)选择【上传文件】–>【选择文件】,选择需要上传至存储桶的文件,上传相应的文件。

    (3)单击【上传】,即可将对应的文件上传至存储桶。

    3、下载对象

    将云上数据下载到本地:

    (1)单击文件 exampleobjext.txt 右侧的【详情】,进入对象属性页。

    (2)在【基本信息】配置项中,单击【下载对象】即可下载,或单击【复制临时链接】至浏览器下载该对象。

    以上操作均有腾讯云文档提供,操作并不难,也不是重点,重点的是搞清COS对象存储的工作原理,以及与块存储、文件系统存储之间的区别以及优缺点。

    五、COSBrowser

    COSBrowser 是腾讯云对象存储 COS 推出的可视化界面工具,可实现对 COS 资源的查看、传输和管理。COS 对象存储使用的工具有很多,比如:COSCMD、COS Migration等。目前 COSBrowser 有桌面端和移动端两种,本次主要讲桌面端的相关操作及功能。

    5.1 登录界面

    COSBrowser 桌面端仅支持云 API 密钥进行登录使用,API秘钥可在COS实例中获取,软件登录界面如下所示:

    在这里插入图片描述

    上图中 SecretID 和 SecretKey 可在 COS 对象存储控制台中创建并获取,如下图所示:

    在这里插入图片描述

    5.2 基本功能

    • 创建/删除存储桶
    • 查看存储桶详情
    • 添加访问路径
    • 上传文件/文件夹
    • 下载文件/文件夹
    • 删除文件/文件夹
    • 复制粘贴文件

    功能还有很多,以上只列举一部分功能,更多功能可查阅官方文档。

    COS 对象存储使用的工具还有很多,比如:COSCMD、COS Migration、FTP Server、COSFS、Hadoop等工具,实际上不管用哪种工具,其基本的操作和功能都差不多。

    六、FAQ

    1、COS数据误删问题

    • 问题描述:

      对象存储 COS 的数据冗余存储机制是针对服务器等硬件出现故障时需要数据恢复的场景进行设计的。如果主动对 COS 的数据手动删除或进行配置删除后,删除后的数据将无法恢复。

    • 解决方案

      (1)对存储桶文件做定时备份操作:

      • 使用 COSCMD 工具将 COS 内对象下载至本地或第三方服务器。
      • 使用 COS Migration 工具或者跨地域复制功能实现同地域或跨地域的存储桶数据备份。
      • 定期使用 COS API、SDK,将数据备份到 COS 的其他存储桶。
      • 使用版本控制保存您的历史版本数据。

      (2)使用 COS 权限管理:

      • 读写权限分离,对于只需要读数据的业务、只使用具有读权限的子账号或临时密钥进行访问。
      • 存储桶(Bucket)权限分离,针对不同的业务,只授权对应业务范围内的存储桶、目录和操作权限。
      • 不使用主账号访问 COS。
      • 使用临时密钥访问 COS。
      • 妥善保管数据访问的凭据,如腾讯云账号密码、CAM 子账号访问凭据、腾讯云 API 密钥等。

    2、API接口调用

    • 问题描述:

      在调用 API 接口时,出现“Request has expired”等错误信息。

    • 解决方案

      出现该提示,存在两种可能:

      (1)一是因为您发起请求的时间超过了签名的有效时间;

      (2)二是您本地系统时间和所在时区的时间不一致。

      针对第一种可能,可重新获取有效的请求签名再进行 API 操作。若是第二种可能,将你本地系统时间按照所在时区的时间进行校正。

    参考资料:腾讯云文档-COS对象存储

    <点击跳转至开头>

    展开全文
  • 腾讯云---COS对象存储上传前言一、COS对象存储什么?二、COS对象存储能做什么?1.图文介绍流程2.简单介绍三、COS对象存储怎么使用?1.准备工作2.本文引用javaSDK版本示例3.可能用到的工具类总结 前言 作者标签:...

    前言

    作者标签:自己选择的路,没有什么后悔的。

    本文章主要介绍,腾讯云COS对象存储上传文件实例并进行封装。


    一、COS对象存储是什么?

    COS对象存储简单来说就是为大家上传文件,处理文件的,开发上传文件到本地会有带宽,占用物理内存等种种限制,所以单独抽出来,进行存储,单独存放到公共资源。

    二、COS对象存储能做什么?

    1.图文介绍流程

    COS 用于数据处理(来自腾讯云官网)

    对象存储流程

    COS 用于内容分发(来自腾讯云官网)

    内容分发

    2.简单介绍

    对象存储(Cloud Object Storage,COS)是一种存储海量文件的分布式存储服务,用户可通过网络随时存储和查看数据。腾讯云 COS 使所有用户都能使用具备高扩展性、低成本、可靠和安全的数据存储服务。

    简单来说,就是可以为大家上传文件提供公共接口,上传到线上资源库,通过腾讯云进行内容分发,用户进行访问。

    三、COS对象存储怎么使用?

    腾讯云官方文档:https://cloud.tencent.com/document/product/436/38484

    1.准备工作

    初次使用对象存储 COS,建议您先了解以下基本概念:

    1. 存储桶(bucket):是对象的载体,可理解为存放对象的“容器”。
    2. 对象(Object):是对象存储的基本单元,可理解为任何格式类型的数据,例如图片、文档和音视频文件等。
    3. 地域(Region):是腾讯云托管机房的分布地区,对象存储 COS 的数据存放在这些地域的存储桶中。

    2.本文引用javaSDK版本示例

    • 安装sdk依赖
    • 代码如下(示例):
    		<!--腾讯云COS-->
    		     <dependency>
    		         <groupId>com.tencentcloudapi</groupId>
    		         <artifactId>tencentcloud-sdk-java</artifactId>
    		         <version>3.0.1</version>
    		     </dependency>
    		     <dependency>
    		         <groupId>com.qcloud</groupId>
    		         <artifactId>cos_api</artifactId>
    		         <version>5.6.8</version>
    		     </dependency>
    		<!--腾讯云COS-->
    
    • 封装上传配置配置类
    import com.qcloud.cos.COSClient;
    import com.qcloud.cos.ClientConfig;
    import com.qcloud.cos.auth.BasicCOSCredentials;
    import com.qcloud.cos.auth.COSCredentials;
    import com.qcloud.cos.region.Region;
    import com.ruoyi.common.utils.StringUtils;
    import com.ruoyi.common.utils.file.MimeTypeUtils;
    import com.ruoyi.common.utils.uuid.IdUtils;
    import org.apache.commons.io.FilenameUtils;
    import org.springframework.web.multipart.MultipartFile;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.io.OutputStream;
    
    /**
     * @program: cos
     * @description: 存储桶信息配置类
     * @author: Sun
     * @create: 2020-11-19 15:32
     **/
    
    public class TencentCosConfig {
        //存储桶ID
        public static final String COS_APP_ID = "YOUR APPID";
        //存储桶名称
        public static final String COS_BUCKET_NAME = "YOUR BUCKET_NAME";
        //存储桶region名称
        public static final String COS_REGION_NAME = "YOUR REGION_NAME";
        //存储桶密钥id
        public static final String COS_SECRET_ID = "YOUR SECRET_ID";
        //存储桶密钥ley
        public static final String COS_SECRET_KEY = "YOUR SECRET_KEY";
        //存储桶对象Key 前缀
        public static final String COS_RESORCE_PATH="/XXX/xxx/";
        //存储桶访问域名
        public static final String COS_DOMAIN_URL="YOUR DOMAIN_URL";
    
    
    
    
        /**
         *
         * 方法名称:获取存储桶客户端
         * @return : com.qcloud.cos.COSClient
         * @author : Sun
         * @date : 2020/11/19
         */
        public static COSClient getCosClient(){
            // 1 初始化用户身份信息(secretId, secretKey)。
            COSCredentials cred = new BasicCOSCredentials(COS_SECRET_ID, COS_SECRET_KEY);
            // 2 设置 bucket 的区域, COS 地域的简称请参照 https://cloud.tencent.com/document/product/436/6224
            // clientConfig 中包含了设置 region, https(默认 http), 超时, 代理等 set 方法, 使用可参见源码或者常见问题 Java SDK 部分。
            Region region = new Region(COS_REGION_NAME);
            ClientConfig clientConfig = new ClientConfig(region);
            // 3 生成 cos 客户端。
            return new COSClient(cred, clientConfig);
        }
    
        /**
         *
         * 方法名称:获取对象键(Key)是对象在存储桶中的唯一标识。
         *
         * 功能描述:
         * 〈
         *   获取对象键(Key)是对象在存储桶中的唯一标识。
         *   桶内没有文件架的概念
         *   例如,在对象的访问域名
         *   https://examplebucket-1250000000.cos.ap-guangzhou.myqcloud.com/images/picture.jpg 中,
         *   对象键为 images/picture.jpg,
         *   对象键就是访问域名后面的所有路径URL  并且唯一
         *  〉
         *
         * @param file 1
         * @param path 2
         * @return : java.lang.String
         * @author : Sun
         * @date : 2020/11/19
         */
        public static String getCosFileKey(MultipartFile file,String path){
            if (StringUtils.isNotNull(path)){
                //模拟路径:/campus/res/sysimg/ + circle/schoo_id/ + xxx.后缀
                return COS_RESORCE_PATH+path+getUniqueFilename(file);
            }
            //模拟路径:/campus/res/sysimg/ + xxx.后缀
            return COS_RESORCE_PATH+getUniqueFilename(file);
        }
    
    
        /**
         * 设置:获取唯一文件名字
         */
        private static  String  getUniqueFilename(MultipartFile file)
        {
            String fileName = file.getOriginalFilename();
            String extension = getExtension(file);
            fileName =  IdUtils.fastUUID() + "." + extension;
            return fileName;
        }
    
    
        /**
         * 获取文件名的后缀
         *
         * @param file 表单文件
         * @return 后缀名
         */
        private static  String getExtension(MultipartFile file)
        {
            String extension = FilenameUtils.getExtension(file.getOriginalFilename());
            if (StringUtils.isEmpty(extension))
            {
                extension = MimeTypeUtils.getExtension(file.getContentType());
            }
            return extension;
        }
    
    
        /**
         *
         * 方法名称:MultipartFile 文件类型转换成File 类型
         *
         * 功能描述:
         * 〈〉
         *
         * @param multipartFile 1
         * @return : java.io.File
         * @author : Sun
         * @date : 2020/11/19
         */
        public static File transferToFile(MultipartFile multipartFile) throws Exception {
            File toFile = null;
            if (multipartFile.equals("") || multipartFile.getSize() <= 0) {
                multipartFile = null;
            } else {
                InputStream ins = null;
                ins = multipartFile.getInputStream();
                toFile = new File(multipartFile.getOriginalFilename());
                inputStreamToFile(ins, toFile);
                ins.close();
            }
            return toFile;
        }
    
        //获取流文件
        private static void inputStreamToFile(InputStream ins, File file) {
            try {
                OutputStream os = new FileOutputStream(file);
                int bytesRead = 0;
                byte[] buffer = new byte[8192];
                while ((bytesRead = ins.read(buffer, 0, 8192)) != -1) {
                    os.write(buffer, 0, bytesRead);
                }
                os.close();
                ins.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    • 封装公共上传方法工具类

    代码如下(示例):

    import java.io.File;
    
    /**
     * @program: cos
     * @description: 腾讯云COS上传文件工具类
     * @author: Sun
     * @create: 2020-11-19 15:30
     **/
    
    public class TencentCosFileUtils {
    
        /**
         *
         * 方法名称:腾讯COS上传文件方法
         *
         * 功能描述:
         * 〈腾讯COS上传文件方法〉
         *
         * @param multipartFile 文件名称
         * @param path 文件路径/  分类路径 将照片进行分类
         * @return : java.lang.String
         * @author : Sun
         * @date : 2020/11/19
         */
        public static String cosUploadFile(MultipartFile multipartFile, String path) {
            //1.获取存储桶客户端
            COSClient cosClient = TencentCosConfig.getCosClient();
            //2.获取对象key
            String cosFileKey = TencentCosConfig.getCosFileKey(multipartFile,path);
            try {
            //3.将multipartFile转换成FILE类型
            File localFile = TencentCosConfig.transferToFile(multipartFile);
            //4.创建存储对象的请求
            PutObjectRequest putObjectRequest = new PutObjectRequest(TencentCosConfig.COS_BUCKET_NAME, cosFileKey, localFile);
            //5.执行上传并返回结果信息
            PutObjectResult putObjectResult = cosClient.putObject(putObjectRequest);
            } catch (Exception e){
                System.out.println("-----上传文件出错-----"+e.getMessage());
                e.printStackTrace();
            }finally {
                cosClient.shutdown();
            }
            return TencentCosConfig.COS_DOMAIN_URL+cosFileKey;
        }
    
    
        /**
         * 方法名称:删除COS上的文件
         * 功能描述:
         * 〈〉
         * @param filePathUrl 1
         * @return : void
         * @author : Sun
         * @date : 2020/11/19
         */
        public static void cosDeleteFile(String filePathUrl) {
            //1.获取存储桶客户端
            COSClient cosClient = TencentCosConfig.getCosClient();
            try {
            //2.指定要删除的 对象桶 和 对象key
            String[] srr =  filePathUrl.split(TencentCosConfig.COS_DOMAIN_URL);
            String key = srr[1];
            cosClient.deleteObject(TencentCosConfig.COS_BUCKET_NAME, key);
            } catch (Exception e){
                System.out.println("-----上传文件出错-----"+e.getMessage());
                e.printStackTrace();
            }finally {
                cosClient.shutdown();
            }
        }
    }
    
    

    3.可能用到的工具类

    • 字符串工具类

    代码如下(示例):

    import java.util.Collection;
    import java.util.Map;
    import com.ruoyi.common.core.text.StrFormatter;
    
    /**
     * 字符串工具类
     */
    public class StringUtils extends org.apache.commons.lang3.StringUtils
    {
        /** 空字符串 */
        private static final String NULLSTR = "";
    
        /** 下划线 */
        private static final char SEPARATOR = '_';
    
        /**
         * 获取参数不为空值
         * 
         * @param value defaultValue 要判断的value
         * @return value 返回值
         */
        public static <T> T nvl(T value, T defaultValue)
        {
            return value != null ? value : defaultValue;
        }
    
        /**
         * * 判断一个Collection是否为空, 包含List,Set,Queue
         * 
         * @param coll 要判断的Collection
         * @return true:为空 false:非空
         */
        public static boolean isEmpty(Collection<?> coll)
        {
            return isNull(coll) || coll.isEmpty();
        }
    
        /**
         * * 判断一个Collection是否非空,包含List,Set,Queue
         * 
         * @param coll 要判断的Collection
         * @return true:非空 false:空
         */
        public static boolean isNotEmpty(Collection<?> coll)
        {
            return !isEmpty(coll);
        }
    
        /**
         * * 判断一个对象数组是否为空
         * 
         * @param objects 要判断的对象数组
         ** @return true:为空 false:非空
         */
        public static boolean isEmpty(Object[] objects)
        {
            return isNull(objects) || (objects.length == 0);
        }
    
        /**
         * * 判断一个对象数组是否非空
         * 
         * @param objects 要判断的对象数组
         * @return true:非空 false:空
         */
        public static boolean isNotEmpty(Object[] objects)
        {
            return !isEmpty(objects);
        }
    
        /**
         * * 判断一个Map是否为空
         * 
         * @param map 要判断的Map
         * @return true:为空 false:非空
         */
        public static boolean isEmpty(Map<?, ?> map)
        {
            return isNull(map) || map.isEmpty();
        }
    
        /**
         * * 判断一个Map是否为空
         * 
         * @param map 要判断的Map
         * @return true:非空 false:空
         */
        public static boolean isNotEmpty(Map<?, ?> map)
        {
            return !isEmpty(map);
        }
    
        /**
         * * 判断一个字符串是否为空串
         * 
         * @param str String
         * @return true:为空 false:非空
         */
        public static boolean isEmpty(String str)
        {
            return isNull(str) || NULLSTR.equals(str.trim());
        }
    
        /**
         * * 判断一个字符串是否为非空串
         * 
         * @param str String
         * @return true:非空串 false:空串
         */
        public static boolean isNotEmpty(String str)
        {
            return !isEmpty(str);
        }
    
        /**
         * * 判断一个对象是否为空
         * 
         * @param object Object
         * @return true:为空 false:非空
         */
        public static boolean isNull(Object object)
        {
            return object == null;
        }
    
        /**
         * * 判断一个对象是否非空
         * 
         * @param object Object
         * @return true:非空 false:空
         */
        public static boolean isNotNull(Object object)
        {
            return !isNull(object);
        }
    
        /**
         * * 判断一个对象是否是数组类型(Java基本型别的数组)
         * 
         * @param object 对象
         * @return true:是数组 false:不是数组
         */
        public static boolean isArray(Object object)
        {
            return isNotNull(object) && object.getClass().isArray();
        }
    
        /**
         * 去空格
         */
        public static String trim(String str)
        {
            return (str == null ? "" : str.trim());
        }
    
        /**
         * 截取字符串
         * 
         * @param str 字符串
         * @param start 开始
         * @return 结果
         */
        public static String substring(final String str, int start)
        {
            if (str == null)
            {
                return NULLSTR;
            }
    
            if (start < 0)
            {
                start = str.length() + start;
            }
    
            if (start < 0)
            {
                start = 0;
            }
            if (start > str.length())
            {
                return NULLSTR;
            }
    
            return str.substring(start);
        }
    
        /**
         * 截取字符串
         * 
         * @param str 字符串
         * @param start 开始
         * @param end 结束
         * @return 结果
         */
        public static String substring(final String str, int start, int end)
        {
            if (str == null)
            {
                return NULLSTR;
            }
    
            if (end < 0)
            {
                end = str.length() + end;
            }
            if (start < 0)
            {
                start = str.length() + start;
            }
    
            if (end > str.length())
            {
                end = str.length();
            }
    
            if (start > end)
            {
                return NULLSTR;
            }
    
            if (start < 0)
            {
                start = 0;
            }
            if (end < 0)
            {
                end = 0;
            }
    
            return str.substring(start, end);
        }
    
        /**
         * 格式化文本, {} 表示占位符<br>
         * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
         * 如果想输出 {} 使用 \\转义 { 即可,如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
         * 例:<br>
         * 通常使用:format("this is {} for {}", "a", "b") -> this is a for b<br>
         * 转义{}: format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
         * 转义\: format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
         * 
         * @param template 文本模板,被替换的部分用 {} 表示
         * @param params 参数值
         * @return 格式化后的文本
         */
        public static String format(String template, Object... params)
        {
            if (isEmpty(params) || isEmpty(template))
            {
                return template;
            }
            return StrFormatter.format(template, params);
        }
    
        /**
         * 下划线转驼峰命名
         */
        public static String toUnderScoreCase(String str)
        {
            if (str == null)
            {
                return null;
            }
            StringBuilder sb = new StringBuilder();
            // 前置字符是否大写
            boolean preCharIsUpperCase = true;
            // 当前字符是否大写
            boolean curreCharIsUpperCase = true;
            // 下一字符是否大写
            boolean nexteCharIsUpperCase = true;
            for (int i = 0; i < str.length(); i++)
            {
                char c = str.charAt(i);
                if (i > 0)
                {
                    preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
                }
                else
                {
                    preCharIsUpperCase = false;
                }
    
                curreCharIsUpperCase = Character.isUpperCase(c);
    
                if (i < (str.length() - 1))
                {
                    nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
                }
    
                if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase)
                {
                    sb.append(SEPARATOR);
                }
                else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase)
                {
                    sb.append(SEPARATOR);
                }
                sb.append(Character.toLowerCase(c));
            }
            return sb.toString();
        }
    
        /**
         * 是否包含字符串
         * 
         * @param str 验证字符串
         * @param strs 字符串组
         * @return 包含返回true
         */
        public static boolean inStringIgnoreCase(String str, String... strs)
        {
            if (str != null && strs != null)
            {
                for (String s : strs)
                {
                    if (str.equalsIgnoreCase(trim(s)))
                    {
                        return true;
                    }
                }
            }
            return false;
        }
    
        /**
         * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空,则返回空字符串。 例如:HELLO_WORLD->HelloWorld
         * 
         * @param name 转换前的下划线大写方式命名的字符串
         * @return 转换后的驼峰式命名的字符串
         */
        public static String convertToCamelCase(String name)
        {
            StringBuilder result = new StringBuilder();
            // 快速检查
            if (name == null || name.isEmpty())
            {
                // 没必要转换
                return "";
            }
            else if (!name.contains("_"))
            {
                // 不含下划线,仅将首字母大写
                return name.substring(0, 1).toUpperCase() + name.substring(1);
            }
            // 用下划线将原始字符串分割
            String[] camels = name.split("_");
            for (String camel : camels)
            {
                // 跳过原始字符串中开头、结尾的下换线或双重下划线
                if (camel.isEmpty())
                {
                    continue;
                }
                // 首字母大写
                result.append(camel.substring(0, 1).toUpperCase());
                result.append(camel.substring(1).toLowerCase());
            }
            return result.toString();
        }
    
        /**
         * 驼峰式命名法
         * 例如:user_name->userName
         */
        public static String toCamelCase(String s)
        {
            if (s == null)
            {
                return null;
            }
            if (s.indexOf(SEPARATOR) == -1)
            {
                return s;
            }
            s = s.toLowerCase();
            StringBuilder sb = new StringBuilder(s.length());
            boolean upperCase = false;
            for (int i = 0; i < s.length(); i++)
            {
                char c = s.charAt(i);
    
                if (c == SEPARATOR)
                {
                    upperCase = true;
                }
                else if (upperCase)
                {
                    sb.append(Character.toUpperCase(c));
                    upperCase = false;
                }
                else
                {
                    sb.append(c);
                }
            }
            return sb.toString();
        }
    
        @SuppressWarnings("unchecked")
        public static <T> T cast(Object obj)
        {
            return (T) obj;
        }
    }
    
    
    • 媒体类型工具类
    /**
     * 媒体类型工具类
     */
    public class MimeTypeUtils
    {
        public static final String IMAGE_PNG = "image/png";
    
        public static final String IMAGE_JPG = "image/jpg";
    
        public static final String IMAGE_JPEG = "image/jpeg";
    
        public static final String IMAGE_BMP = "image/bmp";
    
        public static final String IMAGE_GIF = "image/gif";
    
        public static final String[] IMAGE_EXTENSION = { "bmp", "gif", "jpg", "jpeg", "png" };
    
        public static final String[] FLASH_EXTENSION = { "swf", "flv" };
    
        public static final String[] MEDIA_EXTENSION = { "swf", "flv", "mp3", "wav", "wma", "wmv", "mid", "avi", "mpg",
                "asf", "rm", "rmvb" };
    
        public static final String[] VIDEO_EXTENSION = { "mp4", "avi", "rmvb" };
    
        public static final String[] DEFAULT_ALLOWED_EXTENSION = {
                // 图片
                "bmp", "gif", "jpg", "jpeg", "png",
                // word excel powerpoint
                "doc", "docx", "xls", "xlsx", "ppt", "pptx", "html", "htm", "txt",
                // 压缩文件
                "rar", "zip", "gz", "bz2",
                // 视频格式
                "mp4", "avi", "rmvb",
                // pdf
                "pdf" };
    
        public static String getExtension(String prefix)
        {
            switch (prefix)
            {
                case IMAGE_PNG:
                    return "png";
                case IMAGE_JPG:
                    return "jpg";
                case IMAGE_JPEG:
                    return "jpeg";
                case IMAGE_BMP:
                    return "bmp";
                case IMAGE_GIF:
                    return "gif";
                default:
                    return "";
            }
        }
    }
    
    
    • ID生成器工具类
    /**
     * ID生成器工具类
     *
     */
    public class IdUtils
    {
        /**
         * 获取随机UUID
         * 
         * @return 随机UUID
         */
        public static String randomUUID()
        {
            return UUID.randomUUID().toString();
        }
    
        /**
         * 简化的UUID,去掉了横线
         * 
         * @return 简化的UUID,去掉了横线
         */
        public static String simpleUUID()
        {
            return UUID.randomUUID().toString(true);
        }
    
        /**
         * 获取随机UUID,使用性能更好的ThreadLocalRandom生成UUID
         * 
         * @return 随机UUID
         */
        public static String fastUUID()
        {
            return UUID.fastUUID().toString();
        }
    
        /**
         * 简化的UUID,去掉了横线,使用性能更好的ThreadLocalRandom生成UUID
         * 
         * @return 简化的UUID,去掉了横线
         */
        public static String fastSimpleUUID()
        {
            return UUID.fastUUID().toString(true);
        }
    }
    
    
    • 测试接口
     @PostMapping("/testUploadFile")
        @ResponseBody
        public String testUploadFile(MultipartFile file, Integer yourUserId)
        {
            try
            {
                // 上传文件分类路径
                String filePath =yourUserId+"/";
                // 上传文件返回全路径
                String cosFilePathUrl = TencentCosFileUtils.cosUploadFile(file, filePath);
                return cosFilePathUrl;
            }
            catch (Exception e)
            {
                return e.getMessage();
            }
        }
    

    总结

    以上就是对腾讯云COS的讲解和通过COS进行文件上传的封装。谢谢大家的观看,抽空点个赞呗~

    展开全文
  • COS对象存储服务的使用

    万次阅读 2016-12-14 15:58:23
    官网的简介是这样的:对象存储服务(Cloud Object Service)是面向企业和个人开发者提供的高可用,高稳定,强安全的云端存储服务。然后我最开始是抱着死马当活马医的心态来使用的,进度上面要求我是要尽快完成的,...
    ---------------------------------------------------------------------------------------------
    
    [版权申明:本文系作者原创,转载请注明出处] 
    文章出处: http://blog.csdn.net/sdksdk0/article/details/53639792
    作者:朱培      ID:sdksdk0     

    --------------------------------------------------------------------------------------------

    在很多图片上传以及文件上传下载操作的时候,我之前一直使用的是nginx在服务器中划分出一个静态的文件服务器,我主要用于存放图片。然后因为某种原因,然后我换成了COS。

    官网的简介是这样的:

    对象存储服务(Cloud Object Service)是面向企业和个人开发者提供的高可用,高稳定,强安全的云端存储服务。您可以将任意数量和形式的非结构化数据放入COS,并在其中实现数据的管理和处理。COS支持标准的Restful API接口,您可以快速上手使用,按实际使用量计费,无最低使用限制。


    然后我最开始是抱着死马当活马医的心态来使用的,进度上面要求我是要尽快完成的,而且我发现对于我这种小网站来说使用这个COS服务基本上是免费的,简直就是捡到宝的感觉,哈哈!所以我就赶紧放弃了我的nginx图片服务器。然后去github上面下载他们的官方文档。

    https://github.com/tencentyun/cos-java-sdk-v4

    在在里面有个demo.java,然后直接拿过来用就行了。因为我项目上传的图片是要按年月日自动生成目录来存放的,所以官方提供的那段代码是非常不够用的。

    maven坐标是:

    <dependency>
    				<groupId>com.qcloud</groupId>
    				<artifactId>cos_api</artifactId>
    				<version>4.2</version>
    			</dependency>

    一般在真实项目中只导入这个是不行的,还需要加入http的jar包,所以还需要:而且这个版本还要匹配,否则在本地localhost的时候是可以用的,但是一道服务器上就会说你少jar包了。

    <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpmime -->
    		<dependency>
    			<groupId>org.apache.httpcomponents</groupId>
    			<artifactId>httpmime</artifactId>
    			<version>4.3.1</version>
    		</dependency>
    		<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpcore -->
    		<dependency>
    			<groupId>org.apache.httpcomponents</groupId>
    			<artifactId>httpcore</artifactId>
    			<version>4.3</version>
    		</dependency>
    		<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
    		<dependency>
    			<groupId>org.apache.httpcomponents</groupId>
    			<artifactId>httpclient</artifactId>
    			<version>4.3.1</version>
    		</dependency>

    资源初始化:


    // 设置用户属性, 包括appid, secretId和SecretKey
            // 这些属性可以通过cos控制台获取(https://console.qcloud.com/cos)
            long appId = 1000000;
            String secretId = "xxxxxxxxxxxxxxxxxxxxxxxxxxx";
            String secretKey = "xxxxxxxxxxxxxxxxxxxxxxxxxx";
            // 设置要操作的bucket
            String bucketName = "xxxxxxxxx";
            // 初始化客户端配置
            ClientConfig clientConfig = new ClientConfig();
            // 设置bucket所在的区域,比如广州(gz), 天津(tj)
            clientConfig.setRegion("gz");
            // 初始化秘钥信息
            Credentials cred = new Credentials(appId, secretId, secretKey);
            // 初始化cosClient
            COSClient cosClient = new COSClient(clientConfig, cred);


    我只使用了其中的文件上传功能:


    // 1. 上传文件(默认不覆盖)
            // 将本地的local_file_1.txt上传到bucket下的根分区下,并命名为sample_file.txt
            // 默认不覆盖, 如果cos上已有文件, 则返回错误
            String cosFilePath = "/sample_file.txt";
            String localFilePath1 = "src/test/resources/bigfile.txt";
            UploadFileRequest uploadFileRequest =
                    new UploadFileRequest(bucketName, cosFilePath, localFilePath1);
            uploadFileRequest.setEnableSavePoint(false);
            uploadFileRequest.setEnableShaDigest(false);
            String uploadFileRet = cosClient.uploadFile(uploadFileRequest);
            System.out.println("upload file ret:" + uploadFileRet);

    这段代码只是一个入门程序,所以在我们实际应用中肯定是需要进行修改的。例如我图片上传的吧,进来的是一个二进制流文件,总不能用String来接收吧,所以我将其改变了一下:

    我传进去的是一个MultipartFile。所以接收我需要一个byte[].非常方便就改好了。

    MultipartFile uploadFile

     // 1. 上传文件(默认不覆盖)
    	        // 将本地的local_file_1.txt上传到bucket下的根分区下,并命名为sample_file.txt
    	        // 默认不覆盖, 如果cos上已有文件, 则返回错误
    	        String cosFilePath = "/images"+imagePath+"/"+newName;
    	        byte[] localFilePath1 = uploadFile.getBytes();
    	        UploadFileRequest uploadFileRequest =
    	                new UploadFileRequest(bucketName, cosFilePath, localFilePath1);
    	        uploadFileRequest.setEnableSavePoint(false);
    	        uploadFileRequest.setEnableShaDigest(false);
    	        String uploadFileRet = cosClient.uploadFile(uploadFileRequest);

    那么我需要按年月日来生成目录,所以我需要这样。

    // 生成一个新的文件
    			// 取原始文件名
    			String oldName = uploadFile.getOriginalFilename();
    			// 生成新文件名
    //		UUID.randomUUID();
    			String newName = IDUtils.genImageName();
    			newName = newName + oldName.substring(oldName.lastIndexOf("."));
    			// 图片上传
    			String imagePath = new DateTime().toString("/yyyy/MM/dd");

    所以完整代码就如下了:


    @Override
    	public Map uploadPicture(MultipartFile uploadFile) {
    		Map resultMap = new HashMap();
    		
    		try {
    			// 生成一个新的文件
    			// 取原始文件名
    			String oldName = uploadFile.getOriginalFilename();
    			// 生成新文件名
    //		UUID.randomUUID();
    			String newName = IDUtils.genImageName();
    			newName = newName + oldName.substring(oldName.lastIndexOf("."));
    			// 图片上传
    			String imagePath = new DateTime().toString("/yyyy/MM/dd");
    
    			  // 设置用户属性, 包括appid, secretId和SecretKey
    	        // 这些属性可以通过cos控制台获取(https://console.qcloud.com/cos)
    	       long appId = 1000000;
            String secretId = "xxxxxxxxxxxxxxxxxxxxxxxxxxx";
            String secretKey = "xxxxxxxxxxxxxxxxxxxxxxxxxx";
            // 设置要操作的bucket
            String bucketName = "xxxxxxxxx";
    	        // 初始化客户端配置
    	        ClientConfig clientConfig = new ClientConfig();
    	        // 设置bucket所在的区域,比如广州(gz), 天津(tj)
    	        clientConfig.setRegion("gz");
    	        // 初始化秘钥信息
    	        Credentials cred = new Credentials(appId, secretId, secretKey);
    	        // 初始化cosClient
    	        COSClient cosClient = new COSClient(clientConfig, cred);
    	        ///
    	        // 文件操作 //
    	        ///
    	        // 1. 上传文件(默认不覆盖)
    	        // 将本地的local_file_1.txt上传到bucket下的根分区下,并命名为sample_file.txt
    	        // 默认不覆盖, 如果cos上已有文件, 则返回错误
    	        String cosFilePath = "/images"+imagePath+"/"+newName;
    	        byte[] localFilePath1 = uploadFile.getBytes();
    	        UploadFileRequest uploadFileRequest =
    	                new UploadFileRequest(bucketName, cosFilePath, localFilePath1);
    	        uploadFileRequest.setEnableSavePoint(false);
    	        uploadFileRequest.setEnableShaDigest(false);
    	        String uploadFileRet = cosClient.uploadFile(uploadFileRequest);
    			
    	        //System.out.println("upload file ret:" + uploadFileRet);
    			
    			
    	        String json=JsonUtils.objectToJson(uploadFileRet);
    			//System.out.println(json.toString());
    			
    			
    			resultMap.put("error", 0);
    			resultMap.put("url", IMAGE_BASE_URL +"/images"+imagePath+"/"+newName);
    			
    			
    			return resultMap;
    		} catch (Exception e) {
    			resultMap.put("error", 1);
    			resultMap.put("message", "文件上传发生异常");
    			return resultMap;
    		}
    	}

    这个IMAGE_BASE_URL就是这个对象存储的位置。例如你随便上传一个文件的时候,都会给你一个文件的地址的前缀部分。




    完成之后可以在控制台查看,或者网址访问,如果需要图片的时候,就把这个url拿出用即可,例如我就是放在img标签的src里就可以直接使用了。




    前面的工具类IDUtils.java


    public class IDUtils {
    
    	/**
    	 * 图片名生成
    	 */
    	public static String genImageName() {
    		//取当前时间的长整形值包含毫秒
    		long millis = System.currentTimeMillis();
    		//long millis = System.nanoTime();
    		//加上三位随机数
    		Random random = new Random();
    		int end3 = random.nextInt(999);
    		//如果不足三位前面补0
    		String str = millis + String.format("%03d", end3);
    		
    		return str;
    	}
    }






    总结:使用对象存储服务是一种非常高效便捷的方式,而且使用起来还是挺简单的。点个赞。



    展开全文
  • 腾讯云COS对象存储

    2019-05-19 16:28:00
    腾讯云对象存储 COS 是一种存储海量数据的分布式存储服务。COS 提供了多种对象的存储类型:标准存储、低频存储、归档存储。 二、为什么要使用TA 便宜; 个人用户有6个月的免费使用额度50G; 有客户端COSBrowser ,...

    一、腾讯云COS

    腾讯云对象存储 COS 是一种存储海量数据的分布式存储服务。COS 提供了多种对象的存储类型:标准存储、低频存储、归档存储。

    二、为什么要使用TA

    1. 便宜;
    2. 个人用户有6个月的免费使用额度50G;
    3. 有客户端COSBrowser ,提供图形化操作;
    4. 可以设置跨域、防盗链;
    5. 可以进行静态网站托管;
    6. 支持https访问;
    7. CDN加速,下载速度大幅提高。

    以上就是我使用它的原因。

    三、开始对接

    1、添加SDK

    <!-- 腾讯云cos_api -->
    <dependency>
        <groupId>com.qcloud</groupId>
        <artifactId>cos_api</artifactId>
        <version>5.4.10</version>
    </dependency>
    
    <!-- java开发工具包 https://www.hutool.club/docs/#/ -->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>4.1.13</version>
    </dependency>

    2、编写工具类

    import cn.hutool.core.exceptions.ValidateException;
    import cn.hutool.core.lang.Validator;
    import cn.hutool.core.thread.ThreadUtil;
    import com.qcloud.cos.COSClient;
    import com.qcloud.cos.ClientConfig;
    import com.qcloud.cos.auth.BasicCOSCredentials;
    import com.qcloud.cos.auth.COSCredentials;
    import com.qcloud.cos.exception.CosClientException;
    import com.qcloud.cos.model.*;
    import com.qcloud.cos.region.Region;
    import com.qcloud.cos.transfer.Copy;
    import com.qcloud.cos.transfer.Download;
    import com.qcloud.cos.transfer.TransferManager;
    import com.qcloud.cos.transfer.Upload;
    
    import java.io.File;
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.List;
    import java.util.concurrent.ExecutorService;
    
    /**
     * 腾讯云对象存储cos帮助类
     *
     * @author lixingwu
     */
    public class TxCosUtils {
    
        /*配置参数自行填写*/
        private static final String APP_ID = "";
        private static final String SECRET_ID = "";
        private static final String SECRET_KEY = "";
        private static final String REGION_NAME = "";
    
        private TxCosUtils() {
        }
    
        /**
         * 方法描述:获取cos存储桶客户端.
         * 创建时间:2019-02-27 18:09:46
         *
         * @author "lixingwu"
         */
        private static COSClient getCOSClient() {
            // 1 初始化用户身份信息(secretId, secretKey)。
            COSCredentials cred = new BasicCOSCredentials(SECRET_ID, SECRET_KEY);
            // 2 设置bucket的区域, COS地域的简称请参照 https://cloud.tencent.com/document/product/436/6224
            // clientConfig中包含了设置 region, https(默认 http), 超时, 代理等 set 方法, 使用可参见源码或者接口文档 FAQ 中说明。
            ClientConfig clientConfig = new ClientConfig(new Region(REGION_NAME));
            // 3 生成 cos 客户端。
            return new COSClient(cred, clientConfig);
        }
    
        /**
         * 方法描述:bucket 的命名规则为{name}-{appid} ,
         * name 仅支持小写字母、数字和 - 的组合,不能超过40字符.
         * 创建时间:2019-02-27 18:09:46
         *
         * @author "lixingwu"
         */
        private static String getBucketName(String bucketName) {
            Validator.validateNotEmpty(bucketName, "bucketName不能为空");
            Validator.validateMatchRegex("^[a-z!-@0-9]+$", bucketName,
                    "bucketName仅支持小写字母、数字和 - 的组合");
            if (bucketName.length() > 40) {
                throw new ValidateException("bucketName不能超过40字符");
            }
            return (bucketName + "-" + APP_ID);
        }
    
        /**
         * 方法描述:创建一个存储桶.
         * 创建时间:2019-02-27 18:09:46
         *
         * @author "lixingwu"
         */
        public static Bucket createBucket(String bucketName) throws CosClientException {
            Bucket bucket = null;
            COSClient client = getCOSClient();
            bucket = createBucket(getBucketName(bucketName));
            //设置存储桶的权限为 公有读私有写
            if (null != bucket) {
                client.setBucketAcl(bucketName, CannedAccessControlList.PublicRead);
            }
            return bucket;
        }
    
        /**
         * 方法描述:获取存储桶列表.
         * 创建时间:2019-02-27 18:09:46
         *
         * @author "lixingwu"
         */
        public static List<Bucket> listBuckets() throws CosClientException {
            return getCOSClient().listBuckets();
        }
    
        /**
         * 方法描述:检测存储桶是否存在.
         * 创建时间:2019-02-27 18:09:46
         *
         * @author "lixingwu"
         */
        public static boolean doesBucketExist(String bucketName) throws CosClientException {
            return getCOSClient().doesBucketExist(getBucketName(bucketName));
        }
    
        /**
         * 方法描述:删除文件.
         * 创建时间:2019-03-05 14:25:08
         * 创建作者:李兴武
         *
         * @param bucketName bucketName
         * @param fileName   文件地址
         * @throws CosClientException the cos client exception
         * @author "lixingwu"
         */
        public static void deleteObject(String bucketName, String fileName)
                throws CosClientException {
            getCOSClient().deleteObject(bucketName, fileName);
        }
    
        /**
         * 方法描述:获取文件的信息.
         * 创建时间:2019-03-05 14:54:09
         * 创建作者:李兴武
         *
         * @param bucketName bucketName
         * @param fileName   文件地址
         * @return the object metadata
         * @throws CosClientException the cos client exception
         * @author "lixingwu"
         */
        public static ObjectMetadata findObjectMetadata(String bucketName, String fileName)
                throws CosClientException {
            return getCOSClient().getObjectMetadata(getBucketName(bucketName), fileName);
        }
    
        /**
         * 方法描述:获取一个高级的API TransferManager,项目中应该使用这些接口.
         * 创建时间:2019-03-05 15:35:12
         * 创建作者:李兴武
         *
         * @return the transfer manager
         * @author "lixingwu"
         */
        public static TransferManager cosTransferManager() {
            ExecutorService threadPool = ThreadUtil.newExecutor();
            return new TransferManager(getCOSClient(), threadPool);
        }
    
        /**
         * 方法描述:上传文件
         * 创建时间:2019-03-05 15:53:54
         * 创建作者:李兴武
         *
         * @param bucketName 存储桶名称
         * @param filePath   文件存储地址
         * @param stream     文件流
         * @return the upload
         * @author "lixingwu"
         */
        public static Upload upload(String bucketName, String filePath, InputStream stream) {
            TransferManager manager = cosTransferManager();
            Upload result = null;
            try {
                result = manager.upload(getBucketName(bucketName), filePath, stream, new ObjectMetadata());
                result.waitForUploadResult();
            } catch (CosClientException | InterruptedException e) {
                e.printStackTrace();
            } finally {
                manager.shutdownNow();
            }
            return result;
        }
    
        /**
         * 方法描述:下载文件.
         * 创建时间:2019-03-05 16:20:16
         * 创建作者:李兴武
         *
         * @param bucketName 存储桶名称
         * @param filePath   文件存储地址
         * @param destFile   存储到的本地目标文件
         * @return the download
         * @author "lixingwu"
         */
        public static Download download(String bucketName, String filePath, File destFile) {
            TransferManager manager = cosTransferManager();
            Download download = null;
            try {
                download = manager.download(getBucketName(bucketName), filePath, destFile);
                download.waitForCompletion();
            } catch (CosClientException | InterruptedException e) {
                e.printStackTrace();
            } finally {
                manager.shutdownNow();
            }
            return download;
        }
    
    
        /**
         * 方法描述:复制文件-不同存储桶.
         * 创建时间:2019-03-05 16:28:11
         * 创建作者:李兴武
         *
         * @param srcBucketName  源存储桶名称
         * @param srcKey         源文件地址
         * @param destBucketName 目标存储桶名称
         * @param destKey        目标件地址
         * @return the copy
         * @author "lixingwu"
         */
        public static Copy copy(String srcBucketName, String srcKey, String destBucketName, String destKey) {
            TransferManager manager = cosTransferManager();
            Copy copy = null;
            try {
                copy = manager.copy(getBucketName(srcBucketName), srcKey, getBucketName(destBucketName), destKey);
                copy.waitForCompletion();
            } catch (CosClientException | InterruptedException e) {
                e.printStackTrace();
            } finally {
                manager.shutdownNow();
            }
            return copy;
        }
    
        /**
         * 方法描述:复制文件-同存储桶.
         * 创建时间:2019-03-05 16:28:11
         * 创建作者:李兴武
         *
         * @param bucketName 源存储桶名称
         * @param srcKey     源文件地址
         * @param destKey    目标件地址
         * @return the copy
         * @author "lixingwu"
         */
        public static Copy copy(String bucketName, String srcKey, String destKey) {
            return copy(bucketName, srcKey, bucketName, destKey);
        }
    
        /*测试*/
        public static void main(String[] args) throws IOException {
            // Bucket bucket = TxCosUtils.createBucket("test");
            // List<Bucket> listBuckets = TxCosUtils.listBuckets();
            // boolean test = TxCosUtils.doesBucketExist("web-js-css01");
            // File file = new File("E:\\codeList01.html");
            // BufferedInputStream stream = FileUtil.getInputStream(file);
            // PutObjectResult result = TxCosUtils.putObject("test", "html/codeList01.html", stream);
            // COSObject test = downObject("test", "html/codeList.html");
            // COSObjectInputStream inputStream = test.getObjectContent();
            // ObjectMetadata test = downObject("test", "html/codeList.html", new File("E:\\codeList.xml"));
            // ObjectMetadata metadata = findObjectMetadata("test", "html/codeList.html");
            // CopyObjectResult result = TxCosUtils.copyObject("web-js-css", "css/ch233.min.css", "test", "css/ch233.min.css");
            // CopyObjectResult result = TxCosUtils.copyObject("test", "css/ch233.min.css", "css/ch233.min.css.bak");
            // deleteObject(getBucketName("test"), "html/codeList01.html");
    
            // 高级API
            // 上传文件
            // File file = new File("E:\\templet.html");
            // BufferedInputStream stream = FileUtil.getInputStream(file);
            // Upload test = TxCosUtils.upload("test", "html/templet.html", stream);
            // Console.log(test);
    
            // 下载文件
            // Download test = TxCosUtils.download("test", "css/ch233.min.css.bak", new File("E:\\ch233.min.css"));
            // Console.log(test);
    
            // 复制文件
            // Copy copy = TxCosUtils.copy("web-js-css", "layui/layui.js", "test", "layui/layui.js");
            // Copy copy = TxCosUtils.copy("test", "layui/layui.js", "layui/layui.js.bak");
            // Console.log(copy);
        }
    }
    

    转载于:https://www.cnblogs.com/lixingwu/p/10889552.html

    展开全文
  • 文章目录腾讯 COS 对象存储 - SDK 文件上传对接,示例代码1、SDK2、工具类代码3、使用示例 腾讯 COS 对象存储 - SDK 文件上传对接,示例代码 1、SDK <dependency> <groupId>com.qcloud</groupId&...
  • 腾讯云 COS 最新v5版本sdk暂时没C#版本。自己琢磨了一个,能用可供参考。js直传也可以用里面方法获取签名 ,代码里ToUnixTime自己网少找下处理方法,代码就不放了
  • 腾讯云专题网在"创建腾讯云COS存储准备部署静态资源分离 及获取API授权"文章中分享到我们如何创建腾讯云COS对象存储以及获取API密钥的方法。但是,如果我们将腾讯云COS存储用于实际项目中的时候也需要进行基础设置,...
  • 当我们需要上传图片或者视频时,可以选择使用腾讯云下的COS对象存储空间 一、导入依赖 <dependency> <groupId>com.qcloud</groupId> <artifactId>cos_api</artifactId&g
  • 每日上传腾讯云cos本地数据日志:#!/usr/bin/env python# coding=utf-8# author: wz# mail: 277215243@qq.com# datetime:2019/10/18 1:24 PM# web: https://www.bthlt.comfrom qcloud_cos import CosConfigfrom ...
  • FineUI上传文件到腾讯云cos对象存储,并不是完整的案例,需要一定的理解能力,请谨慎下载。包含页面 文件管理、文件新建、文件编辑、COS拖拽上传、COS插入外链文件,已实现文件增删改、插入外链文件、本地拖拽或点击...
  • 腾讯云COS对象存储采坑记录

    千次阅读 2019-09-08 08:41:19
    腾讯云的COS对象存储真是坑,这么坑开发者对你有什么好处? 之前接入支付宝和微信的支付,有感于支付宝的便捷和微信支付的无数暗坑;对象存储之前使用的是阿里云(阿里叫OSS),也是一次成功;但是这次接入微信的...
  • 由于我的服务器是腾讯云的,我这里的对象存储是腾讯云的COS。 1,首先你要有腾讯云的账号,登陆之后在控制台,找到对象存储服务,进去之后找到下面的入口,新建存储桶 2,然后我们再生成秘钥 我们先找到访问管理菜单...
  • 导入依赖 <...cos_api</artifactId> <version>5.6.35</version> </dependency> 工具类 TencentCOSUploadFileUtil public class TencentCOSUploadFileUtil { //.
  • 目前使用腾讯云的对象存储cos服务,将本地的文件同步到cos中,看了腾讯云的用户文档,发现使用COS Migration 工具还是挺适合的。 原因 因为服务器已经安装有java环境,而cos的几个用户工具中,用于自动同步的只...
  • 对象存储COS(英文Cloud Object Storage)是腾讯云提供的一种存储海量文件的分布式存储服务,用户可通过网络随时存储和查看数据。COS 以冗余的方式跨多个地域存储用户数据,并允许多个不同的客户端或应用程序线程...
  • 2018-05-04 上传大小:10KB cos对象存储C# 分享 腾讯云 COS 最新v5版本sdk暂时没C#版本。自己琢磨了一个,能用可供参考。
  • 下面就介绍腾讯云COS对象存储如何绑定自定义域名的方法。 先创建腾讯云COS,我们在创建完毕存储桶之后,可以开始自定义绑定域名。 我们点击当前需要设置自定义域名的COS存储桶,在【自定义站源域名】添加设置。 ...
  • 如何处理 COS 对象存储中的大量文件打包需求?或许 SCF 无服务器云函数能助你一臂之力!
  • 1、自动同步将WordPress静态文件,比如图片等上传到腾讯云COS存储中,在WP网站中删除图片会自动也删除COS存储文件; 2、可以设置本地与COS同步备份,或者本地不保存,仅存储COS中(这一点在多个网友版本中均有错误...
  • 腾讯的叫COS对象储存,阿里的叫OSS对象储存,其实都是一样的,这里我使用的是腾讯COS。 腾讯云COS 这里我已经购买了,打开如下图所示。 腾讯云COS控制面板 腾讯云COS控制面板 腾讯云COS控制面板 ...
  • 叮当哥之前买了一年的腾讯云服务器,昨日偶然发现腾讯云送了叮当哥半年的cos对象存储服务器,于是就撸起袖子传了几张珍藏的高清大图上去,现将其上传的简单使用步骤总结一波(其它操作参加官方SDK文档API)。...
  • 叮当哥之前买了一年的腾讯云服务器,昨日偶然发现腾讯云送了叮当哥半年的cos对象存储服务器,于是就撸起袖子传了几张珍藏的高清大图上去,现将其上传的简单使用步骤总结一波(其它操作参加官方SDK文档API)。...
  • 腾讯云 COS对象存储+视频处理总结

    万次阅读 2018-11-08 11:31:51
    1,找到对象存储COS)产品 2,新建存储桶(必须是华东地区的) 3,在所有产品中找到 视频处理 4,Bucket管理:找到自己新建的的bucket,点击后面的管理(注意:现在的情况,不是华东地区的bucket不支持视频处理...
  • 为了节省本机空间在这里我选择腾讯云COS对象储存,把图片存在腾讯云上。注册腾讯云账号可以领取6个月免费的对象储存服务。 腾讯云COS地址 创建储存桶的时候权限要设置成公有读私有写。 一定要把静态网站功能打开,...
  • ['local_path'] self.logger = logger def cos_client(self): config = CosConfig(Secret_id=self.secret_id, Secret_key=self.secret_key, Region=self.cos_region) cos_client = CosS3Client(config) return cos_...
  • 老蒋在前面的文章中有介绍到腾讯云COS对象存储的用途还是比较大的,有我们常见的用来当做网盘使用,也可以将用来网站静态文件分离,同时还有可以作为数据同步备份。在这篇文章中,我还准备测试商家支持将COS挂载到...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,918
精华内容 7,567
关键字:

cos对象存储是什么