JAVA1.1

最近更新时间:2019-01-14 10:11:00

KS3 SDK For Java使用指南


目录

一、前言

二、安装

三、初始化

1、配置参数

2、配置日志

3、获取密钥

4、初始化客户端

四、快速入门

1、新建一个存储空间

2、上传文件

3、通过表单的方式上传文件

4、获取文件访问地址

五、存储空间(bucket)相关

1、获取所有Bucket

2、新建Bucket

3、删除Bucket

4、获取Bucket的region信息

5、判断Bucket是否存在

6、设置Bucket权限

7、获取Bucket权限

8、为Bucket配置日志

9、获取Bucket的日志配置

10、设置Bucket的CORS跨域规则

11、获取Bucket的CORS跨域规则

12、删除Bucket的CORS跨域规则

六、文件(object)相关

1、文件上传

1.1 简单上传

1.2 表单上传文件

1.3 分片上传

1.4 上传回调

2、文件下载

2.1 下载到本地文件

2.2 流式下载

2.3 范围下载

3、文件管理

3.1 判断文件是否存在

3.2 获取文件的ACL

3.3 设置文件的ACL

3.4 设置文件的元信息

3.5 获取文件的元信息

3.6 删除文件

3.7 列举存储空间下的文件

3.8 列举指定目录下的文件

3.9 拷贝文件

七、授权管理

1、生成文件的下载外链地址

2、生成文件的上传外链地址

3、生成签名URL

4、使用签名URL上传文件

5、使用签名URL下载文件

八、数据安全性

1、MD5检验

2、服务端加密

3、客户端加密

九、跨域资源访问

1、创建跨域访问规则

2、查删除跨域访问规则

3、查看跨域访问规则

十、访问日志

1、开启日志功能

2、关闭日志功能

十一、异常处理

十二、常见问题


一、前言

此SDK适用于Java 5及以上版本,是基于KS3 API 构建,请访问GitHub获取源码。

二、安装

1、请在计算机上配置JAVA5以上的开发环境;

2、下载KS3 SDK For Java https://github.com/ks3sdk/ks3-java-sdk

3、新建一个maven工程,填写GroupId和ArtifactId,点击【完成】;

4、导入KS3 SDK工程有如下两种方法:

  • 打开创建的Maven项目下的Pom.xml文件,将以下代码添加到Pom.xml文件中下,点击保存后将会自动下载所有jar包;

    <dependency>
    
        <groupId>com.ksyun</groupId>
    
        <artifactId>ks3-kss-java-sdk</artifactId>
    
        <version>0.8.5</version>
    
    </dependency>
  • 直接引用KS3 SDK包lib目录下的所有jar包;

三、初始化

1、配置参数

1、创建一个config对象,并根据需要修改Ks3ClientConfig的默认配置项;

2、指定Endpoint和访问方式,有关EndPoint的更多信息请参考概念和术语文档, 如果使用自定义域名,设置endpoint为自定义域名,同时设置domainMode为true;

3、设置httpclient的相关属性,例如代理,超时,重试等;

  • 以下代码为配置参数参考示例:

    //1.创建一个config对象;
    Ks3ClientConfig config = new Ks3ClientConfig();
    
    //2.填写Endpoint,此处以北京region为例;
    config.setEndpoint("ks3-cn-beijing.ksyun.com");  
    
    //3.配置域名模式:(true):表示以自定义域名访问;(false):表示以KS3的外网域名或内网域名访问,默认为false;
    config.setDomainMode(false);
    
    //4.配置协议
    config.setProtocol(PROTOCOL.http);
    
    //5.设置访问方式:
    //(true)表示以endpoint/{bucket}/{key}的方式访问
    //(false)表示以{bucket}.endpoint/{key}的方式访问
    //如果domainMode设置为true,pathStyleAccess可忽略设置;
    config.setPathStyleAccess(false); 
    
    //6.在HttpClientConfig中可以设置httpclient的相关属性,比如代理,超时,重试等。
    HttpClientConfig hconfig = new HttpClientConfig();
    config.setHttpClientConfig(hconfig);

2、配置日志

该SDK使用commons-logging

使用log4j的示例:

1、引用log4j相关jar包

    <dependency>

        <groupId>log4j</groupId>

        <artifactId>log4j</artifactId>

        <version>1.2.16</version>

    </dependency>

2、新建log4j.properties(如下为示例配置)

    log4j.logger.com.ksyun.ks3=DEBUG,stdout

    log4j.logger.org.apache.http=DEBUG,stdout

    log4j.logger.org.apache.http.wire=ERROR,stdout

    log4j.addivity.org.apache=true

    log4j.appender.stdout=org.apache.log4j.ConsoleAppender

    log4j.appender.stdout.Target=System.out

    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

    log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss SSS} %-5p [%t]%C{1}.%M(%L) - %m%n

使用logback示例

1、引用SDK的时候排除commons-logging,引用logback相关包(包括但不止jcl-over-slf4j)

    <dependency>

        <groupId>com.ksyun</groupId>

        <artifactId>ks3-kss-java-sdk</artifactId>

        <version>0.6.0</version>

        <exclusions>

            <exclusion>

                <artifactId>commons-logging</artifactId>

                 <groupId>commons-logging</groupId>

            </exclusion>

        </exclusions>

    </dependency>

    <dependency>

        <groupId>org.slf4j</groupId>

        <artifactId>jcl-over-slf4j</artifactId>

        <version>1.7.7</version>

    </dependency>

2、配置logback

3、获取密钥

1、开通KS3服务,可点击https://www.ksyun.com/user/register 注册金山云账号;

2、进入控制台 获取AccessKeyID 、AccessKeySecret;

注意:主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM子账号进行API访问或日常运维,请登录 https://iam.console.ksyun.com/#/userList创建IAM子账号。

4、初始化客户端

当以上全部完成之后用户便可初始化客户端进行操作了,操作方法有如下两种:

方法一:

//创建一个client对象;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
lient.setKs3config(config);
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>");
lient.setKs3config(config);

方法二:

//创建一个client对象,加入配置参数;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

四、快速入门

本节主要介绍如何使用KS3 Java SDK完成基础操作,帮助用户快速熟悉KS3的基本功能。 在学习本节内容之前,请先阅读常用概念术语文档

1、新建一个存储空间

存储空间是存放文件的容器,所有的文件都必须存放在特定的存储空间中。每个用户最多可以创建30个存储空间,每个存储空间中可以存放无限多个文件。

本小节使用金山云控制台创建Bucket:进入控制台,选择【存储与对象】菜单下的【对象存储】,点击右上角【创建空间】,填写“Region”、“空间名称”、“访问权限”,点击【确定】后Bucket创建完成,可在【我的空间】列表中查询已创建的Bucket。

2、上传文件

以下代码用于上传文件至KS3:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建request对象,将new File("<filePath>")这个文件上传至<bucket名称>这个存储空间下,并命名为<key>;
PutObjectRequest request = new PutObjectRequest("<bucket名称>","<key>", new File("<filePath>"));

//4.设置文件ACL权限;
request.setCannedAcl(CannedAccessControlList.PublicRead);

//5.执行上传文件操作;
client.putObject(request);

说明:

  • Bukect名称全局唯一。

  • 该方法需要三个参数,第一个参数为在4.1时新建的Bucket名称。第二个参数为Object名称,例如:image.jpg,2015/10/19/image.jpg 等。第三个参数为要上传的文件对象,请填写正确的文件路径,例如:“D:/XXX/XXXX.doxc”。
  • 登录的账号需获取上传文件Bucket的写权限,否则会出现Access Deny的错误提示,详情请见用户权限示例

3、通过表单的方式上传文件

第一步:在KS3控制台->空间设置->配置CORS跨域规则。例如:

第二步:以下代码在JAVA SDK中使用,用于获取policy和Signature:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);     

//3.初始化一个postData对象,对于用户可以确定表单值的放在 postData中;
Map<String,String> postData = new HashMap<String,String>();

//4.设置ACL,且值要与js SDK中保持一致,否则删除下面一行代码;
postData.put("acl","public-read");

//5.输入key值,且值要与js SDK中保持一致;
postData.put("key","PostObject/filed1.docx");

//6.初始化一个unknowValueField对象,对于用户无法确定表单值的放在unknownValueField中(比如有的上传控件会添加一些表单项,但表单项的值可能是随机的);
List<String> unknowValueField = new ArrayList<String>();

//7.js sdk上传的时候会自动加上一个name的表单项,此处也需要保持一致;
unknowValueField.add("name");

//8.如果计算签名时提供的key里不包含${filename}占位符,可以把第二个参数传一个空字符串。因为计算policy需要的key是把${filename}进行替换后的key。
PostObjectFormFields fields = client.postObject("<Bucket>", "<key>", postData, unknowValueField);

//9.在打印控制台上输出Policy和Signature,请保存该信息以便于在js sdk中使用;
System.out.println("fields : "+fields);
System.out.println("KssAccessKeyId : "+fields.getKssAccessKeyId());
System.out.println("Policy : "+fields.getPolicy());
System.out.println("Signature : "+fields.getSignature());

第三步:下载js sdk文档

第四步:打开js文件夹下的ks3jssdk.js文件,根据提示填写信息(建议不要直接复制),如下图所示:

(function KS3JsSDK (win) {
var ks3FileUploader = function(ks3PostOptions, pluploadOptions){
this.defaultKS3Options  = {
//1.输入在第二步中,使用java sdk获得的KSSAccessKeyId;
KSSAccessKeyId: "",

//2.输入在第二步中,使用java sdk获得的policy;
policy: "",

//3.输入在第二步中,使用java sdk获得的signature;
signature: "", 

//4.填写Bucket;
bucket_name: "",

//5.填写上传键值的名称。如果用户想要使用文件名作为键值,可以使用${filename} 变量。例如:如果用户想要上传文件local.jpg,需要指明specify /
key: "",

//6.上传文件访问权限,与java sdk中保持一致
acl: "", 

//7.上传域名,http://destination-bucket.kss.ksyun.com 或者 http://kssws.ks-cdn.com/destination-bucket
uploadDomain: "", 

autoStart: false, //是否在文件添加完毕后自动上传
onInitCallBack: function(){}, //上传初始化时调用的回调函数
onErrorCallBack: function(){}, //发生错误时调用的回调函数
onFilesAddedCallBack: function(){}, //文件添加到浏览器时调用的回调函数
onBeforeUploadCallBack: function(){}, //文件上传之前时调用的回调函数
onStartUploadFileCallBack: function(){}, //文件开始上传时调用的回调函数
onUploadProgressCallBack: function(){}, //上传进度时调用的回调函数
onFileUploadedCallBack: function(){}, //文件上传完成时调用的回调函数
onUploadCompleteCallBack: function(){} //所有上传完成时调用的回调函数
    };

第五步:打开js文件夹下的main.js文件,根据提示填写信息,请请参考以下代码:

//1.请替换为您的AK;
Ks3.config.AK = '';

//2.填写您的SK;
Ks3.config.SK = ''; 

//3.填写Bucket所在的region;如果region设置和实际不符,则会返回301状态码;
Ks3.config.region = 'BEIJING';

//4.填写Bucket名称,请与java sdk中的信息保持一致;
Ks3.config.bucket = '<Bucket>';
var bucketName = Ks3.config.bucket; 

var policy = {
//1。expiration用于指定策略的过期时间,即只能在指定时间之前进行上传,在这个时间之后的上传都将被认为是非法的,KS3将返回403。注意:时区为格林时间(零时区)而非北京时间(东八区),此处暂时设置为一小时后;
"expiration": new Date(getExpires(3600)*1000).toISOString(), 

//2.Policy文档中对上传内容的验证条件。您在表单中指定的每个表单字段(KSSAccessKeyId、Signature、file、policy除外)以及bucket必须包含在条件列表中,此处可以自定义原信息、上传协议、文件类型,但请与java sdk中的postData.put("","")方法。
"conditions": [
        ["eq","$bucket", bucketName],
        ["starts-with", "$key", "key"],
        ["starts-with","$acl", "与java sdk中保持一致"],
        ["starts-with", "$name", "name"],   //表单中传了name字段,也需要加到policy中
        ["starts-with", "$x-kss-meta-custom-param1",""],
        ["starts-with", "$x-kss-newfilename-in-body",""],//必须只包含小写字符
        ["starts-with", "$Cache-Control",""],
        ["starts-with", "$Expires", ""],
        ["starts-with", "$Content-Disposition", ""],
        ["starts-with", "$Content-Type",""],
        ["starts-with", "$Content-Encoding",""]
    ]
};

第六步:打开demo文件夹下的index文件,开始上传文件。

说明:

  • 上传时,浏览器一共会发送两个请求,第一个为OPTIONS请求,第二个为POST请求。如果第一个请求返回403,请检测CORS配置是否正确。如果第二个请求返回403,请检查生成policy时,是否完全按照表单内容生成。或者把policy进行base64解码,对比表单内容是否正确。对比规则:Policy、Signature构建方法

4、获取文件访问地址

4.1 公有文件

通过http://{bucket}.{endpoint}/{key}的方式拼接一个URL即可。

例如:http://test-bucket.kss.ksyun.com/2015/10/19/image.jpg , 该URL中的{bucket}是test-bucket;{endpoint}是kssws.ks-cdn.com;{key}是2015/10/19/image.jpg。

4.2 私有文件

以下代码用于生成一个私有文件的URL:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.生成一个在1000秒后过期的外链;
client.generatePresignedUrl("<bucket>","<key>",1000);

//4.生成一个1000秒后过期并重写返回的heade的外链;
ResponseHeaderOverrides overrides = new ResponseHeaderOverrides();
client.generatePresignedUrl("<bucket>","<key>",1000,overrides);

//5.打印输出生成的URL;
System.out.println( "生成一个在1000秒后过期的外链: "+ client.generatePresignedUrl("<bucket>","<key>",1000));
System.out.println( "生成一个1000秒后过期并重写返回的heade的外链: "+ client.generatePresignedUrl("<bucket>","<key>",1000,overrides));

常见问题:

  • 如果文件不存在,会返回NoSuchKey错误;

  • 如果以公开的方式访问私有文件,会返回AccessDined错误;

  • 如果私有文件访问地址过期,会返回URLExpired错误;

  • 1000秒后过期参照客户端本地时间;

五、存储空间(bucket)相关

本节主要介绍有关存储空间(Bucket)相关的KS3 Java SDK操作。

1、获取所有Bucket

以下代码用于获取用户拥有的全部存储空间:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建Bucket对象;
List<Bucket> buckets = client.listBuckets();

//4.遍历获取到的所有Bucket,并获取每个Bucket的参数;
for(Bucket bucket:buckets){
    //获取bucket的创建时间
    bucket.getCreationDate();
    //获取bucket的名称
    bucket.getName();
    //获取bucket的拥有者(用户ID base64后的值)
    bucket.getOwner();

//5.在控制台打印输出Bucket的名称、创建时间、拥有者;
System.out.println( "Bucket名称: "+bucket.getName()+ "  Bucket创建时间: "+bucket.getCreationDate()+"  Bucket的拥有者: "+bucket.getOwner());

2、新建Bucket

在4.1中介绍了使用控制台的方式创建存储空间(Bucket),本小节介绍以代码的方式创建存储空间,用户可根据需求选择创建方式。

以下代码用于创建一个Bucket:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.输入Bucket名称,注意全局唯一;
client.createBucket("<bucket>");

//4.配置Bucket的存储地点,以北京为例;
CreateBucketRequest request = new CreateBucketRequest("<bucket>");
CreateBucketConfiguration config1 = new CreateBucketConfiguration(REGION.BEIJING);
 request.setConfig(config1);

//5.配置Bucket的ACL访问权限,此处设置为私有;
request.setCannedAcl(CannedAccessControlList.Private);

//6.创建Bucket,可登陆金山云控制台,在【我的空间】列表中查看创建的Bucket,或者参考5.7判断Bucket是否存在;
client.createBucket(request);

3、删除Bucket

以下代码用于删除Bucket:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.删除Bucket,注意:删除Bucket之前先确保该Bucket下的所有Object被删除完毕;
client.deleteBucket("<Bucket>");

4、获取Bucket的region信息

以下代码用于获取Bucket的region信息:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个region对象,填写要查询的Bucket名称;
REGION region = client.getBucketLoaction("<您的Bucket名称>");

//4.在控制台打印输出结果;
System.out.println( "返回结果为: "+region);

说明:

  • 关于获取存储空间Region的详细说明,请参考GET Location文档。

5、判断Bucket是否存在

以下代码用于判断Bucket是否存在:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个result对象并获取bucket是否存在和读写权限信息;
HeadBucketResult result = client.headBucket("<Bucket>");
result.getStatueCode();

//4.在控制台打印输出结果,若状态字为200则表示成功;若状态字为404则表示该bucket不存在;
System.out.println( "返回结果为: "+result.getStatueCode());

说明:

  • 关于获取Bucket信息的详细说明,请参考HEAD Bucket文档。
  • 关于返回的错误码的详细说明,请参考错误码列表

6、设置Bucket权限

存储空间的访问权限(ACL)有以下三类:

ACL访问权限 描述 预设ACL权限值
私有 只有存储空间的拥有者和授权用户有该存储空间内的文件的读写权限。 CannedAccessControlList.Private
公有读 存储空间的拥有者和授权用户有该存储空间内的文件的读写权限,其他用户只有该存储空间内的文件的读权限。请谨慎使用该权限。 CannedAccessControlList.PublicRead
公有读写 所有用户都有该存储空间内的文件的读写权限。请谨慎使用该权限。 CannedAccessControlList.PublicReadWrite

以下代码用于设置一个存储空间的访问权限:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request实例;
 PutBucketACLRequest request = new PutBucketACLRequest("<Bucket>");

//4.设置存储空间的控制访问权限(ACL),此处以“私有”为例,详情可参考5.3中给出的ACL分类说明表格;
request.setCannedAcl(CannedAccessControlList.Private);

//5.设置存储空间的访问权限,可登陆金山云控制台查看对应Bucket的访问权限,或者参考5.4获取Bucket控制访问权限信息;
client.putBucketACL(request);

以下代码用于自定义存储空间的访问权限:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request实例;
PutBucketACLRequest request = new PutBucketACLRequest("<Bucket>");

//4.创建一个ACL实例;
AccessControlList acl = new AccessControlList();

//5.自定义存储空间的权限
//5.1设置用户id为XXXX的用户对bucket有读权限;
    /**
    Grant grant1 = new Grant();
    grant1.setGrantee(new GranteeId("XXXX"));
    grant1.setPermission(Permission.Read);
    acl.addGrant(grant1);
    request.setAccessControlList(acl);
    client.putBucketACL(request);
    */
//5.2设置用户id为XXXX的用户对bucket完全控制
    /**
    Grant grant2 = new Grant();
    grant2.setGrantee(new GranteeId("XXXX"));
    grant2.setPermission(Permission.FullControl);
    acl.addGrant(grant2);
    request.setAccessControlList(acl);
    client.putBucketACL(request);
    */
//5.3.设置用户id为XXXX的用户对bucket有写权限
    /**
    Grant grant3 = new Grant();
    grant3.setGrantee(new GranteeId("XXXX"));
    grant3.setPermission(Permission.Write);
    acl.addGrant(grant3);
    request.setAccessControlList(acl);
    client.putBucketACL(request);
    */

说明:

7、获取Bucket权限

以下代码用于获取Bucket权限:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个result对象并获取bucket是否存在和读写权限信息;
HeadBucketResult result = client.headBucket("<Bucket>");
result.getStatueCode();

//4.在控制台打印输出结果,若状态字为200则表示成功,若状态字为403表示当前用户没有权限访问这个bucket;
System.out.println( "返回结果为: "+result.getStatueCode());

说明:

  • 关于获取Bucket信息的详细说明,请参考HEAD Bucket文档。
  • 关于获取Bucket控制访问权限的详细说明,请参考Get Bucket Policy文档。
  • 关于返回的错误码的详细说明,请参考错误码列表

8、为Bucket配置日志

KS3提供为Bucket配置日志的功能,当Bucket被赋予该功能后,KS3将自动把Bucket和Bucket下的Object的操作日志存储到指定的空间中。

以下代码用于为Bucket配置日志:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象;
PutBucketLoggingRequest request = new PutBucketLoggingRequest("<Bucket>");

//4.开启日志;
request.setEnable(true);
request.setTargetBucket("<存放日志文件的bucket名称>");

//5.设置日志文件的前缀为logging-;
request.setTargetPrefix("logging-");

//6.创建日志,可登陆金山云控制台查看空间日志设置详情;
client.putBucketLogging(request);

说明:

  • 设置日志的详细说明请参考PUT Bucket logging文档。
  • 存放日志文件的Bucket必须是当前用户同一个Region的Bucket。
  • 要配置日志的Bucket和存放日志文件的Bucket可以是同一个Bucket,但是为了用户方便管理,建议使用两个不同的Bucket。
  • 日志的生效时间为当日的24:00。

9、获取Bucket的日志配置

以下代码用于获取Bucket的日志信息:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.获取日志,由于KS3暂时不支持日志权限,所以返回的BucketLoggingStatus中targetGrants始终为空集合;
BucketLoggingStatus logging = client.getBucketLogging("<Bucket>");

//4.在控制台打印输出日志详情;
System.out.println( "返回的日志为:  "+logging);

说明:

  • 关于获取存储空间日志详细说明,请参考GET Bucket logging文档。
  • 由于KS3暂时不支持日志权限,所以返回的BucketLoggingStatus中targetGrants始终为空集合。

10、设置Bucket的CORS跨域规则

跨域资源共享(Cross-Origin Resource Sharing,简称 CORS),是 HTML5 提供的标准跨域解决方案。CORS允许WEB端的应用程序访问不属于本域的资源。

以下代码用于设置Bucket的CORS跨域规则:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.初始化一个CORS配置对象;
BucketCorsConfiguration config1 = new BucketCorsConfiguration();

//4.创建一个资源跨域共享规则对象;
CorsRule rule1 = new CorsRule();

//5.指定允许的跨域请求方法(GET/PUT/DELETE/POST/HEAD) ,可以根据实际需求更改关键字;
List<AllowedMethods> allowedMethods = new ArrayList<AllowedMethods>();
allowedMethods.add(AllowedMethods.GET);
rule1.setAllowedMethods(allowedMethods);

//6.指定允许跨域请求的来源 ,例如http://www.XXXX.com/;
List<String> allowedOrigins = new ArrayList<String>();
allowedOrigins.add("http://www.XXXX.com/");
rule1.setAllowedOrigins(allowedOrigins);

//7.指定允许用户从应用程序中访问的响应头,例如“x-kss-test1”;
List<String> exposedHeaders = new ArrayList<String>();
exposedHeaders.add("x-kss-test1");
rule1.setExposedHeaders(exposedHeaders);

//8.控制在 OPTIONS 预取指令中 Access-Control-Request-Headers 头中指定的 header 是否允许。
List<String> allowedHeaders = new ArrayList<String>();
allowedHeaders.add("x-kss-test"); 
rule1.setAllowedHeaders(allowedHeaders);

//9.指定浏览器对特定资源的预取(OPTIONS)请求返回结果的缓存时间,单位为秒。 
rule1.setMaxAgeSeconds(200);

//10.创建CORS跨域规则,可登陆金山云控制台查看指定的存储空间下的CORS规则详情;
config1.addRule(rule1);
PutBucketCorsRequest request = new PutBucketCorsRequest("<Bucket>",config1);
client.putBucketCors(request);
System.out.println( "配置成功");

以下代码用于同时设置存储空间GET和POST请求的CORS跨域规则:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.初始化一个CORS配置对象;
BucketCorsConfiguration config1 = new BucketCorsConfiguration();

//4.创建一个资源跨域共享规则对象;
CorsRule rule2 = new CorsRule();

//5.指定允许的跨域GET、POST请求方法,可以根据实际需求更改关键字;
List<AllowedMethods> allowedMethods2 = new ArrayList<AllowedMethods>();
allowedMethods2.add(AllowedMethods.GET);
allowedMethods2.add(AllowedMethods.POST);
rule2.setAllowedMethods(allowedMethods2);

//6.指定允许跨域请求的来源 ,例如http://www.XXXX.com/;
List<String> allowedOrigins2 = new ArrayList<String>();
allowedOrigins2.add("http://example.com");
allowedOrigins2.add("http://*.example.com");
rule2.setAllowedOrigins(allowedOrigins2);

//7.指定允许用户从应用程序中访问的响应头,例如“x-kss-test1”;
List<String> exposedHeaders2 = new ArrayList<String>();
exposedHeaders2.add("x-kss-test1");
exposedHeaders2.add("x-kss-test2");
rule2.setExposedHeaders(exposedHeaders2);

//8.控制在 OPTIONS 预取指令中 Access-Control-Request-Headers 头中指定的 header 是否允许。
List<String> allowedHeaders2 = new ArrayList<String>();
allowedHeaders2.add("x-kss-test"); 
allowedHeaders2.add("x-kss-test2"); 
rule2.setAllowedHeaders(allowedHeaders2);

//9.指定浏览器对特定资源的预取(OPTIONS)请求返回结果的缓存时间,单位为秒。
rule2.setMaxAgeSeconds(500);

//10.创建CORS跨域规则,可登陆金山云控制台查看指定的存储空间下的CORS规则详情,或者参考5.10获取Bucket的CORS跨域规则;
config1.addRule(rule2);
PutBucketCorsRequest request = new PutBucketCorsRequest("<Bucket>",config1);
client.putBucketCors(request);
System.out.println( "配置成功");

说明:

  • 一个Bucket可以最多配置10条CORS跨域规则。

  • CORS是指跨域资源共享,当使用javascript进行跨域的时候,需要为bucket配置该规则,详请参考情W3C文档

  • AllowedMethods、AllowedHeaders和AllowedOrigins为必选参数。AllowedHeaders和AllowedOrigins中支持最多一个*号的通配,更多设置CORS跨域详细说明,请参考PUT Bucket CORS文档。

11、获取Bucket的CORS跨域规则

以下代码用于获取CORS跨域资源共享规则:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.初始化一个CORS跨域规则配置对象;
BucketCorsConfiguration config1= client.getBucketCors("<Bucket>");

//4.获取指定Bucket下的所有CORS跨域规则;
List<CorsRule> rules = config1.getRules();

//5.遍历获取到的所有CORS跨域规则;
for(CorsRule rule : rules){

//5.1获取控制在 OPTIONS 预取指令中 Access-Control-Request-Headers 头中指定的 header 是否允许;
rule.getAllowedHeaders();

//5.2获取允许的跨域请求方法(GET/PUT/DELETE/POST/HEAD); 
rule.getAllowedMethods();

//5.3获取允许跨域请求的来源; 
rule.getAllowedOrigins();

//5.4获取允许用户从应用程序中访问的响应头;
rule.getExposedHeaders();

//5.5获取浏览器对特定资源的预取(OPTIONS)请求返回结果的缓存时间,单位为秒; 
rule.getMaxAgeSeconds();

//5.6在控制台逐个打印输出获取的CORS跨域规则参数;
System.out.println( "header:"+ rule.getAllowedHeaders());
System.out.println( "请求方法:"+ rule.getAllowedMethods());
System.out.println( "请求来源 :"+ rule.getAllowedOrigins());
System.out.println( "允许访问的响应头 :"+ rule.getExposedHeaders());
System.out.println( "缓存时间 :"+ rule.getMaxAgeSeconds());
                            }

说明:

  • 关于获取CORS跨域资源共享规则的详细说明,请参考GET Bucket CORS文档。
  • 当Bucket下无CORS跨域规则时,返回空集。

12、删除Bucket的CORS跨域规则

以下代码用于删除Bucket的CORS跨域规则:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.删除指定Bucket下的所有CORS跨域规则,可登陆金山云控制台查看指定Bucket下的CORS跨域规则详情,或者参考5.10获取Bucket的CORS跨域规则;
client.deleteBucketCors("<Bucket>");
System.out.println( "CORS规则删除成功!");

说明:

  • 关于更多删除CORS跨域规则的详细说明,请参考DELETE Bucket CORS文档。

六、文件(object)相关

本节主要介绍有关文件(Object)相关的KS3 Java SDK操作。

1、文件上传

KS3 Java SDK提供了丰富的文件上传方式:

  • 简单上传:包括本地上传和流式上传;
  • 表单上传:最大不能超过5G;
  • 分片上传:适用于大文件上传;

1.1 简单上传

  • 上传Byte数组

以下代码用于上传Byte数组:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个meta对象;
ObjectMetadata meta = new ObjectMetadata();

//4.输入要上传的内容,content为要输入的bety数;
byte[] content = "<上传的内容>".getBytes(); 
PutObjectRequest request = new PutObjectRequest("<Bucket>","<key>",new ByteArrayInputStream(<content>),meta);

//5.请指定输入流长度防止jvm内存溢出;
//meta.setContentLength(1000);

//6.上传Byte数组;
client.putObject(request);
System.out.println("上传成功!");

  • 上传网络流

以下代码用于上传网络流:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个meta对象;
 ObjectMetadata meta = new ObjectMetadata();

try {
//4.请填写完整的URL链接,通过URL+URLConnection来创建Http服务连接,进行数据通信;
URL url = new URL("<URL链接>");
URLConnection urlConnection = url.openConnection();
urlConnection.setDoInput(true);
InputStream inputStream = urlConnection.getInputStream();

//5.创建一个request对象;
PutObjectRequest request = new PutObjectReques("<Bucket>","<Object>", inputStream,meta);

//6.为了防止jvm内存溢出,请指定输入流长度
//meta.setContentLength(1000);

//7.上传网络流;
client.putObject(request);
System.out.println("上传成功!");

    } catch (IOException e) {
        return;
    }

  • 上传文件流

以下代码用于上传文件流:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个meta对象;
ObjectMetadata meta = new ObjectMetadata();

try {
    //4.请填写完整的文件路径;
    File file = new File("<filePath>");
    InputStream  InputStream=new FileInputStream(file);

    //5.创建一个request对象;
    PutObjectRequest request = new PutObjectRequest("<Bucket>","<key>", InputStream,meta);

    //6.请指定输入流长度防止jvm内存溢出;
    //meta.setContentLength(1000);

    //7.上传文件流;
    client.putObject(request);
    System.out.println("上传成功!");
    } catch (IOException e) {
        return;
    }

  • 上传本地文件

以下代码用于上传本地文件:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象,本地文件是由路径加文件名包括后缀组成,例如:/users/local/myfile.txt;
PutObjectRequest request = new PutObjectRequest("<Bucket>",
    "<key>", new File("<filePath>"));

//4.设置文件的ACL访问权限;
request.setCannedAcl(CannedAccessControlList.PublicRead);

//5.上传文件;
client.putObject(request);
System.out.println("文件上传成功!");

  • 创建文件夹

以下代码用于创建文件夹:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象,此处文件夹由“FolderName”+“/”组成,FilePath由本地文件路径加文件名包括后缀组成,例如:/users/local/myfile.txt;
PutObjectRequest request = new PutObjectRequest("<Bucket>",
    "FolderName/", new File("<FilePath>"));

//4.执行操作
client.putObject(request);
System.out.println("文件夹创建成功!");

  • 上传时指定原信息

以下代码用于上传时指定元信息:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象,FilePath由本地文件路径加文件名包括后缀组成,例如:/users/local/myfile.txt;
PutObjectRequest request = new PutObjectRequest("<Bucket>", "<key>", new File("<FilePath>"));

//4.创建一个meta对象,设置元数据的头部key、value值;
ObjectMetadata meta = new ObjectMetadata();
meta.setUserMeta("x-kss-meta-example", "example");

//5.上传文件;
request.setObjectMeta(meta);
client.putObject(request);
System.out.println("元数据设置、上传成功!");

  • 上传时指定上传协议

以下代码用于上传时指定上传协议:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象,FilePath由本地文件路径加文件名包括后缀组成,例如:/users/local/myfile.txt;
PutObjectRequest request = new PutObjectRequest("<Bucket>", "<key>", new File("<FilePath>"));

//4.创建一个meta对象,设置了Content-Type,建议根据文件实际类型做相应设置,方便浏览器识别。
ObjectMetadata meta = new ObjectMetadata();
meta.setContentType("text/html");

//5.上传文件;
request.setObjectMeta(meta);
client.putObject(request);
System.out.println("上传成功!");

  • 上传时指定文件类型

以下代码用于上传时指定文件类型:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象,此处填写的key值加上文件名类型例如:Test/XXXX.docx;本地文件是由路径加文件名包括后缀组成,例如:/users/local/myfile.txt;
PutObjectRequest request = new PutObjectRequest("<Bucket>",
    "<key>", new File("<filePath>"));

//4.上传文件;
client.putObject(request);
System.out.println("文件上传成功!");

说明:

  • 关于文件上传的详细说明请查看PUT Object文档。
  • 大文件请通过API进行分片上传,详情请见1.3分片上传。

1.2 表单上传文件

  • 表单上传

第一步:在KS3控制台->空间设置->配置CORS跨域规则。例如:

第二步:以下代码在JAVA SDK中使用,用于获取policy和Signature:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);     

//3.初始化一个postData对象,对于用户可以确定表单值的放在 postData中;
Map<String,String> postData = new HashMap<String,String>();

//4.设置ACL,且值要与js SDK中保持一致,否则删除下面一行代码;
postData.put("acl","public-read");

//5.输入key值,且值要与js SDK中保持一致;
postData.put("key","PostObject/filed1.docx");

//6.初始化一个unknowValueField对象,对于用户无法确定表单值的放在unknownValueField中(比如有的上传控件会添加一些表单项,但表单项的值可能是随机的);
List<String> unknowValueField = new ArrayList<String>();

//7.js sdk上传的时候会自动加上一个name的表单项,此处也需要保持一致;
unknowValueField.add("name");

//8.如果计算签名时提供的key里不包含${filename}占位符,可以把第二个参数传一个空字符串。因为计算policy需要的key是把${filename}进行替换后的key。
PostObjectFormFields fields = client.postObject("<Bucket>", "<key>", postData, unknowValueField);

//9.在打印控制台上输出Policy和Signature,请保存该信息以便于在js sdk中使用;
System.out.println("fields : "+fields);
System.out.println("KssAccessKeyId : "+fields.getKssAccessKeyId());
System.out.println("Policy : "+fields.getPolicy());
System.out.println("Signature : "+fields.getSignature());

第三步:下载js sdk文档

第四步:打开js文件夹下的ks3jssdk.js文件,根据提示填写信息(建议不要直接复制),如下图所示:

(function KS3JsSDK (win) {
var ks3FileUploader = function(ks3PostOptions, pluploadOptions){
this.defaultKS3Options  = {
//1.输入在第二步中,使用java sdk获得的KSSAccessKeyId;
KSSAccessKeyId: "",

//2.输入在第二步中,使用java sdk获得的policy;
policy: "",

//3.输入在第二步中,使用java sdk获得的signature;
signature: "", 

//4.填写Bucket;
bucket_name: "",

//5.填写上传键值的名称。如果用户想要使用文件名作为键值,可以使用${filename} 变量。例如:如果用户想要上传文件local.jpg,需要指明specify /
key: "",

//6.上传文件访问权限,与java sdk中保持一致
acl: "", 

//7.上传域名,http://destination-bucket.kss.ksyun.com 或者 http://kssws.ks-cdn.com/destination-bucket
uploadDomain: "", 

autoStart: false, //是否在文件添加完毕后自动上传
onInitCallBack: function(){}, //上传初始化时调用的回调函数
onErrorCallBack: function(){}, //发生错误时调用的回调函数
onFilesAddedCallBack: function(){}, //文件添加到浏览器时调用的回调函数
onBeforeUploadCallBack: function(){}, //文件上传之前时调用的回调函数
onStartUploadFileCallBack: function(){}, //文件开始上传时调用的回调函数
onUploadProgressCallBack: function(){}, //上传进度时调用的回调函数
onFileUploadedCallBack: function(){}, //文件上传完成时调用的回调函数
onUploadCompleteCallBack: function(){} //所有上传完成时调用的回调函数
    };

第五步:打开js文件夹下的main.js文件,根据提示填写信息,请请参考以下代码:

//1.请替换为您的AK;
Ks3.config.AK = '';

//2.填写您的SK;
Ks3.config.SK = ''; 

//3.填写Bucket所在的region;如果region设置和实际不符,则会返回301状态码;
Ks3.config.region = 'BEIJING';

//4.填写Bucket名称,请与java sdk中的信息保持一致;
Ks3.config.bucket = '<Bucket>';
var bucketName = Ks3.config.bucket; 

var policy = {
//1。expiration用于指定策略的过期时间,即只能在指定时间之前进行上传,在这个时间之后的上传都将被认为是非法的,KS3将返回403。注意:时区为格林时间(零时区)而非北京时间(东八区),此处暂时设置为一小时后;
"expiration": new Date(getExpires(3600)*1000).toISOString(), 

//2.Policy文档中对上传内容的验证条件。您在表单中指定的每个表单字段(KSSAccessKeyId、Signature、file、policy除外)以及bucket必须包含在条件列表中,此处可以自定义原信息、上传协议、文件类型,但请与java sdk中的postData.put("","")方法。
"conditions": [
        ["eq","$bucket", bucketName],
        ["starts-with", "$key", "key"],
        ["starts-with","$acl", "与java sdk中保持一致"],
        ["starts-with", "$name", "name"],   //表单中传了name字段,也需要加到policy中
        ["starts-with", "$x-kss-meta-custom-param1",""],
        ["starts-with", "$x-kss-newfilename-in-body",""],//必须只包含小写字符
        ["starts-with", "$Cache-Control",""],
        ["starts-with", "$Expires", ""],
        ["starts-with", "$Content-Disposition", ""],
        ["starts-with", "$Content-Type",""],
        ["starts-with", "$Content-Encoding",""]
    ]
};

第六步:打开demo文件夹下的index文件,开始上传文件。

  • 上传时指定文件类型

    由于指定文件类型、指定原信息、指定上传协议的操作类似,且改动步骤简单,请参考指定文件类型操作,其他方法不再赘述。

第一步:在KS3控制台->空间设置->配置CORS跨域规则。例如:

第二步:以下代码在JAVA SDK中使用,用于获取policy和Signature:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);     

//3.初始化一个postData对象,对于用户可以确定表单值的放在 postData中;
Map<String,String> postData = new HashMap<String,String>();

//4.设置ACL,且值要与js SDK中保持一致,否则删除下面一行代码;
postData.put("acl","public-read");

//5.配置上传文件类型
postData.put("Content-Type","");
//配置原信息
//postData.put("x-kss-meta-custom-param1","public-read");   

//6.输入key值,且值要与js SDK中保持一致;
postData.put("key","PostObject/filed1.docx");

//7.初始化一个unknowValueField对象,对于用户无法确定表单值的放在unknownValueField中(比如有的上传控件会添加一些表单项,但表单项的值可能是随机的);
List<String> unknowValueField = new ArrayList<String>();

//8.js sdk上传的时候会自动加上一个name的表单项,此处也需要保持一致;
unknowValueField.add("name");

//9.如果计算签名时提供的key里不包含${filename}占位符,可以把第二个参数传一个空字符串。因为计算policy需要的key是把${filename}进行替换后的key。
PostObjectFormFields fields = client.postObject("<Bucket>", "<key>", postData, unknowValueField);

//10.在打印控制台上输出Policy和Signature,请保存该信息以便于在js sdk中使用;
System.out.println("fields : "+fields);
System.out.println("KssAccessKeyId : "+fields.getKssAccessKeyId());
System.out.println("Policy : "+fields.getPolicy());
System.out.println("Signature : "+fields.getSignature());

第三步:下载js sdk文档

第四步:打开js文件夹下的ks3jssdk.js文件,根据提示填写信息(建议不要直接复制),如下图所示:

(function KS3JsSDK (win) {
var ks3FileUploader = function(ks3PostOptions, pluploadOptions){
this.defaultKS3Options  = {
//1.输入在第二步中,使用java sdk获得的KSSAccessKeyId;
KSSAccessKeyId: "",

//2.输入在第二步中,使用java sdk获得的policy;
policy: "",

//3.输入在第二步中,使用java sdk获得的signature;
signature: "", 

//4.填写Bucket;
bucket_name: "",

//5.填写上传键值的名称。如果用户想要使用文件名作为键值,可以使用${filename} 变量。例如:如果用户想要上传文件local.jpg,需要指明specify /
key: "",

//6.上传文件访问权限,与java sdk中保持一致
acl: "", 

//7.上传域名,http://destination-bucket.kss.ksyun.com 或者 http://kssws.ks-cdn.com/destination-bucket
uploadDomain: "", 

autoStart: false, //是否在文件添加完毕后自动上传
onInitCallBack: function(){}, //上传初始化时调用的回调函数
onErrorCallBack: function(){}, //发生错误时调用的回调函数
onFilesAddedCallBack: function(){}, //文件添加到浏览器时调用的回调函数
onBeforeUploadCallBack: function(){}, //文件上传之前时调用的回调函数
onStartUploadFileCallBack: function(){}, //文件开始上传时调用的回调函数
onUploadProgressCallBack: function(){}, //上传进度时调用的回调函数
onFileUploadedCallBack: function(){}, //文件上传完成时调用的回调函数
onUploadCompleteCallBack: function(){} //所有上传完成时调用的回调函数
    };

第五步:打开js文件夹下的main.js文件,根据提示填写信息,请请参考以下代码:

//1.请替换为您的AK;
Ks3.config.AK = '';

//2.填写您的SK;
Ks3.config.SK = ''; 

//3.填写Bucket所在的region;如果region设置和实际不符,则会返回301状态码;
Ks3.config.region = 'BEIJING';

//4.填写Bucket名称,请与java sdk中的信息保持一致;
Ks3.config.bucket = '<Bucket>';
var bucketName = Ks3.config.bucket; 

var policy = {
//1。expiration用于指定策略的过期时间,即只能在指定时间之前进行上传,在这个时间之后的上传都将被认为是非法的,KS3将返回403。注意:时区为格林时间(零时区)而非北京时间(东八区),此处暂时设置为一小时后;
"expiration": new Date(getExpires(3600)*1000).toISOString(), 

//2.Policy文档中对上传内容的验证条件。您在表单中指定的每个表单字段(KSSAccessKeyId、Signature、file、policy除外)以及bucket必须包含在条件列表中,此处可以自定义原信息、上传协议、文件类型,但请与java sdk中的postData.put("","")方法。
"conditions": [
        ["eq","$bucket", bucketName],
        ["starts-with", "$key", "key"],
        ["starts-with","$acl", "与java sdk中保持一致"],
        ["starts-with", "$name", "name"],   //表单中传了name字段,也需要加到policy中
        ["starts-with", "$x-kss-meta-custom-param1",""],//如果在java sdk中配置了原信息,请填写该行,且与java sdk中保持一致;
        ["starts-with", "$x-kss-newfilename-in-body",""],//必须只包含小写字符
        ["starts-with", "$Cache-Control",""],
        ["starts-with", "$Expires", ""],
        ["starts-with", "$Content-Disposition", ""],
        ["starts-with", "$Content-Type",""],//如果在java sdk中配置了上传文件类型,请填写该行,且与java sdk保持一致;
        ["starts-with", "$Content-Encoding",""]
    ]
};

第六步:打开demo文件夹下的index文件,开始上传文件。

说明:

  • 上传时,浏览器一共会发送两个请求,第一个为OPTIONS请求,第二个为POST请求。如果第一个请求返回403,请检测CORS配置是否正确。如果第二个请求返回403,请检查生成policy时,是否完全按照表单内容生成。或者把policy进行base64解码,对比表单内容是否正确。
  • 了解KS3表单上传协议详细说明,请参考POST Object文档。
  • 表单上传签名认证方式详细说明,请参考Policy Signature构建方法

1.3 分片上传

使用分块上传,文件小于5M时,除了最后一块的其他块大小应不小于100K;文件大于5M时,除了最后一块的其他块大小应不小于5M且不大于5G。上传分为三步:

1、Initiate Multipart Upload 初始化分片上传

2、Upload Part 上传文件块

3、Complete Multipart Upload 完成分片上传

上传中,你可以使用Abort Multipart Upload取消上传,或者List Parts查看上传的分块。或者List Multipart Uploads查看当前的bucket下有多少个uploadid,详细说明请参考分片上传文档。

  • 分片上传

以下代码用于初始化分片上传:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3、创建一个初始化上传对象request,填写上传的存储空间和文件名;
InitiateMultipartUploadRequest request = new InitiateMultipartUploadRequest( "<Bucket>","<key>");

//4、设置Object的ACL权限,此处设置为公开读;
request.setCannedAcl(CannedAccessControlList.PublicRead);

//5、执行初始化分片上传操作,并返回UploadID。请保存该UploadId,以便后续使用。
InitiateMultipartUploadResult result = client.initiateMultipartUpload(request);
result.getUploadId();
System.out.println("UploadId值: "+result.getUploadId());

以下代码用于上传文件块和完成上传:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3、创建一个file类型的文件,填写要上传文件的本地地址,例如:D://22/22.zip;
File file =new File("<FilePath>");
List<PartETag> parts = new ArrayList<PartETag>();

//4、创建一个request对象,填写分片上传的基本信息,使用循环调用API上传文件;
//注意:上传的文件大小应换算成Byte数;
for(int i=1;i<=7;i++) {
UploadPartRequest request = new UploadPartRequest( "<Bucket>"," <key>","<UploadId>",i,file, partsize,fileoffset);

//指定内容的MD5值以便于在服务端进行MD5校验查看上传文件的完整性,否则程序只会在客户端进行MD5校验;
//request.setContentMD5("yE0ZQBpRgPrLSDEe6fGAvg==");  

//5、执行上传操作;
PartETag result = client.uploadPart(request);    
System.out.println("获取到的uploadid "+result);

//6、根据获取到的Etag值和partNumber,拼接所有的块;
parts.add(result);
    }

//7、填写完成分片上传的基本信息;
CompleteMultipartUploadRequest request = new CompleteMultipartUploadRequest( "<Bucket>","<key>","<UploadId>", parts);

//8、完成分片上传操作;
client.completeMultipartUpload(request);

以下代码用于上传分片块:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3、创建一个file类型的文件,填写要上传文件的本地地址;
    File file =new File("D://22/22.zip");

//4、创建一个request对象,填写分片上传的基本信息。
//注意:上传的文件大小应换算成Byte数;
for(int i=1;i<=<MAXpartNumber>;i++) {
     UploadPartRequest request = new UploadPartRequest( "<Bucket>"," <key>","<UploadId>",i,file, partsize,fileoffset);

//指定内容的MD5值以便于在服务端进行MD5校验查看上传文件的完整性,否则程序只会在客户端进行MD5校验。
//request.setContentMD5("yE0ZQBpRgPrLSDEe6fGAvg==");  

//5、执行上传操作;
PartETag result = client.uploadPart(request);    
System.out.println("获取到的uploadid "+result);

    }

以下代码用于完成分片上传:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3、获取已上传的文件块的所有ETag,合并所有的块;
List<PartETag> parts = new ArrayList<PartETag>(); 
for(int i=1;i<=MAXpartNumber;i++) {
PartETag f=new PartETag(i,"<ETage>");
parts.add(f);
    }

//4、填写完成分片上传的基本信息;
CompleteMultipartUploadRequest request = new CompleteMultipartUploadRequest( "<Bucket>"," <key>","<UploadId>", parts);

//5、完成分片上传操作;
client.completeMultipartUpload(request);
  • 上传时指定原信息

以下代码用于初始化分片上传时指定原信息:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3、创建一个初始化上传对象request,填写上传的存储空间和文件名;
InitiateMultipartUploadRequest request = new InitiateMultipartUploadRequest( "<Bucket>","<key>");

//4、设置Object的ACL权限,此处设置为公开读;
request.setCannedAcl(CannedAccessControlList.PublicRead);

//5、设置将要上传的object的用户元数据。当下载文件的时候,返回的header中将会带上设置的用户元数据。
ObjectMetadata meta = new ObjectMetadata();
meta.setUserMeta("x-kss-meta-example", "example");
request.setObjectMeta(meta);

//6、执行初始化分片上传操作,并返回UploadID。请保存该UploadId,以便后续使用。
InitiateMultipartUploadResult result = client.initiateMultipartUpload(request);
result.getUploadId();
System.out.println("UploadId值: "+result.getUploadId());
  • 上传时指定上传协议

以下代码用于初始化分片上传时指定上传协议:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3、创建一个初始化上传对象request,填写上传的存储空间和文件名;
InitiateMultipartUploadRequest request = new InitiateMultipartUploadRequest( "<Bucket>","<key>");

//4、设置Object的ACL权限,此处设置为公开读;
request.setCannedAcl(CannedAccessControlList.PublicRead);

//5、如果用户设置了Content-Type,那么在下载的时候,返回的header中将会带上Content-Type:{设置的值} 。建议根据文件实际类型做相应设置,方便浏览器识别。
ObjectMetadata meta = new ObjectMetadata();
meta.setContentType("text/html");
request.setObjectMeta(meta);

//6、执行初始化分片上传操作,并返回UploadID。请保存该UploadId,以便后续使用。
InitiateMultipartUploadResult result = client.initiateMultipartUpload(request);
result.getUploadId();
System.out.println("UploadId值: "+result.getUploadId());
  • 上传时指定文件类型

以下代码用于初始化分片上传时指定文件类型:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3、创建一个初始化上传对象request,填写上传的存储空间和文件名,设置上传文件的类型可以再key中加入后缀,例如xxxx.docx/xxxx.exe/xxxxx.zip等;
InitiateMultipartUploadRequest request = new InitiateMultipartUploadRequest( "<Bucket>","<key>");

//4、设置Object的ACL权限,此处设置为公开读;
request.setCannedAcl(CannedAccessControlList.PublicRead);

//5、执行初始化分片上传操作,并返回UploadID。请保存该UploadId,以便后续使用。
InitiateMultipartUploadResult result = client.initiateMultipartUpload(request);
result.getUploadId();
System.out.println("UploadId值: "+result.getUploadId());
  • 取消分片上传

以下代码用于取消分块上传:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.执行取消分片上传操作;
client.abortMultipartUpload(<bucketname>,<objectkey>, <uploadId>);
  • 罗列已经完成的分片上传块

以下代码用于罗列已经完成的分片上传块:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象;
ListPartsRequest request = new ListPartsRequest(<bucketname>,<objectkey>, <uploadId>);

//4.执行根据uploadid罗列已完成的上传块的ETag和 partNumber;
ListPartsResult tags = client.listParts(request);
    System.out.println("已经完成的分片上传块:"+tags);
  • 罗列正在进行的分片上传块

以下代码用于罗列正在进行的分片上传块:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象;
ListMultipartUploadsRequest request = new ListMultipartUploadsRequest("<Bucket>");

//4.keyMaker和uploadIdMarker一起使用:指定列举指定空间中正在进行分块上传任务的起始位置;
request.setKeyMarker("<keyMarker>");
request.setUploadIdMarker("<uploadIdMarker>");

//5.填写Delimiter和prefix,请参考给出的示例
request.setDelimiter("/");
request.setPrefix("prefix");

//6.最多返回100条记录,默认(最大)是1000;
request.setMaxUploads(100);
ListMultipartUploadsResult result = client.listMultipartUploads(request);
System.out.println("正在进行的分块上传: "+result);

说明:

1.4 上传回调

以下代码用于完成分片上传时设置回调:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.把上传块时返回的所有要合并的块按ETag拼接;
List<PartETag> parts = new ArrayList<PartETag>();        
for(int i=1;i<=< MaxpartNumber>;i++) {
PartETag f=new PartETag(i,"<ETage>");
parts.add(f);
    }
CompleteMultipartUploadRequest request = new CompleteMultipartUploadRequest( "<Bucket>"," <key>","<UploadId>", parts);

//4.完成分片上传操作;
CallBackConfiguration config1= new CallBackConfiguration();

config1.setCallBackUrl("http://10.4.2.38:19090/");//KS3服务器回调的地址

//5.以下为KS3服务器访问http://10.4.2.38:19090/时body中的参数

Map<String,MagicVariables> magicVariables = new HashMap<String,MagicVariables>();

magicVariables.put("bucket", MagicVariables.bucket);

magicVariables.put("createTime", MagicVariables.createTime);

magicVariables.put("etag", MagicVariables.etag);

magicVariables.put("key", MagicVariables.key);

magicVariables.put("mimeType", MagicVariables.mimeType);

magicVariables.put("objectSize", MagicVariables.objectSize);

config1.setBodyMagicVariables(magicVariables);

//6.用户可以自己定义返回的参数。

Map<String,String> kssVariables = new HashMap<String,String>();

kssVariables.put("time", "20150222");

request.setCallBackConfiguration(config1);

//7.完成分片上传操作;
client.completeMultipartUpload(request);

2、文件下载

2.1 下载到本地文件

以下代码用于下载到本地文件:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象     
GetObjectRequest request = new GetObjectRequest("<Bucket>","<key>");

//4.获取文件
GetObjectResult result = client.getObject(request);
Ks3Object object = result.getObject();
BufferedReader reader = new BufferedReader(new InputStreamReader(object.getObjectContent()));

//5.指定本地存放路径,并创建文件
File f = new File("<FilePath>");
try {
    f.createNewFile();
    } catch (IOException e) {
    // TODO 自动生成的 catch 块
    e.printStackTrace();
    }

//6.将文件保存至本地;
try {
FileOutputStream fos =new FileOutputStream(f);
String str; 
try {
        while(true) {
        str = reader.readLine();
        if (str == null) break;
        for(int i=0;i<str.length();i++) {
            int b=(int)str.charAt(i);   
            fos.write(b);   
        }
        }
        fos.close();
         } catch (IOException e) {
        // TODO 自动生成的 catch 块
        e.printStackTrace();
    }       
    } catch (FileNotFoundException e) {
    // TODO 自动生成的 catch 块
    e.printStackTrace();
    }

2.2 流式下载

以下代码用于流式下载:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象
    GetObjectRequest request = new GetObjectRequest("<Bucket>","<key>");

//4.获取object的输入流
GetObjectResult result = client.getObject(request);
Ks3Object object = result.getObject();

//5.在控制台显示文本文件内容;
BufferedReader reader = new BufferedReader(new InputStreamReader(object.getObjectContent()));
while (true) {
    String line;
    try {
            line = reader.readLine();
            if (line == null) break;
            System.out.println("\n" + line);

        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
    }   
    try {
        reader.close();
    } catch (IOException e) {
        // TODO 自动生成的 catch 块
        e.printStackTrace();
    }

2.3 范围下载

以下代码用于范围下载:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象     
GetObjectRequest request = new GetObjectRequest("<Bucket>","<key>");

//4.获取0~1000字节范围内的数据,包括0和1000,共1001个字节的数据。如果指定的范围无效(比如开始或结束位置的指定值为负数,或指定值大于文件大小),则下载整个文件。
request.setRange(0,1000);

//5.获取文件
GetObjectResult result = client.getObject(request);
Ks3Object object = result.getObject();
BufferedReader reader = new BufferedReader(new InputStreamReader(object.getObjectContent()));

//6.指定本地存放路径,并创建文件
File f = new File("<FilePath>");
try {
    f.createNewFile();
    } catch (IOException e) {
    // TODO 自动生成的 catch 块
    e.printStackTrace();
    }

//7.将文件保存至本地;
try {
FileOutputStream fos =new FileOutputStream(f);
String str; 
try {
        while(true) {
        str = reader.readLine();
        if (str == null) break;
        for(int i=0;i<str.length();i++) {
            int b=(int)str.charAt(i);   
            fos.write(b);   
        }
        }
        fos.close();
         } catch (IOException e) {
        // TODO 自动生成的 catch 块
        e.printStackTrace();
    }       
    } catch (FileNotFoundException e) {
    // TODO 自动生成的 catch 块
    e.printStackTrace();
    }

3.文件管理

3.1 判断文件是否存在

以下代码用于判断文件是否存在:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象,查找指定的存储空间下的文件是否存在;
try {
      HeadObjectRequest request = new HeadObjectRequest("<Bucket>","key");
      client.headObject(request);
      System.out.println("存在该文件");
    } catch (NotFoundException e) {
        System.out.println("该文件不存在");
    }

3.2 获取文件的ACL

以下代码用于获取文件的ACL:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config); 

//3.填写存储空间和文件名,将该文件的权限输出打印;
AccessControlPolicy policy = client.getObjectACL("<bucket名称>","<objectkey>");
System.out.println("返回的文件"+policy);

3.3 设置文件的ACL

以下代码用于设置文件的ACL:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象;
PutObjectACLRequest request = new PutObjectACLRequest("<bucket名称>","<objectkey>");

//4.1 设为私有
request.setCannedAcl(CannedAccessControlList.Private);

//4.2 设为公开读
//request.setCannedAcl(CannedAccessControlList.PublicRead);

//5.执行设置权限操作;
client.putObjectACL(request);

以下代码用于自定义文件访问权限:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象,填写存储空间和文件名称;
PutObjectACLRequest request = new PutObjectACLRequest("<bucket名称>","<objectkey>");
AccessControlList acl = new AccessControlList();

//4.1 设置用户id为12345678的用户对object的读权限
Grant grant1 = new Grant();
grant1.setGrantee(new GranteeId("12345678"));
grant1.setPermission(Permission.Read);
acl.addGrant(grant1);

//4.2 设置用户id为123456789的用户对object完全控制
Grant grant2 = new Grant();
grant2.setGrantee(new GranteeId("123456789"));
grant2.setPermission(Permission.FullControl);
acl.addGrant(grant2);

//4.3设置用户id为12345678910的用户对object的写权限
Grant grant3 = new Grant();
grant3.setGrantee(new GranteeId("12345678910"));
grant3.setPermission(Permission.Write);
acl.addGrant(grant3);

//5.执行权限设置操作;
request.setAccessControlList(acl);
client.putObjectACL(request);

3.4 设置文件的元信息

以下代码用于设置文件的元信息:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象,用于指定存储空间和其下的文件;
PutObjectRequest request = new PutObjectRequest("<Bucket>","<key>", new File("<FilePath>"));
ObjectMetadata meta = new ObjectMetadata();

//4.设置元数据的头部key、value值;
meta.setUserMeta("x-kss-meta-example", "example");

//5.如果用户设置了Content-Type,那么在下载的时候,返回的header中将会带上Content-Type:{设置的值} 。建议根据文件实际类型做相应设置,方便浏览器识别。
meta.setContentType("text/html");

//6.调用putObject接口,执行设置元信息操作;        
request.setObjectMeta(meta);
client.putObject(request);

3.5 获取文件的元信息

以下代码用于获取文件的元信息:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象,填写存储空间和文件;
HeadObjectRequest request = new HeadObjectRequest("<bucket名称>","<objectkey>");  

//4.head请求可以用于获取object的元数据
HeadObjectResult result = client.headObject(request);
result.getObjectMetadata();

//5.将请求结果打印输出在控制台:
//如果抛出{@link NotFoundException} 表示这个object不存在;
//如果抛出{@link AccessDinedException} 表示当前用户没有权限访问;
System.out.println("返回的文件的元数据为: "+result.getObjectMetadata());

3.6 删除文件

以下代码用于获取文件的元信息:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.输入指定的存储空间和文件名,执行删除文件操作;
client.deleteObject("<bucket名称>","<key>");

3.7 列举存储空间下的文件

以下代码用于获取文件的元信息:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个list对象,填写指定的Bucket;
ObjectListing list = client.listObjects("<Bucket>");

//4.将返回的Object信息打印输出在控制台,最多可返回10001条;
System.out.println( "该Bucket下的Object有: "+list);

3.8 列举指定目录下的文件

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

 //2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.新建一个ListObjectsRequest
ListObjectsRequest request = new ListObjectsRequest("<Bucket>");

//4.设置参数
request.setMaxKeys(10);//指定返回条数最大值
request.setPrefix("test");//返回以指定前缀开头的object
request.setDelimiter("·············");//设置文件分隔符,系统将根据该分隔符组织文件夹结构,默认是"/"

//5.执行操作
ObjectListing list = null;
list = client.listObjects(request);
System.out.println( "自定义筛选参数后Bucket下的Object有: "+list);

3.9 拷贝文件

  • 简单拷贝

以下代码用于简单拷贝文件:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.将sourceBucket这个存储空间下的sourceKey这个object复制到destinationBucket这个存储空间下,并命名为destinationBucket
CopyObjectRequest request = new CopyObjectRequest("<sourceBucket>","<sourceKey>","<destinationBucket>","<destinationBucket>");  

//4.执行复制文件操作;        
client.copyObject(request);
System.out.println("文件复制成功!");

说明:

  • 文件复制的时候,需要用户对源文件有读取权限,对目标bucket有写权限。
  • 如果目标文件已经存在,复制操作将会抛出400,对应的ErrorCode是 invalidKey。

七、授权管理

1、生成文件的下载外链地址

以下代码用于生成文件的下载外链地址:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个overrides对象,并设置ContentType;
ResponseHeaderOverrides overrides = new ResponseHeaderOverrides();
overrides.setContentType("text/html");

//4.在控制台打印输出外链地址;
System.out.println( "生成一个在1000秒后过期的外链: "+ client.generatePresignedUrl("zhousiyingkingsoft","kkkk",1000));

System.out.println( "生成一个1000秒后过期并重写返回的heade的外链: "+ client.generatePresignedUrl("<Bucket>","<key>",1000,overrides));

2、生成文件的上传外链地址

以下代码用于生成文件的上传外链地址:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个req对象;
GeneratePresignedUrlRequest req = new GeneratePresignedUrlRequest();
req.setMethod(HttpMethod.PUT);

//4.文件上传的bucket
req.setBucket("<Bucket>");

//5.请输入文件名
req.setKey("<key>");

//6.不指定的话则默认为15分钟后过期
req.setExpiration(null);

//7.设置acl为公开读,不加该header则默认为私有,生成外链时设置了header,则在使用外链的时候也需要添加相应的header
req.getRequestConfig().getExtendHeaders().put("x-kss-acl", "public-read");

//8.设置文件的Content-Type,具体值请根据时间情况设定。在使用外链的时候需要把Content-Type设置成指定的值;
req.setContentType("application/ocet-stream");

//9.将生成的外链输出至控制台;
System.out.println("返回的url为"+url);

3、生成签名URL

下载KS3可视化签名工具KS3可视化签名工具,阅读KS3可视化签名工具使用说明,直接通过可视化签名工具根据用户需求生成对应的生成签名URL。

4、使用签名URL上传文件

首先需要使用签名工具,根据您的SK生成一个Signare。然后在KS3 SDK中运行以下代码:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象,FilePath由本地文件路径加文件名包括后缀组成,例如:/users/local/myfile.txt;
PutObjectRequest request = new PutObjectRequest("<Bucket>", "<key>", new File("<Path>"));

//4.创建一个meta对象,在HTTP请求Header中添加Signare;
ObjectMetadata meta = new ObjectMetadata();
meta.setUserMeta("Authorization", "KSS   <您的SK>:<您获取到的Signare>");

//5.上传文件;
request.setObjectMeta(meta);
client.putObject(request);
System.out.println("上传成功!");

5、使用签名URL下载文件

通过签名工具中的通过URL Querystring发送的签名方法,填写相应的信息,直接生成getObject的签名URL,在网页中输入该URL后自动下载文件。

八、数据安全性

1、MD5检验

上传文件至KS3,为了确保文件的完整性,PUT方式上传时带上Content-MD5头部,KS3会计算收到的文件的MD5,并根据用户提供的MD5进行校验。

第一步:在客户端生成Content-MD5.

1、以下代码用于计算MD5值,在KS3 JAVA SDK中新建class(此处的类名为MD5Test),并添加以下代码:

package ksc.ks3;
import java.security.MessageDigest;
public class MD5Test {   
     public static String string2MD5(String inStr){
         MessageDigest md5 = null;  
        try{  
            md5 = MessageDigest.getInstance("MD5");  
        }catch (Exception e){  
             System.out.println(e.toString());  
             e.printStackTrace();  
             return "";  
         }  
         char[] charArray = inStr.toCharArray();  
         byte[] byteArray = new byte[charArray.length];  

         for (int i = 0; i < charArray.length; i++)  
             byteArray[i] = (byte) charArray[i];  
         byte[] md5Bytes = md5.digest(byteArray);  
         StringBuffer hexValue = new StringBuffer();  
         for (int i = 0; i < md5Bytes.length; i++){  
             int val = ((int) md5Bytes[i]) & 0xff;  
             if (val < 16)  
                 hexValue.append("0");  
             hexValue.append(Integer.toHexString(val));  
         }  
         return hexValue.toString();       
     }
}

2、在KS3 JAVA SDK的main函数中添加以下代码:

//1、添加要传输的内容;
String s1 = "<Content>";

//2、在控制台显示计算的Content-MD5值,相同内容MD5值不变,请保存该值以便上传文件时使用。
System.out.println("使用工具类进行加密的为 "+MD5Test.string2MD5(s1));

第二步:初始化分片上传。

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个初始化上传对象request,填写上传的存储空间和文件名;
InitiateMultipartUploadRequest request = new InitiateMultipartUploadRequest( "<Bucket>","<key>");

//4.设置Object的ACL权限,此处设置为公开读;
request.setCannedAcl(CannedAccessControlList.PublicRead);

//5.执行初始化分片上传操作,并返回UploadID。请保存该UploadId,以便后续使用。
InitiateMultipartUploadResult result = client.initiateMultipartUpload(request);
result.getUploadId();
System.out.println("UploadId值: "+result.getUploadId());

第三步:使用分片上传时添加MD5值,并且完成上传。

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个file类型的文件,填写要上传文件的本地地址,例如:D://22/22.zip;
File file =new File("<FilePath>");
List<PartETag> parts = new ArrayList<PartETag>();

//4.创建一个request对象,填写分片上传的基本信息,使用循环调用API上传文件;
//注意:上传的文件大小应换算成Byte数;
for(int i=1;i<=7;i++) {
UploadPartRequest request = new UploadPartRequest( "<Bucket>"," <key>","<UploadId>",i,file, partsize,fileoffset);

//5.填写获取的MD5值以便于在服务端进行MD5校验查看上传文件的完整性,否则程序只会在客户端进行MD5校验;
//request.setContentMD5("yE0ZQBpRgPrLSDEe6fGAvg==");  

//6.执行上传操作;
PartETag result = client.uploadPart(request);    
System.out.println("获取到的uploadid "+result);

//7.根据获取到的Etag值和partNumber,拼接所有的块;
parts.add(result);
    }

//8.填写完成分片上传的基本信息;
CompleteMultipartUploadRequest request = new CompleteMultipartUploadRequest( "<Bucket>","<key>","<UploadId>", parts);

//9.完成分片上传操作;
client.completeMultipartUpload(request);

2、服务端加密

以下代码用于上传文件时的服务端加密:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象,本地文件是由路径加文件名包括后缀组成,例如:/users/local/myfile.txt;
PutObjectRequest request = new PutObjectRequest("<Bucket>",
    "<key>", new File("<filePath>"));

//4.设置文件的ACL访问权限;
request.setCannedAcl(CannedAccessControlList.PublicRead);

//5、设置在服务端加密
ObjectMetadata meta = new ObjectMetadata();
meta.setSseAlgorithm("AES256");
request.setObjectMeta(meta);

//6.上传文件;
client.putObject(request);
System.out.println("文件上传成功!");

以下代码用于上传文件时设置用户提供key的服务端加密:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象,本地文件是由路径加文件名包括后缀组成,例如:/users/local/myfile.txt;
PutObjectRequest request = new PutObjectRequest("<Bucket>",
    "<key>", new File("<filePath>"));

//4.设置文件的ACL访问权限;
request.setCannedAcl(CannedAccessControlList.PublicRead);

//5.生成一个密钥;
KeyGenerator symKeyGenerator;
try {
    symKeyGenerator = KeyGenerator.getInstance("AES");
    symKeyGenerator.init(256); 
    SecretKey symKey = symKeyGenerator.generateKey();

//6.将密钥保存至本地,LoadPath为本地路径,例如:D:/22/aes.key;
    Path keyPath = Paths.get("<LoadPath>");  
    try {
        Files.write(keyPath, symKey.getEncoded());
        } catch (IOException e) {
            e.printStackTrace();
        }   
         SSECustomerKey ssec = new SSECustomerKey(symKey);
         System.out.println("ssec为:"+ssec);
         request.setSseCustomerKey(ssec);
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }

//7.执行上传文件操作;
client.putObject(request);    
System.out.println("加密上传成功!");

以下代码用于下载用户提供key的服务端加密的文件:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象 ,此处的key是上传文件时设置用户提供key的服务端加密后的Object;    
GetObjectRequest request = new GetObjectRequest("<Bucket>","<key>");

//4.读取秘钥,SecretKeyPath为该Object上传时保存的秘钥的本地路径,例如:D:/22/aes.key。
    Path keyPath = Paths.get("<SecretKeyPath>"); 

    byte[] keyBytes;
    try {
        keyBytes = Files.readAllBytes(keyPath);
        SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "AES"); 
        SecretKey sourceKey=keySpec;
        request.setSseCustomerKey(new SSECustomerKey(sourceKey));
    } catch (IOException e) {
        e.printStackTrace();
    }  
//5.获取文件;
    GetObjectResult result = client.getObject(request);
    Ks3Object object = result.getObject();
    BufferedReader reader = new BufferedReader(new InputStreamReader(object.getObjectContent()));

//6.指定本地存放路径,并创建文件。FilePath为本地路径,例如D:/22/密文下载.txt;
    File f = new File("<FilePath>");
    try {
        f.createNewFile();
        } catch (IOException e) {
        e.printStackTrace();
        }
//7.将文件保存至本地;
    try {
    FileOutputStream fos =new FileOutputStream(f);
    String str; 
    try {
            while(true) {
            str = reader.readLine();
            if (str == null) break;
            for(int i=0;i<str.length();i++) {
                int b=(int)str.charAt(i);   
                fos.write(b);   
            }
            }
            fos.close();
             } catch (IOException e) {
            e.printStackTrace();
        }       
        } catch (FileNotFoundException e) {
        e.printStackTrace();
        }
    System.out.println("下载成功!");

说明:

  • 如果用户使用了用户提供key的服务端加密,则下载文件的时候,必须提供加密使用的key,否则将无法下载。

3、客户端加密

  • 客户端对称加密上传文件

第一步:生成密钥

在KS3 SDK JAVA中新建GenerateSymmetricMasterKey类,添加以下代码:

package ksc.ks3;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.security.InvalidKeyException;

import java.security.NoSuchAlgorithmException;

import java.security.spec.InvalidKeySpecException;

import java.security.spec.X509EncodedKeySpec;

import java.util.Arrays;

import javax.crypto.KeyGenerator;

import javax.crypto.SecretKey;

import javax.crypto.spec.SecretKeySpec;

import org.junit.Assert;

public class GenerateSymmetricMasterKey {

//注意:在此处添加SecretkeyPath,用于将密钥保存至本地,例如:D:/22/
private static final String keyDir  = "<SecretkeyPath>"; 

private static final String keyName = "secret.key";

public static void main(String[] args) throws Exception {

    //Generate symmetric 256 bit AES key.

    KeyGenerator symKeyGenerator = KeyGenerator.getInstance("AES");

    symKeyGenerator.init(256); 

    SecretKey symKey = symKeyGenerator.generateKey();

    //Save key.

    saveSymmetricKey(keyDir, symKey);

    //Load key.

    SecretKey symKeyLoaded = loadSymmetricAESKey(keyDir, "AES");           

    Assert.assertTrue(Arrays.equals(symKey.getEncoded(), symKeyLoaded.getEncoded()));

}

public static void saveSymmetricKey(String path, SecretKey secretKey) 

    throws IOException {

    X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(

            secretKey.getEncoded());

    FileOutputStream keyfos = new FileOutputStream(path + "/" + keyName);

    keyfos.write(x509EncodedKeySpec.getEncoded());

    keyfos.close();

}

public static SecretKey loadSymmetricAESKey(String path, String algorithm) 

    throws IOException, NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException{

    //Read private key from file.

    File keyFile = new File(path + "/" + keyName);

    FileInputStream keyfis = new FileInputStream(keyFile);

    byte[] encodedPrivateKey = new byte[(int)keyFile.length()];

    keyfis.read(encodedPrivateKey);

    keyfis.close(); 

    //Generate secret key.

    return new SecretKeySpec(encodedPrivateKey, "AES");

}

}

第二步:在KS3 JAVA SDK的主函数中添加以下代码,用于客户端加密上传文件:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2、获取本地生成的密钥,SecretkeyPath为已经生成好的对称密钥,例如:D:/22/secret.key
Path keyPath = Paths.get("<SecretkeyPath>");  
byte[] keyBytes;
try {
        keyBytes = Files.readAllBytes(keyPath);
        SecretKeySpec keySpec = new SecretKeySpec(keyBytes,"AES"); 
        SecretKey symKey=keySpec;  
        EncryptionMaterials keyMaterials = new EncryptionMaterials(symKey);
//3.初始化客户端;
        Ks3  client = new Ks3EncryptionClient("<AK>","<SK>",keyMaterials);
        client.setKs3config(config);

//4.创建一个request对象,本地文件是由路径加文件名包括后缀组成,例如:/users/local/myfile.txt;
        PutObjectRequest request = new PutObjectRequest("<Bucket>","<key>", new File("<loadPath>"));

//5.设置文件的ACL访问权限;
        request.setCannedAcl(CannedAccessControlList.PublicRead);

//6.上传文件;
        client.putObject(request);
        System.out.println("文件上传成功!");      
    } catch (IOException e) {           
        e.printStackTrace();
    }
  • 客户端对称加密下载文件

以下代码用于下载经过客户端加密上传的文件并且对文件进行解密:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);

//2.获取本地密钥,SecretKeyPath为本地保存的密钥地址,例如:D:/22/secret.key,且密钥与上传文件时使用的密钥保持一致;
Path keyPath = Paths.get("<SecretKeyPath>");  
byte[] keyBytes;
try {
        keyBytes = Files.readAllBytes(keyPath);
        SecretKeySpec keySpec = new SecretKeySpec(keyBytes,"AES"); 
        SecretKey symKey=keySpec;  
        EncryptionMaterials keyMaterials = new EncryptionMaterials(symKey);
//3.初始化客户端;
        Ks3  client = new Ks3EncryptionClient("AKLT9rO-ssiXT3GGmdqhM3YVvw","OI+1Ra/Tgu53Q0iqzhD5TtXlzqJ1430rNTtFP6z6Be9ggowUr4HKYCkSxzOlVWh8xw==",keyMaterials);
        client.setKs3config(config);

//4.创建一个request对象 ,此处的Key为上传使用客户端加密的文件    
        GetObjectRequest request = new GetObjectRequest("<Bucket>","<key>");

//5.获取文件
        GetObjectResult result = client.getObject(request);
        Ks3Object object = result.getObject();
        BufferedReader reader = new BufferedReader(new InputStreamReader(object.getObjectContent()));

//6.指定本地存放路径,并创建文件
        File f = new File("D:/22/解密文件.txt");
        try {
            f.createNewFile();
            } catch (IOException e) {
            e.printStackTrace();
            }

//7.将文件保存至本地;
        try {
        FileOutputStream fos =new FileOutputStream(f);
        String str; 
        try {
                while(true) {
                str = reader.readLine();
                if (str == null) break;
                for(int i=0;i<str.length();i++) {
                    int b=(int)str.charAt(i);   
                    fos.write(b);   
                }
                }
                fos.close();
                 } catch (IOException e) {
                e.printStackTrace();
            }       
            } catch (FileNotFoundException e) {
            e.printStackTrace();
            }

    } catch (IOException e) {           
        e.printStackTrace();
    }  

*使用非对称算法的客户端加密上传文件

第一步:加载创建RSA密钥类

在KS3 SDK JAVA中新建GenerateSymmetricMasterKey类,添加以下代码:

import static org.junit.Assert.assertTrue;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.security.KeyFactory;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.NoSuchAlgorithmException;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.SecureRandom;

import java.security.spec.InvalidKeySpecException;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

import java.util.Arrays;

public class GenerateAsymmetricMasterKey {

private static final String keyDir  = "D:/22/";

private static final SecureRandom srand = new SecureRandom();

public static void main(String[] args) throws Exception {

    // Generate RSA key pair of 1024 bits

    KeyPair keypair = genKeyPair("RSA", 1024);

    // Save to file system

    saveKeyPair(keyDir, keypair);

    // Loads from file system

    KeyPair loaded = loadKeyPair(keyDir, "RSA");

    // Sanity check

    assertTrue(Arrays.equals(keypair.getPublic().getEncoded(), loaded

        .getPublic().getEncoded()));

    assertTrue(Arrays.equals(keypair.getPrivate().getEncoded(), loaded

        .getPrivate().getEncoded()));

}

public static KeyPair genKeyPair(String algorithm, int bitLength)

    throws NoSuchAlgorithmException {

    KeyPairGenerator keyGenerator = KeyPairGenerator.getInstance(algorithm);

    keyGenerator.initialize(1024, srand);

    return keyGenerator.generateKeyPair();

}

public static void saveKeyPair(String dir, KeyPair keyPair)

    throws IOException {

    PrivateKey privateKey = keyPair.getPrivate();

    PublicKey publicKey = keyPair.getPublic();

    X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(

        publicKey.getEncoded());

    FileOutputStream fos = new FileOutputStream(dir + "/public.key");

    fos.write(x509EncodedKeySpec.getEncoded());

    fos.close();

    PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(

        privateKey.getEncoded());

    fos = new FileOutputStream(dir + "/private.key");

    fos.write(pkcs8EncodedKeySpec.getEncoded());

    fos.close();

}

public static KeyPair loadKeyPair(String path, String algorithm)

    throws IOException, NoSuchAlgorithmException,

    InvalidKeySpecException {

    // read public key from file

    File filePublicKey = new File(path + "/public.key");

    FileInputStream fis = new FileInputStream(filePublicKey);

    byte[] encodedPublicKey = new byte[(int) filePublicKey.length()];

    fis.read(encodedPublicKey);

    fis.close();

    // read private key from file

    File filePrivateKey = new File(path + "/private.key");

    fis = new FileInputStream(filePrivateKey);

    byte[] encodedPrivateKey = new byte[(int) filePrivateKey.length()];

    fis.read(encodedPrivateKey);

    fis.close();

    // Convert them into KeyPair

    KeyFactory keyFactory = KeyFactory.getInstance(algorithm);

    X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(

        encodedPublicKey);

    PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);

    PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(

        encodedPrivateKey);

    PrivateKey privateKey = keyFactory.generatePrivate(privateKeySpec);

    return new KeyPair(publicKey, privateKey);

}
}

第二步:在KS3 JAVA SDK的主函数中添加以下代码,用于客户端RSA加密上传文件:

KeyPair keypair;
try {
    keypair = GenerateAsymmetricMasterKey.genKeyPair("RSA", 1024);
    try {
    //1.填写保存密钥对的本地路径,例如D:/22/
        String keyDir  = "<FilePath>";
        GenerateAsymmetricMasterKey.saveKeyPair(keyDir, keypair);
        KeyPair loaded = GenerateAsymmetricMasterKey.loadKeyPair(keyDir, "RSA");
        } catch (InvalidKeySpecException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        EncryptionMaterials keyMaterials = new EncryptionMaterials(keypair );

    //2.输入AK/SK;
    String ak = " ";
    String sk = " ";

    //3.初始化客户端;
    Ks3  client = new Ks3EncryptionClient(ak,sk,keyMaterials);
    client.setKs3config(config);

    //4.创建一个request对象,此处的FilePath为要上传文件的本地路径,本地文件是由路径加文件名包括后缀组成,例如:/users/local/myfile.txt;
    PutObjectRequest request = new PutObjectRequest("<Bucket>","<key>", new File("FilePath"));

    //5.设置文件的ACL访问权限;
    request.setCannedAcl(CannedAccessControlList.PublicRead);

    //6.上传文件;
    client.putObject(request);
    System.out.println("文件上传成功!");

    } catch (NoSuchAlgorithmException e) {
        // TODO 自动生成的 catch 块
        e.printStackTrace();
    }
  • 客户端非对称加密下载文件

以下代码用于下载经过客户端加密上传的文件并且对文件进行解密:

try {
//1.输入上传文件时保存的密钥对的本地路径,例如D:/22/
    String keyDir  = "<FilePath>";
    try {
        KeyPair loaded = GenerateAsymmetricMasterKey.loadKeyPair(keyDir, "RSA");
        EncryptionMaterials keyMaterials = new EncryptionMaterials(loaded );
//2.输入AK/SK
String ak = " ";
String sk = " ";

//3.初始化客户端
Ks3  client = new Ks3EncryptionClient(ak,sk,keyMaterials);
client.setKs3config(config);

//4.创建一个request对象     
GetObjectRequest request = new GetObjectRequest("<Bucket>","<key>");

//5.获取文件
GetObjectResult result = client.getObject(request);
Ks3Object object = result.getObject();
BufferedReader reader = new BufferedReader(new InputStreamReader(object.getObjectContent()));

//6.指定本地存放路径,并创建文件例如:D:/22/解密文件.txt
File f = new File("<FilePath>");
try {
    f.createNewFile();
    } catch (IOException e) {
    e.printStackTrace();
    }

//7.将文件保存至本地;
try {
    FileOutputStream fos =new FileOutputStream(f);
    String str; 
    try {
          while(true) {
                        str = reader.readLine();
                        if (str == null) break;
                        for(int i=0;i<str.length();i++) {
                            int b=(int)str.charAt(i);   
                            fos.write(b);   
                        }
                        }
                        fos.close();
                         } catch (IOException e) {
                        // TODO 自动生成的 catch 块
                        e.printStackTrace();
                    }       
                    } catch (FileNotFoundException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                    }
        } catch (InvalidKeySpecException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }

    } catch (NoSuchAlgorithmException e) {
        // TODO 自动生成的 catch 块
        e.printStackTrace();
    }    

九、跨域资源访问

1、创建跨域访问规则

以下代码用于设置Bucket的CORS跨域规则:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.初始化一个CORS配置对象;
BucketCorsConfiguration config1 = new BucketCorsConfiguration();

//4.创建一个资源跨域共享规则对象;
CorsRule rule1 = new CorsRule();

//5.指定允许的跨域请求方法(GET/PUT/DELETE/POST/HEAD) ,可以根据实际需求更改关键字;
List<AllowedMethods> allowedMethods = new ArrayList<AllowedMethods>();
allowedMethods.add(AllowedMethods.GET);
rule1.setAllowedMethods(allowedMethods);

//6.指定允许跨域请求的来源 ,例如http://www.XXXX.com/;
List<String> allowedOrigins = new ArrayList<String>();
allowedOrigins.add("http://www.XXXX.com/");
rule1.setAllowedOrigins(allowedOrigins);

//7.指定允许用户从应用程序中访问的响应头,例如“x-kss-test1”;
List<String> exposedHeaders = new ArrayList<String>();
exposedHeaders.add("x-kss-test1");
rule1.setExposedHeaders(exposedHeaders);

//8.控制在 OPTIONS 预取指令中 Access-Control-Request-Headers 头中指定的 header 是否允许。
List<String> allowedHeaders = new ArrayList<String>();
allowedHeaders.add("x-kss-test"); 
rule1.setAllowedHeaders(allowedHeaders);

//9.指定浏览器对特定资源的预取(OPTIONS)请求返回结果的缓存时间,单位为秒。 
rule1.setMaxAgeSeconds(200);

//10.创建CORS跨域规则,可登陆金山云控制台查看指定的存储空间下的CORS规则详情;
config1.addRule(rule1);
PutBucketCorsRequest request = new PutBucketCorsRequest("<Bucket>",config1);
client.putBucketCors(request);
System.out.println( "配置成功");

以下代码用于同时设置存储空间GET和POST请求的CORS跨域规则:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.初始化一个CORS配置对象;
BucketCorsConfiguration config1 = new BucketCorsConfiguration();

//4.创建一个资源跨域共享规则对象;
CorsRule rule2 = new CorsRule();

//5.指定允许的跨域GET、POST请求方法,可以根据实际需求更改关键字;
List<AllowedMethods> allowedMethods2 = new ArrayList<AllowedMethods>();
allowedMethods2.add(AllowedMethods.GET);
allowedMethods2.add(AllowedMethods.POST);
rule2.setAllowedMethods(allowedMethods2);

//6.指定允许跨域请求的来源 ,例如http://www.XXXX.com/;
List<String> allowedOrigins2 = new ArrayList<String>();
allowedOrigins2.add("http://example.com");
allowedOrigins2.add("http://*.example.com");
rule2.setAllowedOrigins(allowedOrigins2);

//7.指定允许用户从应用程序中访问的响应头,例如“x-kss-test1”;
List<String> exposedHeaders2 = new ArrayList<String>();
exposedHeaders2.add("x-kss-test1");
exposedHeaders2.add("x-kss-test2");
rule2.setExposedHeaders(exposedHeaders2);

//8.控制在 OPTIONS 预取指令中 Access-Control-Request-Headers 头中指定的 header 是否允许。
List<String> allowedHeaders2 = new ArrayList<String>();
allowedHeaders2.add("x-kss-test"); 
allowedHeaders2.add("x-kss-test2"); 
rule2.setAllowedHeaders(allowedHeaders2);

//9.指定浏览器对特定资源的预取(OPTIONS)请求返回结果的缓存时间,单位为秒。
rule2.setMaxAgeSeconds(500);

//10.创建CORS跨域规则,可登陆金山云控制台查看指定的存储空间下的CORS规则详情,或者参考5.10获取Bucket的CORS跨域规则;
config1.addRule(rule2);
PutBucketCorsRequest request = new PutBucketCorsRequest("<Bucket>",config1);
client.putBucketCors(request);
System.out.println( "配置成功");

说明:

  • 一个Bucket可以最多配置10条CORS跨域规则。

  • CORS是指跨域资源共享,当使用javascript进行跨域的时候,需要为bucket配置该规则,详请参考情W3C文档

  • AllowedMethods、AllowedHeaders和AllowedOrigins为必选参数。AllowedHeaders和AllowedOrigins中支持最多一个*号的通配,更多设置CORS跨域详细说明,请参考PUT Bucket CORS文档。

2、删除跨域访问规则

以下代码用于删除跨域访问规则:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.删除指定Bucket下的所有CORS跨域规则,可登陆金山云控制台查看指定Bucket下的CORS跨域规则详情,或者参考5.10获取Bucket的CORS跨域规则;
client.deleteBucketCors("<Bucket>");
System.out.println( "CORS规则删除成功!");

说明:

  • 关于更多删除CORS跨域规则的详细说明,请参考DELETE Bucket CORS文档。

3、查看跨域访问规则

以下代码用于获取CORS跨域资源共享规则:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.初始化一个CORS跨域规则配置对象;
BucketCorsConfiguration config1= client.getBucketCors("<Bucket>");

//4.获取指定Bucket下的所有CORS跨域规则;
List<CorsRule> rules = config1.getRules();

//5.遍历获取到的所有CORS跨域规则;
for(CorsRule rule : rules){

//5.1获取控制在 OPTIONS 预取指令中 Access-Control-Request-Headers 头中指定的 header 是否允许;
rule.getAllowedHeaders();

//5.2获取允许的跨域请求方法(GET/PUT/DELETE/POST/HEAD); 
rule.getAllowedMethods();

//5.3获取允许跨域请求的来源; 
rule.getAllowedOrigins();

//5.4获取允许用户从应用程序中访问的响应头;
rule.getExposedHeaders();

//5.5获取浏览器对特定资源的预取(OPTIONS)请求返回结果的缓存时间,单位为秒; 
rule.getMaxAgeSeconds();

//5.6在控制台逐个打印输出获取的CORS跨域规则参数;
System.out.println( "header:"+ rule.getAllowedHeaders());
System.out.println( "请求方法:"+ rule.getAllowedMethods());
System.out.println( "请求来源 :"+ rule.getAllowedOrigins());
System.out.println( "允许访问的响应头 :"+ rule.getExposedHeaders());
System.out.println( "缓存时间 :"+ rule.getMaxAgeSeconds());
                            }

说明:

  • 关于获取CORS跨域资源共享规则的详细说明,请参考GET Bucket CORS文档。
  • 当Bucket下无CORS跨域规则时,返回空集。

十、访问日志

1、开启日志功能

以下代码用于开启日志功能:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象;
PutBucketLoggingRequest request = new PutBucketLoggingRequest("<Bucket>");

//4.开启日志;
request.setEnable(true);
request.setTargetBucket("<存放日志文件的bucket名称>");

//5.设置日志文件的前缀为logging-;
request.setTargetPrefix("logging-");

//6.创建日志,可登陆金山云控制台查看空间日志设置详情;
client.putBucketLogging(request);

2、关闭日志功能

以下代码用于关闭日志功能:

//1.配置参数
Ks3ClientConfig config = new Ks3ClientConfig();   
//1.1设置服务器地址和设置访问方式       
config.setEndpoint("ks3-cn-beijing.ksyun.com");//设置服务器地址
config.setDomainMode(false);
config.setProtocol(PROTOCOL.http);
config.setPathStyleAccess(false);       
//1.2设置httpclient的相关属性,比如代理,超时,重试等。
HttpClientConfig hconfig = new HttpClientConfig();
config.setHttpClientConfig(hconfig);    

//2.创建一个client对象,用于管理存储空间和文件资源等;
//主账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用IAM账号进行API访问或日常运维;
//请登录 https://iam.console.ksyun.com/#/userList创建IAM账号;
Ks3 client = new Ks3Client("<您的AccessKeyID>","<您的AccessKeySecret>",config);

//3.创建一个request对象;
PutBucketLoggingRequest request = new PutBucketLoggingRequest("<Bucket>");

//4.开启日志;
request.setEnable(false);

//5.创建日志,可登陆金山云控制台查看空间日志设置详情;
client.putBucketLogging(request);

十一、异常处理

十二、常见问题

金山云,开启您的云计算之旅

注册有礼