百度云存储教程

百度云存储教程---免费建立自己的静态站点

分类： 百度云存储 2014-01-21 12:35 2412人阅读 评论(1) 收藏 举报

百度云 存储 批量文件上传 静态站点实现

目录(?)[+]

欢迎访问的我个人网站：点击打开链接--我的个人网站    想建设个人网站的朋友可以找我聊。无门槛，就能永远自己的永久域名和服务器空间，完全免费哦

以前开发的网站苦于没有云服务器，网站没地方挂，现在百度出了云存储和应用引擎，可以让开发者免费上传动态站点和静态站点。这篇文章，我准备用云存储的方式，存储用户的静态网站，开发者可通过将静态页面上传至云存储空间中，并将其访问权限设置为公开读，即可实现静态网站的效果。文章底部有源码和项目下载。

一、实现效果

本地文件夹  

上传成后百度云存储的文件 ：  直接点击index.html 就能浏览这个网页了

这是我上传的站点 :点击打开链接

js文件夹中的文件全部为公开

二、简介

百度云存储，即BCS（Baidu Cloud Storage），提供object网络存储服务，旨在利用百度在分布式以及网络方面的优势为开发者提供安全、简单、高效的存储服务。

百度云存储提供了一系列简单易用的REST API接口、SDK、工具和方案，使得开发者可以在任何时间、任何地点存储任何类型的数据。通过使用百度云存储服务，开发者可以轻松地开发出扩展性强、稳定性好、安全快速的分布式网络服务；通过使用云存储服务提供的API、SDK及管理平台，开发者也可以迅速开发出适合各种业务的网络程序。

百度云存储可以支持文本、多媒体、二进制等任何类型的数据，支持签名认证及ACL权限设置进行资源访问控制，开发者可以通过管理控制台直接进行页面上传、下载或通过REST API、Shell Tool、SDK、curl等方式实现上传、下载。

云存储功能

百度云存储服务主要提供以下功能供开发者使用：

	功能	描述
1	支持任何类型数据的上传和下载	文本、多媒体、日志、二进制等类型数据
2	强大的元信息机制	开发者可以使用通用的和自定义的元信息机制来定义资源属性。
3	超大容量	云存储支持0-2T的单文件数据容量，同时对object的个数没有限制；云存储提供superfile接口，可以实现2T超大文件的上传和下载。
4	分片上传、断点下载功能。	该功能在网络不稳定的环境下具有非常好的表现。
5	Restful风格的HTTP接口和多语言SDK及工具，可极大提高开发者的开发效率。	了解RESTful的相关信息，可参考http://en.wikipedia.org/wiki/Representational_State_Transfer。
6	签名认证方案	基于公钥和密钥的认证方案可适应灵活的业务需求。
7	强大的ACL权限控制	开发者可通过ACL设置资源的权限（公开或私有），也可授权特定用户具有特定权限。
8	功能完善的管理平台	开发者可通过管理中心对所有资源进行统一管理。
9	静态网页托管	开发者可通过将静态页面上传至云存储空间中，并将其访问权限设置为公开读，即可实现静态网站的效果。

第九点非常酷，网站设计师可以把网页托管到百度云了

详见：http://developer.baidu.com/wiki/index.php?title=docs/cplat/bcs  

三、 基本使用

概述

本文主要面向百度云存储服务的开发者，开发者可通过此文学习如何使用百度云存储进行开发。

使用百度云存储服务进行开发的具体步骤如下：

1.  注册百度账号，并成为百度开发者。

2.  #创建应用并获取密钥对（ak&sk）

3.  #创建bucket

4.  #上传文件

5.  #权限设置

创建应用并获取密钥对（ak&sk）

使用云存储服务，需要首先创建应用并获取应用密钥对。操作步骤如下：

1. 在管理中心创建一个应用

2. 在应用基本信息页，获取相应的“API key 及 Secret Key”

创建bucket

创建Bucket，可通过以下三种方式来实现:

1. 通过 云存储管理控制台创建bucket。可以把bucket看成是命名空间，您的数据就存储在这个bucket里面。

2. 通过调用 REST API接口  Put_Bucket实现

3. 通过SDK，调用相关接口来实现

上传文件

使用云存储服务上传文件有以下四种途径：

1. 使用Shell Tool上传

2. 使用SDK进行上传

3. 直接使用curl命令上传

4. 通过云存储管理控制台上传

bucket

云存储bucket可以看成是命名空间，其名称全局唯一，如果某个名称已创建，则其他开发者将无法再创建相同名称的bucket；开发者上传的任何数据必须是属于某个bucket。上传任何数据之前需先确认是否已经创建bucket。 有关bucket的命名限制，请参考#约束与限制。 创建bucket有以下两种方式：

• 通过云存储管理平台创建
• 通过使用put bucket API创建

object

Object是BCS中的基本存储实体，由Key（键）、Data（数据）及MetaData （元数据）组成。

• Key（键）：

指object的唯一标识，其命名必须以“/”开头，有关object的命名限制，请参考#约束与限制。 如： mystorage/test/我的文件.txt

• Data（数据）：

object可支持文本、多媒体、二进制等任何类型的数据，开发者可以利用object API实现上传、下载及获取object列表的功能。

普通文件的文件大小最大为2GB, 对于更大的超大文件（最大支持2TB）可通过put superfile API来实现。

• MetaData （元数据）：

存储object的相关属性的描述性信息，为 k-v 组合。

三、 java代码实现

我们要实现批量文件上传和权限的控制。请看下文

首先在这里下载 SDK 和开发文档  http://developer.baidu.com/wiki/index.php?title=docs/cplat/bcs/sdk

在Sample.java中输入自己的accessKey和 secretKey ，就能运行其中的基本实例了。

上传文件到云存储的函数

[java] view plain copy print ?

1. **  
2.      *   
3.      * @param baiduBCS  
4.      * @param bucket     仓库名  
5.      * @param object     上传到仓库中的对象  
6.      * @param destFile    本地需要上传的文件对象  
7.      * @param contentType     文件类型  
8.      */  
9.     public static void putObjectByFile(BaiduBCS baiduBCS,String bucket,String object,File destFile,String contentType) {  
10.         PutObjectRequest request = new PutObjectRequest(bucket, object, destFile);  
11.         ObjectMetadata metadata = new ObjectMetadata();  
12.         metadata.setContentType(contentType);  
13.   
14.         request.setMetadata(metadata);  
15.         BaiduBCSResponse<ObjectMetadata> response = baiduBCS.putObject(request);  
16.         ObjectMetadata objectMetadata = response.getResult();  
17.         log.info("x-bs-request-id: " + response.getRequestId());  
18.         log.info(objectMetadata);  
19.     }  

这里涉及到三个问题，

第一个是文件类型的获取， 就是ContentType，我们知道 .html文件 的文件类型是  text/html  .css的文件类型是 text/css我们需要指定文件类型。

第二个是文件的权限，文件上传后，默认的权限是私有的，无法访问。 

第三个问题，一次只能上传一个文件，如果我有一个文件夹需要上传呢，这样操作不方便。

所以有了以下的解决办法。 遍历文件批量上传，并且控制文件的权限

权限控制：

[java] view plain copy print ?

1.   /** 
2.      * 修改文件的权限 
3.      * @param baiduBCS  存储上下文 
4.      * @param bucket 存储仓库 
5.      * @param object 文件对象 
6.      * @param acl 控制权限   
7.      */  
8.     public static void putObjectPolicyByX_BS_ACL(BaiduBCS baiduBCS,String bucket ,String object,X_BS_ACL acl) {  
9.         baiduBCS.putObjectPolicy(bucket, object, acl);  
10.     }  

ACL的取值有：Private, PublicRead, PublicWrite, PublicReadWrite, PublicControl;

默认为private，PublicRead，或者PublicReadWrite  就能公开访问了。

下载完sdk后，就开始动手吧

在项目中引入百度的sdk : bcs-sdk-java_1.4.5.jar

mavne 文件:

[html] view plain copy print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <project xmlns="http://maven.apache.org/POM/4.0.0"  
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
5.     <modelVersion>4.0.0</modelVersion>  
6.   
7.     <groupId>baiduBCS</groupId>  
8.     <artifactId>baiduBCS</artifactId>  
9.     <version>1.0-SNAPSHOT</version>  
10.             <dependencies>  
11.                 <dependency>  
12.                     <groupId>log4j</groupId>  
13.                     <artifactId>log4j</artifactId>  
14.                     <version>1.2.17</version>  
15.                 </dependency>  
16.                 <dependency>  
17.                     <groupId>net.sf.flexjson</groupId>  
18.                     <artifactId>flexjson</artifactId>  
19.                     <version>2.1</version>  
20.                 </dependency>  
21.                 <dependency>  
22.                     <groupId>org.apache.httpcomponents</groupId>  
23.                     <artifactId>httpclient</artifactId>  
24.                     <version>4.3.1</version>  
25.                 </dependency>  
26.                 <dependency>  
27.                     <groupId>commons-codec</groupId>  
28.                     <artifactId>commons-codec</artifactId>  
29.                     <version>1.8</version>  
30.                 </dependency>  
31.             </dependencies>  
32.       
33. </project>  

批量上传的源码：

[java] view plain copy print ?

1. import com.baidu.inf.iis.bcs.BaiduBCS;  
2. import com.baidu.inf.iis.bcs.model.X_BS_ACL;  
3.   
4. import java.io.File;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.util.ArrayList;  
8. import java.util.Properties;  
9.   
10. /** 
11.  * Created with IntelliJ IDEA. 
12.  * User: liu.xing 
13.  * Date: 14-1-20 
14.  * Time: 下午7:23 
15.  * coding for fun and coding my life! 
16.  */  
17. public class MultipUpload {  
18.     static String filePrefix = "E:/站点/innos";  
19.     static int len = filePrefix.length();  
20.     private static ArrayList filelist = new ArrayList();  
21.     static String bucket = "innosrom";     //文件仓库名  
22.     static String bcsDir = "/webDesgin/01/";  //文件存放目录  
23.   
24.     static String object = "";             //文件对象本身  
25.     static BaiduBCS bcs;  
26.     static Properties pro;  
27.   
28.   
29.     public static void main(String[] args) {  
30.         MultipUpload mu = new MultipUpload();  
31.         long a = System.currentTimeMillis();  
32.         pro = mu.loadFileContentType();    //载入文件格式对应的文档类型  
33.         bcs = Sample.init();              //初始化百度云存储环境  
34.         mu.refreshFileList(filePrefix);   //遍历文件  
35.         System.out.println(System.currentTimeMillis() - a);  
36.     }  
37.   
38.     /** 
39.      * 遍历文件 
40.      * @param strPath 文件夹路径 
41.      */  
42.     public void refreshFileList(String strPath) {  
43.         File dir = new File(strPath);  
44.         File[] files = dir.listFiles();  
45.   
46.         if (files == null)  
47.             return;  
48.         for (int i = 0; i < files.length; i++) {  
49.             String absPath = files[i].getAbsolutePath();  
50.             if (files[i].isDirectory()) {  
51.                 refreshFileList(absPath);  
52.             } else {  
53.                 String strFileName = absPath.replace("\\", "/");  
54.                 object = bcsDir + strFileName.substring(len + 1);  
55.                 String contentType = getContentType(object,pro);  
56.                 System.out.println(object+"\t"+contentType);  
57.                 Sample.putObjectByFile(bcs, bucket, object, new File(absPath),contentType);  
58.                 Sample.putObjectPolicyByX_BS_ACL(bcs, bucket, object, X_BS_ACL.PublicReadWrite);  
59.                 //deleteAll(bcs,object);  
60.             }  
61.         }  
62.     }  
63.   
64.     /** 
65.      * 根据文件名获取ContentType 
66.      * @param object    文件名 
67.      * @param pro      contentType-file 对应的 Properties对象 
68.      * @return      ContentType 
69.      */  
70.     private String getContentType(String object,Properties pro) {  
71.   
72.         if(object.contains(".")){  
73.             int index = object.lastIndexOf(".");  
74.             String suffix = object.substring(index+1);     //获取文件后缀  
75.             Object contentType = pro.get(suffix);  
76.             if(contentType != null)  
77.                 return contentType.toString();  
78.         }  
79.         return "text/html";  
80.     }  
81.     public void deleteAll(BaiduBCS bcs,String object){  
82.         Sample.deleteObject(bcs,object);  
83.     }  
84.   
85.     /** 
86.      * 载入ContentType 文件 
87.      * @return 
88.      */  
89.     public Properties loadFileContentType(){  
90.         InputStream is = getClass().getClassLoader().getSystemResourceAsStream("contentType.proerties");  
91.         Properties pro = new Properties();  
92.         try {  
93.             pro.load(is);  
94.         } catch (IOException e) {  
95.             e.printStackTrace();  
96.         }  
97.         return  pro;  
98.     }  
99.   
100.   
101. }  

Smaple demo:

[java] view plain copy print ?

1. /*************************************************************************** 
2.  *  
3.  * Copyright (c) 2012 Baidu.com, Inc. All Rights Reserved 
4.  *  
5.  **************************************************************************/  
6. import java.io.*;  
7. import java.net.URISyntaxException;  
8. import java.util.ArrayList;  
9. import java.util.List;  
10.   
11. import com.baidu.inf.iis.bcs.model.*;  
12. import org.apache.commons.logging.Log;  
13. import org.apache.commons.logging.LogFactory;  
14.   
15. import com.baidu.inf.iis.bcs.BaiduBCS;  
16. import com.baidu.inf.iis.bcs.auth.BCSCredentials;  
17. import com.baidu.inf.iis.bcs.auth.BCSSignCondition;  
18. import com.baidu.inf.iis.bcs.http.HttpMethodName;  
19. import com.baidu.inf.iis.bcs.policy.Policy;  
20. import com.baidu.inf.iis.bcs.policy.PolicyAction;  
21. import com.baidu.inf.iis.bcs.policy.PolicyEffect;  
22. import com.baidu.inf.iis.bcs.policy.Statement;  
23. import com.baidu.inf.iis.bcs.request.CreateBucketRequest;  
24. import com.baidu.inf.iis.bcs.request.GenerateUrlRequest;  
25. import com.baidu.inf.iis.bcs.request.GetObjectRequest;  
26. import com.baidu.inf.iis.bcs.request.ListBucketRequest;  
27. import com.baidu.inf.iis.bcs.request.ListObjectRequest;  
28. import com.baidu.inf.iis.bcs.request.PutObjectRequest;  
29. import com.baidu.inf.iis.bcs.request.PutSuperfileRequest;  
30. import com.baidu.inf.iis.bcs.response.BaiduBCSResponse;  
31.   
32. @SuppressWarnings("unused")  
33. public class Sample {  
34.     private static final Log log = LogFactory.getLog(Sample.class);  
35.     // ----------------------------------------  
36.     static String host = "bcs.duapp.com";  
37.     static String accessKey = "您自己的私钥";  
38.     static String secretKey = "您自己的密钥";  
39.     static String bucket = "innosrom";  
40.     // ----------------------------------------  
41.     static String object = "/index.jsp";  
42.     static File destFile = new File("C:\\BCS\\up.txt");  
43.     static File saveFile = new File("C:\\BCS\\download.txt");  
44.     public static BaiduBCS init(){  
45.         BCSCredentials credentials = new BCSCredentials(accessKey, secretKey);  
46.         BaiduBCS baiduBCS = new BaiduBCS(credentials, host);  
47.         // baiduBCS.setDefaultEncoding("GBK");  
48.          baiduBCS.setDefaultEncoding("UTF-8"); // Default UTF-8  
49.         return  baiduBCS;  
50.     }  
51.   
52.     /** 
53.      * @param args 
54.      * @throws java.net.URISyntaxException 
55.      * @throws java.io.IOException 
56.      */  
57.     public static void main(String[] args) throws URISyntaxException, IOException {  
58.        // PropertyConfigurator.configure("log4j.properties");  
59.   
60.         BCSCredentials credentials = new BCSCredentials(accessKey, secretKey);  
61.         BaiduBCS baiduBCS = new BaiduBCS(credentials, host);  
62.         // baiduBCS.setDefaultEncoding("GBK");  
63.         baiduBCS.setDefaultEncoding("UTF-8"); // Default UTF-8  
64.         try {  
65.             // -------------bucket-------------  
66.             // listBucket(baiduBCS);  
67.             // createBucket(baiduBCS);  
68.             // deleteBucket(baiduBCS);  
69.             // getBucketPolicy(baiduBCS);  
70.             // putBucketPolicyByPolicy(baiduBCS);  
71.             // putBucketPolicyByX_BS_ACL(baiduBCS, X_BS_ACL.PublicControl);  
72.             // listObject(baiduBCS);  
73.             // ------------object-------------  
74.             //putObjectByFile(baiduBCS);  
75.              //putObjectByInputStream(baiduBCS);  
76.             //getObjectWithDestFile(baiduBCS);  
77.             // putSuperfile(baiduBCS);  
78.              //deleteObject(baiduBCS);  
79.              //getObjectMetadata(baiduBCS);  
80.             // setObjectMetadata(baiduBCS);  
81.             // copyObject(baiduBCS, bucket, object + "_copy" +  
82.             // (System.currentTimeMillis()));  
83.             //getObjectPolicy(baiduBCS);  
84.              //putObjectPolicyByPolicy(baiduBCS);  
85.              putObjectPolicyByX_BS_ACL(baiduBCS, X_BS_ACL.PublicReadWrite);  
86.   
87.             // ------------common------------------  
88.             //generateUrl( baiduBCS);  
89.         } catch (BCSServiceException e) {  
90.             log.warn("Bcs return:" + e.getBcsErrorCode() + ", " + e.getBcsErrorMessage() + ", RequestId=" + e.getRequestId());  
91.         } catch (BCSClientException e) {  
92.             e.printStackTrace();  
93.         }  
94.     }  
95.   
96.     public static void generateUrl(BaiduBCS baiduBCS) {  
97.         GenerateUrlRequest generateUrlRequest = new GenerateUrlRequest(HttpMethodName.GET, bucket, object);  
98.         generateUrlRequest.setBcsSignCondition(new BCSSignCondition());  
99.         generateUrlRequest.getBcsSignCondition().setIp("*");  
100.         //generateUrlRequest.getBcsSignCondition().setTime(123455L);  
101.         //generateUrlRequest.getBcsSignCondition().setSize(123455L);  
102.         System.out.println(baiduBCS.generateUrl(generateUrlRequest));  
103.     }  
104.   
105.     public static void copyObject(BaiduBCS baiduBCS, String destBucket, String destObject) {  
106.         ObjectMetadata objectMetadata = new ObjectMetadata();  
107.         objectMetadata.setContentType("image/jpeg");  
108.         baiduBCS.copyObject(new Resource(bucket, object), new Resource(destBucket, destObject), objectMetadata);  
109.         baiduBCS.copyObject(new Resource(bucket, object), new Resource(destBucket, destObject), null);  
110.         baiduBCS.copyObject(new Resource(bucket, object), new Resource(destBucket, destObject));  
111.     }  
112.   
113.     private static void createBucket(BaiduBCS baiduBCS) {  
114.         // baiduBCS.createBucket(bucket);  
115.         baiduBCS.createBucket(new CreateBucketRequest(bucket, X_BS_ACL.PublicRead));  
116.     }  
117.   
118.     private static void deleteBucket(BaiduBCS baiduBCS) {  
119.         baiduBCS.deleteBucket(bucket);  
120.     }  
121.   
122.     public static void deleteObject(BaiduBCS baiduBCS,String object) {  
123.         Empty result = baiduBCS.deleteObject(bucket, object).getResult();  
124.         log.info(result);  
125.     }  
126.   
127.     private static void getBucketPolicy(BaiduBCS baiduBCS) {  
128.         BaiduBCSResponse<Policy> response = baiduBCS.getBucketPolicy(bucket);  
129.   
130.         log.info("After analyze: " + response.getResult().toJson());  
131.         log.info("Origianal str: " + response.getResult().getOriginalJsonStr());  
132.     }  
133.   
134.     public static void getObjectMetadata(BaiduBCS baiduBCS) {  
135.         ObjectMetadata objectMetadata = baiduBCS.getObjectMetadata(bucket, object).getResult();  
136.         log.info(objectMetadata);  
137.     }  
138.   
139.     private static void getObjectPolicy(BaiduBCS baiduBCS) {  
140.         BaiduBCSResponse<Policy> response = baiduBCS.getObjectPolicy(bucket, object);  
141.         log.info("After analyze: " + response.getResult().toJson());  
142.         log.info("Origianal str: " + response.getResult().getOriginalJsonStr());  
143.     }  
144.   
145.     private static void getObjectWithDestFile(BaiduBCS baiduBCS) {  
146.         GetObjectRequest getObjectRequest = new GetObjectRequest(bucket, object);  
147.         baiduBCS.getObject(getObjectRequest, saveFile);  
148.     }  
149.   
150.     private static void listBucket(BaiduBCS baiduBCS) {  
151.         ListBucketRequest listBucketRequest = new ListBucketRequest();  
152.         BaiduBCSResponse<List<BucketSummary>> response = baiduBCS.listBucket(listBucketRequest);  
153.         for (BucketSummary bucket : response.getResult()) {  
154.             log.info(bucket);  
155.         }  
156.     }  
157.   
158.     private static void listObject(BaiduBCS baiduBCS) {  
159.         ListObjectRequest listObjectRequest = new ListObjectRequest(bucket);  
160.         listObjectRequest.setStart(0);  
161.         listObjectRequest.setLimit(20);  
162.         // ------------------by dir  
163.         {  
164.             // prefix must start with '/' and end with '/'  
165.             // listObjectRequest.setPrefix("/1/");  
166.             // listObjectRequest.setListModel(2);  
167.         }  
168.         // ------------------only object  
169.         {  
170.             // prefix must start with '/'  
171.             // listObjectRequest.setPrefix("/1/");  
172.         }  
173.         BaiduBCSResponse<ObjectListing> response = baiduBCS.listObject(listObjectRequest);  
174.         log.info("we get [" + response.getResult().getObjectSummaries().size() + "] object record.");  
175.         for (ObjectSummary os : response.getResult().getObjectSummaries()) {  
176.             log.info(os.toString());  
177.         }  
178.     }  
179.   
180.     private static void putBucketPolicyByPolicy(BaiduBCS baiduBCS) {  
181.         Policy policy = new Policy();  
182.         Statement st1 = new Statement();  
183.         st1.addAction(PolicyAction.all).addAction(PolicyAction.get_object);  
184.         st1.addUser("zhengkan").addUser("zhangyong01");  
185.         st1.addResource(bucket + "/111").addResource(bucket + "/111");  
186.         st1.setEffect(PolicyEffect.allow);  
187.         policy.addStatements(st1);  
188.         baiduBCS.putBucketPolicy(bucket, policy);  
189.     }  
190.   
191.     private static void putBucketPolicyByX_BS_ACL(BaiduBCS baiduBCS, X_BS_ACL acl) {  
192.         baiduBCS.putBucketPolicy(bucket, acl);  
193.     }  
194.   
195.     public static void putObjectByFile(BaiduBCS baiduBCS) {  
196.         PutObjectRequest request = new PutObjectRequest(bucket, object, destFile);  
197.         ObjectMetadata metadata = new ObjectMetadata();  
198.         metadata.setContentType("text/html");  
199.   
200.         request.setMetadata(metadata);  
201.         BaiduBCSResponse<ObjectMetadata> response = baiduBCS.putObject(request);  
202.         ObjectMetadata objectMetadata = response.getResult();  
203.         log.info("x-bs-request-id: " + response.getRequestId());  
204.         log.info(objectMetadata);  
205.     }  
206.   
207.     /** 
208.      * 
209.      * @param baiduBCS 
210.      * @param bucket     仓库名 
211.      * @param object     上传到仓库中的对象 
212.      * @param destFile    本地需要上传的文件对象 
213.      * @param contentType     文件类型 
214.      */  
215.     public static void putObjectByFile(BaiduBCS baiduBCS,String bucket,String object,File destFile,String contentType) {  
216.         PutObjectRequest request = new PutObjectRequest(bucket, object, destFile);  
217.         ObjectMetadata metadata = new ObjectMetadata();  
218.         metadata.setContentType(contentType);  
219.   
220.         request.setMetadata(metadata);  
221.         BaiduBCSResponse<ObjectMetadata> response = baiduBCS.putObject(request);  
222.         ObjectMetadata objectMetadata = response.getResult();  
223.         log.info("x-bs-request-id: " + response.getRequestId());  
224.         log.info(objectMetadata);  
225.     }  
226.   
227.     public static void putObjectByInputStream(BaiduBCS baiduBCS) throws FileNotFoundException {  
228.         File file = createSampleFile();  
229.         InputStream fileContent = new FileInputStream(file);  
230.         ObjectMetadata objectMetadata = new ObjectMetadata();  
231.         objectMetadata.setContentType("text/html");  
232.         objectMetadata.setContentLength(file.length());  
233.         PutObjectRequest request = new PutObjectRequest(bucket, object, fileContent, objectMetadata);  
234.         ObjectMetadata result = baiduBCS.putObject(request).getResult();  
235.         log.info(result);  
236.     }  
237.   
238.     private static void putObjectPolicyByPolicy(BaiduBCS baiduBCS) {  
239.         Policy policy = new Policy();  
240.         Statement st1 = new Statement();  
241.         st1.addAction(PolicyAction.all).addAction(PolicyAction.get_object);  
242.         st1.addUser("zhengkan").addUser("zhangyong01");  
243.         st1.addResource(bucket + object).addResource(bucket + object);  
244.         st1.setEffect(PolicyEffect.allow);  
245.         policy.addStatements(st1);  
246.         baiduBCS.putObjectPolicy(bucket, object, policy);  
247.     }  
248.   
249.     private static void putObjectPolicyByX_BS_ACL(BaiduBCS baiduBCS, X_BS_ACL acl) {  
250.         baiduBCS.putObjectPolicy(bucket, object, acl);  
251.     }  
252.   
253.     /** 
254.      * 修改文件的权限 
255.      * @param baiduBCS  存储上下文 
256.      * @param bucket 存储仓库 
257.      * @param object 文件对象 
258.      * @param acl 控制权限 
259.      */  
260.     public static void putObjectPolicyByX_BS_ACL(BaiduBCS baiduBCS,String bucket ,String object,X_BS_ACL acl) {  
261.         baiduBCS.putObjectPolicy(bucket, object, acl);  
262.     }  
263.   
264.     public static void putSuperfile(BaiduBCS baiduBCS) {  
265.         List<SuperfileSubObject> subObjectList = new ArrayList<SuperfileSubObject>();  
266.         // 0  
267.         BaiduBCSResponse<ObjectMetadata> response1 = baiduBCS.putObject(bucket, object + "_part0", createSampleFile());  
268.         subObjectList.add(new SuperfileSubObject(bucket, object + "_part0", response1.getResult().getETag()));  
269.         // 1  
270.         BaiduBCSResponse<ObjectMetadata> response2 = baiduBCS.putObject(bucket, object + "_part1", createSampleFile());  
271.         subObjectList.add(new SuperfileSubObject(bucket, object + "_part1", response2.getResult().getETag()));  
272.         // put superfile  
273.         PutSuperfileRequest request = new PutSuperfileRequest(bucket, object + "_superfile", subObjectList);  
274.         BaiduBCSResponse<ObjectMetadata> response = baiduBCS.putSuperfile(request);  
275.         ObjectMetadata objectMetadata = response.getResult();  
276.         log.info("x-bs-request-id: " + response.getRequestId());  
277.         log.info(objectMetadata);  
278.     }  
279.   
280.     public static void setObjectMetadata(BaiduBCS baiduBCS) {  
281.         ObjectMetadata objectMetadata = new ObjectMetadata();  
282.         objectMetadata.setContentType("text/html12");  
283.         baiduBCS.setObjectMetadata(bucket, object, objectMetadata);  
284.     }  
285.   
286.     private static File createSampleFile() {  
287.         try {  
288.             File file = File.createTempFile("java-sdk-", ".txt");  
289.             file.deleteOnExit();  
290.   
291.             Writer writer = new OutputStreamWriter(new FileOutputStream(file));  
292.             writer.write("01234567890123456789\n");  
293.             writer.write("01234567890123456789\n");  
294.             writer.write("01234567890123456789\n");  
295.             writer.write("01234567890123456789\n");  
296.             writer.write("01234567890123456789\n");  
297.             writer.close();  
298.   
299.             return file;  
300.         } catch (IOException e) {  
301.             log.error("tmp file create failed.");  
302.             return null;  
303.         }  
304.     }  
305. }  

文件类型和后缀对应表 contentType.proerties

参考我的另外一篇文章：

http://blog.csdn.net/kissliux/article/details/18601729

源码下载地址： http://download.csdn.net/detail/a442180673/6870241