精华内容
下载资源
问答
  • 腾讯COS存储使用

    千次阅读 2019-12-23 15:54:40
    文章目录一、简介二、使用代码1、获取永久密钥2、添加pom.xml中的依赖3、初始化用户身份信息4、创建存储桶(需要先进行3、初始化用户身份信息)5、创建存储桶(需要先进行3、初始化用户身份信息)6、上传对象(需要...

    一、简介

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

    COS 通过控制台、API、SDK 和工具等多样化方式简单、快速地接入,实现了海量数据存储和管理。通过 COS 可以进行多格式文件的上传、下载和管理。腾讯云提供了直观的 Web 管理界面,同时遍布全国范围的 CDN 节点可以对文件下载进行加速。

    二、使用代码

    1、获取永久密钥

    若您使用永久密钥初始化 COSClient,可以先在访问管理控制台中的 API 密钥管理 页面获取 SecretId、SecretKey,使用永久密钥适用于大部分的应用场景;

    2、添加pom.xml中的依赖

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

    3、初始化用户身份信息

    // 1 初始化用户身份信息(secretId, secretKey)。
    String secretId = "COS_SECRETID";
    String secretKey = "COS_SECRETKEY";
    COSCredentials cred = new BasicCOSCredentials(secretId, secretKey);
    // 2 设置 bucket 的区域, COS 地域的简称请参照 https://cloud.tencent.com/document/product/436/6224
    // clientConfig 中包含了设置 region, https(默认 http), 超时, 代理等 set 方法, 使用可参见源码或者常见问题 Java SDK 部分。
    Region region = new Region("ap-guangzhou");
    ClientConfig clientConfig = new ClientConfig(region);
    // 3 生成 cos 客户端。
    COSClient cosClient = new COSClient(cred, clientConfig);
    

    4、创建存储桶(需要先进行3、初始化用户身份信息)

    //  存储桶名称,格式:BucketName-APPID(后面ID每个用户唯一)(需要改1)
    	String bucket = "exa-1300615854";
    	CreateBucketRequest createBucketRequest = new CreateBucketRequest(bucket);
    // 设置 bucket 的权限为 PublicRead(公有读私有写), 其他可选有私有读写, 公有读写
    	createBucketRequest.setCannedAcl(CannedAccessControlList.PublicRead);
    	try{
    		Bucket bucketResult = cosClient.createBucket(createBucketRequest);
    		} catch (CosServiceException serverException) {
    		serverException.printStackTrace();
            } catch (CosClientException clientException) {
             clientException.printStackTrace();
    	}
    

    在这里插入图片描述

    5、创建存储桶(需要先进行3、初始化用户身份信息)

    try {
    	List<Bucket> buckets = cosClient.listBuckets();
    		System.out.println(buckets);
    	} catch (CosServiceException serverException) {
            serverException.printStackTrace();
    	} catch (CosClientException clientException) {
          	clientException.printStackTrace();
    	}
    

    6、上传对象(需要先进行3、初始化用户身份信息)(需要改3处)

    try {
                // 指定要上传的文件(需要改1)
    	File localFile = new File("D:\\11.pdf");
                // 指定要上传到的存储桶(需要改2)
    	String bucketName = "start-1300615357";
                // 指定要上传到 COS 上对象键(需要改3)
    	String key = "exampl";
    	PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, key, localFile);
    	PutObjectResult putObjectResult = cosClient.putObject(putObjectRequest);
    } catch (CosServiceException serverException) {
    	serverException.printStackTrace();
    } catch (CosClientException clientException) {
    	clientException.printStackTrace();
    }
    

    7、查询存储桶中内容(需要先进行3、初始化用户身份信息)(需要改1处)

    try {
    //            桶容器的名称(需要改1)
    	String bucket = "start-1300615357";
    	ListObjectsRequest listObjectsRequest = new ListObjectsRequest();
         // 设置 bucket 名称
    	listObjectsRequest.setBucketName(bucket);
        // prefix 表示列出的 object 的 key 以 prefix 开始
    	listObjectsRequest.setPrefix("");
        // 设置最大遍历出多少个对象, 一次 listobject 最大支持1000
    	listObjectsRequest.setMaxKeys(1000);
    	listObjectsRequest.setDelimiter("/");
    	ObjectListing objectListing = cosClient.listObjects(listObjectsRequest);
    	for (COSObjectSummary cosObjectSummary : objectListing.getObjectSummaries()) {
         // 对象的路径 key
    		String key = cosObjectSummary.getKey();
          // 对象的 etag
    		String etag = cosObjectSummary.getETag();
          // 对象的长度
    		long fileSize = cosObjectSummary.getSize();
          // 对象的存储类型
    		String storageClass = cosObjectSummary.getStorageClass();
    		System.out.println("key:" + key + "; etag:" + etag + "; fileSize:" + fileSize + ";storageClass:" + storageClass);
    		}
    	} catch (CosServiceException serverException) {
    		serverException.printStackTrace();
    	} catch (CosClientException clientException) {
    		clientException.printStackTrace();
    	}
    

    8、下载文件(需要先进行3、初始化用户身份信息)(需要改3处)

    try{
    // 指定对象所在的存储桶(需要改1)
    	String bucketName = "start-1300615357";
    // 指定对象在 COS 上的对象键(需要改2)
    	String key = "exampl";
    // 指定要下载到的本地路径(需要制定文件名)(需要改3)
    	File downFile = new File("D:\\12.pdf");
    	GetObjectRequest getObjectRequest = new GetObjectRequest(bucketName, key);
    	ObjectMetadata downObjectMeta = cosClient.getObject(getObjectRequest, downFile);
    	} catch (CosServiceException serverException) {
    		serverException.printStackTrace();
    	} catch (CosClientException clientException) {
    		clientException.printStackTrace();
    }
    

    9、删除文件(需要先进行3、初始化用户身份信息)(需要改2处)

    删除 COS 上指定路径的对象;

    try {
    // 指定对象所在的存储桶(需要改1)
    	String bucketName = "start-1300615357";
    // 指定对象在 COS 上的对象键(需要改2)
    	String key = "exampl";
    	cosClient.deleteObject(bucketName, key);
    } catch (CosServiceException serverException) {
    	serverException.printStackTrace();
    } catch (CosClientException clientException) {
    	clientException.printStackTrace();
    }
    

    10、关闭客户端(需要先进行3、初始化用户身份信息)

    关闭 cosClient,并释放 HTTP 连接的后台管理线程。

    // 关闭客户端(关闭后台线程)
    cosClient.shutdown();
    

    三、完整代码

    下面是一个完成的代码。主要把账号信息改为自己的就可以了;

    package com.lydms.web;
    
    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.exception.CosServiceException;
    import com.qcloud.cos.model.*;
    import com.qcloud.cos.region.Region;
    
    import java.io.File;
    import java.util.List;
    
    public class TestCos {
    
    
        public static void main(String[] args) {
    // 1 初始化用户身份信息(secretId, secretKey)。
            String secretId = "AKIDTmyudXgm59zmT6T3GI5cw3wb1T5lmYeU";
            String secretKey = "mJZTKp8GApJpBTErIWZNuCLJ5cTeuvhF";
            COSCredentials cred = new BasicCOSCredentials(secretId, secretKey);
    // 2 设置 bucket 的区域, COS 地域的简称请参照 https://cloud.tencent.com/document/product/436/6224
    // clientConfig 中包含了设置 region, https(默认 http), 超时, 代理等 set 方法, 使用可参见源码或者常见问题 Java SDK 部分。
            Region region = new Region("ap-beijing");
            ClientConfig clientConfig = new ClientConfig(region);
    // 3 生成 cos 客户端。
            COSClient cosClient = new COSClient(cred, clientConfig);
    
    //        查询存储桶列表
            getbucket(cosClient);
    
    //        上传文件到桶容器
            upload(cosClient);
    
    //        查询存储桶中内容
            getContent(cosClient);
    
    //        下载文件
            downFile(cosClient);
    
    //        删除文件
            deleteFile(cosClient);
    
    //         创建桶容器
            creatBucket(cosClient);
    
    //        关闭客户端(关闭后台线程)
            cosClient.shutdown();
        }
    
        /**
         * 创建存储桶(需要改3处)
         * @return
         */
        private static void creatBucket(COSClient cosClient) {
            String bucket = "exa-1300415347";
            CreateBucketRequest createBucketRequest = new CreateBucketRequest(bucket);
    // 设置 bucket 的权限为 PublicRead(公有读私有写), 其他可选有私有读写, 公有读写
            createBucketRequest.setCannedAcl(CannedAccessControlList.PublicRead);
            try {
                Bucket bucketResult = cosClient.createBucket(createBucketRequest);
            } catch (CosServiceException serverException) {
                serverException.printStackTrace();
            } catch (CosClientException clientException) {
                clientException.printStackTrace();
            }
        }
    
        /**
         * 删除文件(需要改2处位置)
         * @param cosClient
         */
        private static void deleteFile(COSClient cosClient) {
            try {
                // 指定对象所在的存储桶(需要改1)
                String bucketName = "start-1300415347";
                // 指定对象在 COS 上的对象键(需要改2)
                String key = "exampl";
                cosClient.deleteObject(bucketName, key);
            } catch (CosServiceException serverException) {
                serverException.printStackTrace();
            } catch (CosClientException clientException) {
                clientException.printStackTrace();
            }
        }
    
        /**
         * 下载文件(需要改3处位置)
         *
         * @param cosClient
         */
        private static void downFile(COSClient cosClient) {
            try {
                // 指定对象所在的存储桶(需要改1)
                String bucketName = "start-1300415347";
                // 指定对象在 COS 上的对象键(需要改2)
                String key = "exampl";
                // 指定要下载到的本地路径(需要制定文件名)(需要改3)
                File downFile = new File("D:\\12.pdf");
                GetObjectRequest getObjectRequest = new GetObjectRequest(bucketName, key);
                ObjectMetadata downObjectMeta = cosClient.getObject(getObjectRequest, downFile);
            } catch (CosServiceException serverException) {
                serverException.printStackTrace();
            } catch (CosClientException clientException) {
                clientException.printStackTrace();
            }
        }
    
        /**
         * 查询存储桶中内容(需要改1处位置)
         *
         * @param cosClient
         */
        private static void getContent(COSClient cosClient) {
            try {
    //            桶容器的名称(需要改1)
                String bucket = "start-1300415347";
                ListObjectsRequest listObjectsRequest = new ListObjectsRequest();
                // 设置 bucket 名称
                listObjectsRequest.setBucketName(bucket);
                // prefix 表示列出的 object 的 key 以 prefix 开始
                listObjectsRequest.setPrefix("");
                // 设置最大遍历出多少个对象, 一次 listobject 最大支持1000
                listObjectsRequest.setMaxKeys(1000);
                listObjectsRequest.setDelimiter("/");
                ObjectListing objectListing = cosClient.listObjects(listObjectsRequest);
                for (COSObjectSummary cosObjectSummary : objectListing.getObjectSummaries()) {
                    // 对象的路径 key
                    String key = cosObjectSummary.getKey();
                    // 对象的 etag
                    String etag = cosObjectSummary.getETag();
                    // 对象的长度
                    long fileSize = cosObjectSummary.getSize();
                    // 对象的存储类型
                    String storageClass = cosObjectSummary.getStorageClass();
                    System.out.println("key:" + key + "; etag:" + etag + "; fileSize:" + fileSize + "; storageClass:" + storageClass);
                }
            } catch (CosServiceException serverException) {
                serverException.printStackTrace();
            } catch (CosClientException clientException) {
                clientException.printStackTrace();
            }
        }
    
        /**
         * 上传文件到桶容器(需要改3处位置)
         *
         * @param cosClient
         */
        private static void upload(COSClient cosClient) {
            try {
                // 指定要上传的文件(需要改1)
                File localFile = new File("D:\\11.pdf");
                // 指定要上传到的存储桶(需要改2)
                String bucketName = "start-1300415347";
                // 指定要上传到 COS 上对象键(需要改3)
                String key = "exampl";
                PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, key, localFile);
                PutObjectResult putObjectResult = cosClient.putObject(putObjectRequest);
            } catch (CosServiceException serverException) {
                serverException.printStackTrace();
            } catch (CosClientException clientException) {
                clientException.printStackTrace();
            }
        }
    
        /**
         * 查询存储桶列表(根据用户信息进行)
         *
         * @param cosClient
         */
        private static void getbucket(COSClient cosClient) {
            try {
                List<Bucket> buckets = cosClient.listBuckets();
                System.out.println(buckets);
            } catch (CosServiceException serverException) {
                serverException.printStackTrace();
            } catch (CosClientException clientException) {
                clientException.printStackTrace();
            }
        }
    }
    
    
    展开全文
  • 腾讯云对象存储COS使用

    千次阅读 2019-06-26 09:37:37
    废话不多说,直接开始吧 ...-- 腾讯云cos对象存储 --> <dependency> <groupId>com.qcloud</groupId> <artifactId>cos_api</artifactId> <version>5...

     废话不多说,直接开始吧

    所需要的jar包

                    <!-- 腾讯云cos对象存储 -->
    		<dependency>
    			<groupId>com.qcloud</groupId>
    			<artifactId>cos_api</artifactId>
    			<version>5.2.4</version>
    		</dependency>
    		<dependency>
    			<groupId>com.qcloud</groupId>
    			<artifactId>qcloud-java-sdk</artifactId>
    			<version>2.0.1</version>
    		</dependency>

    工具类COSClientUtil

    package com.lacha.register.utils;
    
    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.exception.CosServiceException;
    import com.qcloud.cos.model.*;
    import com.qcloud.cos.region.Region;
    import com.qcloud.cos.utils.IOUtils;
    
    import java.io.*;
    import java.net.HttpURLConnection;
    import java.net.MalformedURLException;
    import java.net.URL;
    import java.util.Date;
    import java.util.List;
    
    public class COSClientUtil {
     
    
    	private static final String SECRETID ="AK**************dbmK5h";
    	private static final String SECRETKEY = "e***************N0Q";
    	private static final String APPID = "1258378951";
    	private static final String BUCKETNAME = "la-cos01" + "-" + APPID; // 桶的名称
    	private static final String REGIONID = "ap-shanghai";// 区域
    	private static final String KEY = "register/";//存储位置文件夹名称
            private static final String host = "https://" + BUCKETNAME + ".cos.ap-                      shanghai.myqcloud.com";        
     
    	/**
    	 * * 初始化CosClient相关配置, appid、accessKey、secretKey、region * @return
    	 */
    	public static COSClient getCosClient() {
    		// 1 init userInfo (secretId, secretKey)
    		// COSCredentials cred = new BasicCOSCredentials(APPID,ACCESSKEY,
    		// SECRETKEY);
    		COSCredentials cred = new BasicCOSCredentials(SECRETID, SECRETKEY); // 不传APPID也可以,APPID和ACCESSKE已经关联过
    		// 2 set bucket region
    		ClientConfig clientConfig = new ClientConfig(new Region(REGIONID));
    		// 3 init cosclient
    		COSClient cosclient = new COSClient(cred, clientConfig);
    		// bucket name protocol must be {name}-{appid}
    		return cosclient;
    	}
     
    	/**
    	 * 上传文件
    	 * 
    	 * @return
    	 */
    	public static String uploadFile(String fileURL, String fileName) {
    		InputStream inputStream = null;
    		ByteArrayOutputStream output = new ByteArrayOutputStream();
    		if (fileURL.startsWith("http") || fileURL.startsWith("https")) {
    			try {
    				URL url = new URL(fileURL);
    				inputStream = url.openStream();
    			} catch (MalformedURLException e) {
    				e.printStackTrace();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		} else {
    			try {
    				inputStream = new FileInputStream(fileURL);
    			} catch (FileNotFoundException e) {
    				e.printStackTrace();
    			} // 绝对路径和相对路径都OK
    		}
    		try {
    			IOUtils.copy(inputStream, output);
    		} catch (IOException e2) {
    			e2.printStackTrace();
    		}
     
    		return uploadFile(output.toByteArray(), fileName);
     
    	}
     
    	public static String uploadFile(byte[] bytes, String fileName) {
    		String backUrl = "";
     
    		// String bucket = BUCKETNAME + "-" + APPID;
    		// String bucket="claim-1252337168";
    		System.out.println(BUCKETNAME);
    		String key = KEY + fileName;
     
    		ObjectMetadata metadata = new ObjectMetadata();
    		// metadata.setContentType("image/jpeg");
     
    		metadata.setContentLength(bytes.length);
    		PutObjectRequest putObjectRequest = new PutObjectRequest(BUCKETNAME, key, new ByteArrayInputStream(bytes),
    				metadata);
     
    		// 设置存储类型, 默认是标准(Standard), 低频(standard_ia)
    		putObjectRequest.setStorageClass(StorageClass.Standard_IA);
    		COSClient cc = getCosClient();
    		try {
    			PutObjectResult putObjectResult = cc.putObject(putObjectRequest);
    			// putobjectResult会返回文件的etag
    			backUrl = host + "/" + key;
    			System.out.println(backUrl);
    			return backUrl;
    		} catch (CosServiceException e) {
    			e.printStackTrace();
    		} catch (CosClientException e) {
    			e.printStackTrace();
    		}
    		// 关闭客户端
    		cc.shutdown();
     
    		return backUrl;
    	}
     
    	public static String uploadFile(ByteArrayInputStream input, String fileName) {
    		byte[] bytes = null;
    		try {
    			bytes = IOUtils.toByteArray(input);
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
     
    		return uploadFile(bytes, fileName);
    	}
     
    	/**
    	 * * 下载文件 * @param bucketName * @param key * @return
    	 */
     
    	public static String downLoadFile(String bucketName, String key) {
    		File downFile = new File("D:/downloadTest/" + KEY + "czy_test.png");
     
    		COSClient cc = getCosClient();
    		GetObjectRequest getObjectRequest = new GetObjectRequest(bucketName, key);
    		ObjectMetadata downObjectMeta = cc.getObject(getObjectRequest, downFile);
    		cc.shutdown();
    		String etag = downObjectMeta.getETag();
     
    		return etag;
    	}
     
    	/**
    	 * * 删除文件 * @param bucketName * @param key
    	 */
    	public void deleteFile(String bucketName, String key) {
    		COSClient cc = getCosClient();
    		try {
    			cc.deleteObject(bucketName, key);
    		} catch (CosClientException e) {
    			e.printStackTrace();
    		} finally {
    			cc.shutdown();
    		}
    	}
     
    	/**
    	 * * 判断桶是否存在 * @param bucketName * @return * @throws CosClientException
    	 * * @throws CosServiceException
    	 */
    	public static boolean doesBucketExist(String bucketName) throws CosClientException, CosServiceException {
    		COSClient cc = getCosClient();
    		boolean bucketExistFlag = cc.doesBucketExist(bucketName);
    		return bucketExistFlag;
    	}
     
    	/**
    	 * * 查看桶文件 * @param bucketName * @return * @throws CosClientException
    	 * * @throws CosServiceException
    	 */
    	public ObjectListing listObjects(String bucketName) throws CosClientException, CosServiceException {
    		COSClient cc = getCosClient();
    		// 获取 bucket 下成员(设置 delimiter)
    		ListObjectsRequest listObjectsRequest = new ListObjectsRequest();
    		listObjectsRequest.setBucketName(bucketName);
    		// 设置 list 的 prefix, 表示 list 出来的文件 key 都是以这个 prefix 开始
    		listObjectsRequest.setPrefix("");
    		// 设置 delimiter 为/, 即获取的是直接成员,不包含目录下的递归子成员
    		listObjectsRequest.setDelimiter("/");
    		// 设置 marker, (marker 由上一次 list 获取到, 或者第一次 list marker 为空)
    		listObjectsRequest.setMarker("");
    		// 设置最多 list 100 个成员,(如果不设置, 默认为 1000 个,最大允许一次 list 1000 个 key)
    		listObjectsRequest.setMaxKeys(100);
    		ObjectListing objectListing = cc.listObjects(listObjectsRequest);
    		// 获取下次 list 的 marker
    		String nextMarker = objectListing.getNextMarker();
    		// 判断是否已经 list 完, 如果 list 结束, 则 isTruncated 为 false, 否则为 true
    		boolean isTruncated = objectListing.isTruncated();
    		List<COSObjectSummary> objectSummaries = objectListing.getObjectSummaries();
    		for (COSObjectSummary cosObjectSummary : objectSummaries) {
    			// get file path
    			String key = cosObjectSummary.getKey();
    			// get file length
    			long fileSize = cosObjectSummary.getSize();
    			// get file etag
    			String eTag = cosObjectSummary.getETag();
    			// get last modify time
    			Date lastModified = cosObjectSummary.getLastModified();
    			// get file save type
    			String StorageClassStr = cosObjectSummary.getStorageClass();
    		}
    		return objectListing;
    	}
     
    	public static InputStream getImageStream(String url) {
    		try {
    			HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
     
    			connection.setReadTimeout(5000);
    			connection.setConnectTimeout(5000);
    			connection.setRequestMethod("GET");
    			if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
    				InputStream inputStream = connection.getInputStream();
    				System.out.println("进入图片获取***" + inputStream);
    				return inputStream;
    			}
    		} catch (IOException e) {
    			System.out.println("获取网络图片出现异常,图片路径为:" + url);
    			e.printStackTrace();
    		}
    		return null;
    	}
     
    	private static byte[] readBytes(InputStream is) throws Exception {
     
    		if ((is == null) || (is.available() < 1)) {
    			return new byte[0];
    		}
    		byte[] buff = new byte[8192];
    		byte[] result = new byte[is.available()];
     
    		BufferedInputStream in = new BufferedInputStream(is);
    		int pos = 0;
    		int nch;
    		while ((nch = in.read(buff, 0, buff.length)) != -1) {
    			// int nch;
    			pos += nch;
    		}
    		System.out.println("byte长度为:" + result.length);
    		in.close();
    		return result;
    	}
     
    	/**
    	 * 获取网络文件的输入流
    	 * 
    	 * @param urlStr
    	 * @return
    	 */
    	public static InputStream getInputStreamByUrl(String urlStr) {
    		DataInputStream in = null;
    		try {
    			URL url = new URL(urlStr);
    			HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    			in = new DataInputStream(conn.getInputStream());
    		} catch (IOException e) {
     
    		}
    		System.out.println("转换完成" + in);
    		return in;
    	}
     
    	public static byte[] toByteArray(InputStream in) throws IOException {
     
    		ByteArrayOutputStream out = new ByteArrayOutputStream();
    		byte[] buffer = new byte[1024 * 4];
    		int n = 0;
    		while ((n = in.read(buffer)) != -1) {
    			out.write(buffer, 0, n);
    		}
    		return out.toByteArray();
    	}
    
    	public static URL picCOS(File cosFile) throws Exception {
    
    		COSCredentials cred = new BasicCOSCredentials(SECRETID,SECRETKEY);
    		// 2 设置bucket的区域, COS地域的简称请参照
    		// https://cloud.tencent.com/document/product/436/6224
    		ClientConfig clientConfig = new ClientConfig(new Region("ap-shanghai"));
    		// 3 生成cos客户端
    		COSClient cosClient = new COSClient(cred, clientConfig);
    		String bucketName = BUCKETNAME+ "-" + APPID;
    		String key = "image/"+new Date().getTime() + ".png";
    		// 简单文件上传, 最大支持 5 GB, 适用于小文件上传, 建议 20 M 以下的文件使用该接口
    		// 大文件上传请参照 API 文档高级 API 上传
    		// 指定要上传到 COS 上的路径
    
    		PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, key, cosFile);
    		cosClient.putObject(putObjectRequest);
    		cosClient.shutdown();
    		Date expiration = new Date(new Date().getTime() + 5 * 60 * 10000);
    		URL url = cosClient.generatePresignedUrl(bucketName, key, expiration);
    		return url;
    	}
    
    }

     这是Service层的例子  controller和mapper层根据自己的业务就行,这里就不贴出来了

    public List addPartner(List<MultipartFile> files){
                log.info("添加合伙人信息");
            //优先调用cos工具类上传图片 ,返回url地址
            List<String> urls = new ArrayList<>();
            for (MultipartFile m:files) {
                byte[] bytes = m.getBytes();
                String filename = m.getOriginalFilename();
                String uuid = UUID.randomUUID().toString().replace("-", "");
                System.out.println(filename);
                //调用uploadFile方法即可上传
                String url = COSClientUtil.uploadFile(bytes, uuid + filename );
                urls.add(url);
            }
            return urls;
        }

    之后你可以登录cos的客户端去查看一下图片是否上传成功

    大致就是这些,不是经常写这些东西,主要是给自己留个底,以后遇到了方便自己看看,有什么问题可以问我,或者什么地方出错的 也烦请各位大佬帮忙指出来

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

    万次阅读 2016-12-14 15:58:23
    在很多图片上传以及文件上传下载操作的时候...然后我最开始是抱着死马当活马医的心态来使用的,进度上面要求我是要尽快完成的,而且我发现对于我这种小网站来说使用这个COS服务基本上是免费的,简直就是捡到宝的感觉...
    ---------------------------------------------------------------------------------------------
    
    [版权申明:本文系作者原创,转载请注明出处] 
    文章出处: 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服务,将本地的文件同步到cos中,看了腾讯云的用户文档,发现使用COS Migration 工具还是挺适合的。 原因 因为服务器已经安装有java环境,而cos的几个用户工具中,用于自动同步的只...

    目前使用腾讯云的对象存储cos服务,将本地的文件同步到cos中,看了腾讯云的用户文档,发现使用COS Migration 工具还是挺适合的。

    原因

     因为服务器已经安装有java环境,而cos的几个用户工具中,用于自动同步的只看到这个工具,其他工具都需要额外的代码去调用命令,

    从开箱即用的角度看,还是这个工具好用的。

    使用

    配置下./conf/config.ini。指定好同步周期后,运行脚本

    1 sh start_migrate.sh

    因为是需要常驻运行,所以我这边是后台运行的

    nohup sh start_migrate.sh >/dev/null 2>&1 &

    命令大体意思是 

    1.  nohup 表示后台运行
    2. sh start_migrate.sh 是具体的命令
    3. >/dev/null 2>&1   标准输出到空,标准错误输出重定向(等同于)标准输出,即不保存脚本运行中产生的日志,也不保存错误信息(比如脚本不合法。。文件不存在)
    4.    是与nohup一起的,表示不受终端关闭信号影响,保持后台运行。如果没有&,在终端关闭时,当前终端执行的nohup进程也会被stop

    日志

    工具的日志默认是保存在./log下的,有info.log,warn.log,error.log 三个级别的日志。

    1 migrateLocal over! op statistics:
    2                      op_status : ALL_OK
    3                     migrate_ok : 0
    4                   migrate_fail : 0
    5                   migrate_skip : 1094
    6    migrate_condition_not_match : 0
    7                     start_time : 2018-07-14 11:05:57
    8                       end_time : 2018-07-14 11:05:59
    9                      used_time : 2 s

     上面是脚本运行成功后的输出,因为我之前已经同步过了,所以这里是显示 migrate_skip 跳过的文件数。如果有新文件同步成功了,会在migrate_ok显示成功文件数的。

    同步结果中还有可以看到些文件是没有同步成功的,具体的失败原因从error.log中就会详细说明。

     

    utf-8

    我这边遇到的失败原因全都是文件名乱码,或者是说不是utf-8字符格式,导致工具找不到文件。日志中的信息基本是这个内容,就路径不一样

    。。。
    localpath /data/xxxxxx not exist! maybe the path contail illegal utf-8 letter
    ...

    官方文档已经明确指出

    但我们的文件是从本地开发机中通过ftp上传到服务器的。通过对比,那些乱码文件都是含有中文的。

    1. 通过ftp到服务器后全部乱码。
    2. 通过shell远程touch中文名的文件,正常可同步。

    搜索之后知道了ftp是需要设置语言环境的,即字符格式。正在使用的ftp是用默认语言环境,应该是跟系统一样,windows是GBK。linux默认是utf-8

      接下来就是删除乱码文件,修改ftp环境,重新同步文件了。

    发现了乱码文件后,想在终端中手动删除文件,但无法选定。可以使用文件id进行指定。

    ls -i  ./  # 列出文件id及文件名
    find ./ -inum xxxxx -print -exec rm {} \;  # 获取xxx文件id的文件名传给附加命令 rm 删除 如果是文件夹 -rf 需要加在{}后面

     

     

    通知

    有文件需要同步时,不想还要查看日志知道是否成功,打算通过webhook的方式自动通知同步结果。就像git有代码提交后,有消息推送的webhook。目前是使用钉钉平台的自定义机器人

    1. 在群聊中添加自定义机器人,获取webhook地址。
    2. 修改cos migration工具的源码,在成功同步后添加通知任务,向webhook地址post数据
    3. 群聊中显示同步结果,有成功的文件数,还有失败的文件路径及原因

    具体代码请查看我的另外一篇。

    转载于:https://www.cnblogs.com/duoxuan/p/9283959.html

    展开全文
  • Jenkins整合使用腾讯云cos存储桶前言:1、安装python2、安装coscmd3、配置coscmd4、配置jenkins上传文件夹 前言: 因为公司使用腾讯云cos加快访问速度,但是测试地址中使用的是jenkins自动部署项目,所以需要将腾讯...
  • ES使用腾讯云COS存储方案实现快照

    千次阅读 2019-02-21 14:38:38
    由于腾讯云的COS存储兼容S3的API,所以我们使用ES的S3 snapshot接口来对接COS存储,实现快照。 配置ES集群 搭建ES集群环境 该部分由于不是本文讲解的重点,本文不进行讲解 在所有节点安装S3快照插件 bin/...
  • 腾讯云对象存储cos使用一、新建密钥1、登录腾讯云进入控制台2、新建密钥二、创建对象存储1.进入对象存储,并创建存储桶三、创建项目pom文件yml文件创建一util层controller层页面显示四、测试1、上传下载2、删除文件3...
  • Tencent 腾讯云对象存储COS怎么使用?

    千次阅读 2018-05-29 21:55:10
    最近在使用腾讯云中的对象存储,由于文件服务器稍贵,对象存储还是一个不错的选择。对于文件的上传、下载、删除都是可以进行操作的,但是不支持查询获取上传文件的列表。在使用之前需要导入所需jar包 &lt;...
  • COS对象存储

    千次阅读 2018-11-28 20:19:21
    1、为什么需要对象存储 随着移动互联网的快速发展,数据量出现了井喷式的增长,数据的类型也越来越丰富。 在这样的状况下,传统存储已经体现出了一些弊端: ...2.COS存储的优势 COS对象存储,可以很好解决这个问题...
  • 腾讯云对象存储使用 这里忽略创建存储桶之类的操作。 说明:本示例使用nuxt服务端渲染 + koa框架 万事第一步:npm install ~~~ npm i qcloud-cos-sts --save node sdk 注意:qcloud-cos-sts 只能在服务端中使用。 ...
  • 腾讯云主页:http://www.qcloud.com/准备工作:一、根据图示进入COS 点击立即使用 进入后根据下面点击新建:Bucket(Bucket就是你往云存储的一个目录) 新建Bucket 二、下载SDK点击下载SDK下一步: 然后复制把整个cos...
  • 叮当哥之前买了一年的腾讯云服务器,昨日偶然发现腾讯云送了叮当哥半年的cos对象存储服务器,于是就撸起袖子传了几张珍藏的高清大图上去,现将其上传的简单使用步骤总结一波(其它操作参加官方SDK文档API)。...
  • 首先放出GitOS的项目地址...ossdemo-aliyunoss:阿里OSS使用案例(尚未完成) ossdemo-qcloudcos :腾讯云COS使用案例 ossdemo-qiniu :七牛云存储使用案例 pom.xml 腾讯云COS1、官方的使用API介绍地址:https://www
  • 叮当哥之前买了一年的腾讯云服务器,昨日偶然发现腾讯云送了叮当哥半年的cos对象存储服务器,于是就撸起袖子传了几张珍藏的高清大图上去,现将其上传的简单使用步骤总结一波(其它操作参加官方SDK文档API)。...
  • 创建存储桶 创建密钥 SpringBoot下配置COS SecretId 是你生成的密钥ID,Key是密码,region是地区,url是访问域名,bucketName是桶名 创建测试类 先测一下能不能用,在单元测试中添加 @RunWith(SpringRunner....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,735
精华内容 15,094
关键字:

cos存储使用