七牛云图片--Java文档

最新推荐文章于 2024-06-24 09:43:09 发布
最新推荐文章于 2024-06-24 09:43:09 发布
阅读量581 收藏 2
点赞数 1
分类专栏： Unix&Unix-Like Java 文章标签： 七牛云

七牛云图片–Java文档

简介
此 SDK 适用于 Java 7 及以上版本。使用此 SDK 构建您的网络应用程序，能让您以非常便捷地方式将数据安全地存储到七牛云上。无论您的网络应用是一个网站程序，还是包括从云端（服务端程序）到终端（手持设备应用）的架构服务或应用，通过七牛云及其 SDK，都能让您应用程序的终端用户高速上传和下载，同时也让您的服务端更加轻盈。

Java SDK 属于七牛服务端SDK之一，主要有如下功能：

提供生成客户端上传所需的上传凭证的功能
提供文件从服务端直接上传七牛的功能
提供对七牛空间中文件进行管理的功能
提供对七牛空间中文件进行处理的功能
提供七牛CDN相关的刷新，预取，日志功能

开源
Java SDK 项目地址
Java SDK 发布地址
Java SDK 历史文档

安装
使用Gradle
使用Maven
手动安装

Gradle
compile 'com.qiniu:qiniu-java-sdk:7.2.+'

Maven
<dependency>
  <groupId>com.qiniu</groupId>
  <artifactId>qiniu-java-sdk</artifactId>
  <version>[7.2.0, 7.2.99]</version>
</dependency>

这里的version指定了一个版本范围，每次更新pom.xml的时候会尝试去下载7.2.x版本中的最新版本，你可以手动指定一个固定的版本。

手动下载
请尽量使用包管理工具自动解决依赖问题。如果条件实在不满足，只能通过手动下载jar包的方式来解决。本项目自身jar及依赖的第三方库如下：

Java SDK依赖的第三方库及其版本如下：

<dependencies>
    <dependency>
      <groupId>com.qiniu</groupId>
      <artifactId>qiniu-java-sdk</artifactId>
      <version>7.2.11</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>com.squareup.okhttp3</groupId>
      <artifactId>okhttp</artifactId>
      <version>3.3.1</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.6.2</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>com.qiniu</groupId>
      <artifactId>happy-dns-java</artifactId>
      <version>0.1.4</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

库名称 库项目地址 库下载地址
qiniu-java-sdk 链接? 链接?
happy-dns-java 链接? 链接?
okhttp3 链接? 链接?
okio 链接? 链接?
gson 链接? 链接?
junit 链接? 链接?
可以点击每个库的下载链接，然后选择对应的jar进行下载，然后引入到项目中。

鉴权
七牛Java SDK的所有的功能，都需要合法的授权。授权凭证的签算需要七牛账号下的一对有效的Access Key和Secret Key，这对密钥可以通过如下步骤获得：

点击注册?开通七牛开发者帐号
如果已有账号，直接登录七牛开发者后台，点击这里?查看 Access Key 和 Secret Key

文件上传
上传流程
客户端上传凭证
简单上传凭证
覆盖上传凭证
自定义上传回复凭证
带回调业务服务器的凭证
带数据处理的凭证
带自定义参数的凭证
综合上传凭证
服务器直传
构建配置类
文件上传
字节数组上传
数据流上传
断点续传
解析自定义回复内容
业务服务器验证七牛回调

上传流程
七牛文件上传分为客户端上传（主要是指网页端和移动端等面向终端用户的场景）和服务端上传两种场景，具体可以参考文档七牛业务流程。

服务端SDK在上传方面主要提供两种功能，一种是生成客户端上传所需要的上传凭证，另外一种是直接上传文件到云端。

客户端上传凭证
客户端（移动端或者Web端）上传文件的时候，需要从客户自己的业务服务器获取上传凭证，而这些上传凭证是通过服务端的SDK来生成的，然后通过客户自己的业务API分发给客户端使用。根据上传的业务需求不同，七牛云Java SDK支持丰富的上传凭证生成方式。

简单上传的凭证
最简单的上传凭证只需要AccessKey，SecretKey和Bucket就可以。

String accessKey = "access key";
String secretKey = "secret key";
String bucket = "bucket name";
Auth auth = Auth.create(accessKey, secretKey);
String upToken = auth.uploadToken(bucket);
System.out.println(upToken);

覆盖上传的凭证
覆盖上传除了需要简单上传所需要的信息之外，还需要想进行覆盖的文件名称，这个文件名称同时可是客户端上传代码中指定的文件名，两者必须一致。

String accessKey = "access key";
String secretKey = "secret key";
String bucket = "bucket name";
String key = "file key";
Auth auth = Auth.create(accessKey, secretKey);
String upToken = auth.uploadToken(bucket, key);
System.out.println(upToken);

自定义上传回复的凭证
默认情况下，文件上传到七牛之后，在没有设置returnBody或者回调相关的参数情况下，七牛返回给上传端的回复格式为hash和key，例如：

{“hash”:“Ftgm-CkWePC9fzMBTRNmPMhGBcSV”,“key”:“qiniu.jpg”}
有时候我们希望能自定义这个返回的JSON格式的内容，可以通过设置returnBody参数来实现，在returnBody中，我们可以使用七牛支持的魔法变量和自定义变量。

String accessKey = "access key";
String secretKey = "secret key";
String bucket = "bucket name";
Auth auth = Auth.create(accessKey, secretKey);
StringMap putPolicy = new StringMap();
putPolicy.put("returnBody", "{\"key\":\"$(key)\",\"hash\":\"$(etag)\",\"bucket\":\"$(bucket)\",\"fsize\":$(fsize)}");
long expireSeconds = 3600;
String upToken = auth.uploadToken(bucket, null, expireSeconds, putPolicy);
System.out.println(upToken);

则文件上传到七牛之后，收到的回复内容如下：

{"key":"qiniu.jpg","hash":"Ftgm-CkWePC9fzMBTRNmPMhGBcSV","bucket":"if-bc","fsize":39335}

带回调业务服务器的凭证
上面生成的自定义上传回复的上传凭证适用于上传端（无论是客户端还是服务端）和七牛服务器之间进行直接交互的情况下。在客户端上传的场景之下，有时候客户端需要在文件上传到七牛之后，从业务服务器获取相关的信息，这个时候就要用到七牛的上传回调及相关回调参数的设置。

String accessKey = "access key";
String secretKey = "secret key";
String bucket = "bucket name";
Auth auth = Auth.create(accessKey, secretKey);
StringMap putPolicy = new StringMap();
putPolicy.put("callbackUrl", "http://api.example.com/qiniu/upload/callback");
putPolicy.put("callbackBody", "{\"key\":\"$(key)\",\"hash\":\"$(etag)\",\"bucket\":\"$(bucket)\",\"fsize\":$(fsize)}");
putPolicy.put("callbackBodyType", "application/json");
long expireSeconds = 3600;
String upToken = auth.uploadToken(bucket, null, expireSeconds, putPolicy);
System.out.println(upToken);

在使用了上传回调的情况下，客户端收到的回复就是业务服务器响应七牛的JSON格式内容。
通常情况下，我们建议使用application/json格式来设置callbackBody，保持数据格式的统一性。实际情况下，callbackBody也支持application/x-www-form-urlencoded格式来组织内容，这个主要看业务服务器在接收到callbackBody的内容时如何解析。例如：

String accessKey = "access key";
String secretKey = "secret key";
String bucket = "bucket name";
Auth auth = Auth.create(accessKey, secretKey);
StringMap putPolicy = new StringMap();
putPolicy.put("callbackUrl", "http://api.example.com/qiniu/upload/callback");
putPolicy.put("callbackBody", "key=$(key)&hash=$(etag)&bucket=$(bucket)&fsize=$(fsize)");
long expireSeconds = 3600;
String upToken = auth.uploadToken(bucket, null, expireSeconds, putPolicy);
System.out.println(upToken);

带数据处理的凭证
七牛支持在文件上传到七牛之后，立即对其进行多种指令的数据处理，这个只需要在生成的上传凭证中指定相关的处理参数即可。

String accessKey = "access key";
String secretKey = "secret key";
String bucket = "bucket name";
Auth auth = Auth.create(accessKey, secretKey);
StringMap putPolicy = new StringMap();
//数据处理指令，支持多个指令
String saveMp4Entry = String.format("%s:avthumb_test_target.mp4", bucket);
String saveJpgEntry = String.format("%s:vframe_test_target.jpg", bucket);
String avthumbMp4Fop = String.format("avthumb/mp4|saveas/%s", UrlSafeBase64.encodeToString(saveMp4Entry));
String vframeJpgFop = String.format("vframe/jpg/offset/1|saveas/%s", UrlSafeBase64.encodeToString(saveJpgEntry));
//将多个数据处理指令拼接起来
String persistentOpfs = StringUtils.join(new String[]{
        avthumbMp4Fop, vframeJpgFop
}, ";");
putPolicy.put("persistentOps", persistentOpfs);
//数据处理队列名称，必填
putPolicy.put("persistentPipeline", "mps-pipe1");
//数据处理完成结果通知地址
putPolicy.put("persistentNotifyUrl", "http://api.example.com/qiniu/pfop/notify");
long expireSeconds = 3600;
String upToken = auth.uploadToken(bucket, null, expireSeconds, putPolicy);
System.out.println(upToken);

队列 pipeline 请参阅创建私有队列；转码操作具体参数请参阅音视频转码；saveas 请参阅处理结果另存。

带自定义参数的凭证
七牛支持客户端上传文件的时候定义一些自定义参数，这些参数可以在returnBody和callbackBody里面和七牛内置支持的魔法变量（即系统变量）通过相同的方式来引用。这些自定义的参数名称必须以x:开头。例如客户端上传的时候指定了自定义的参数x:user和x:age分别是String和int类型。那么可以通过下面的方式引用：

putPolicy.put("returnBody", "{\"key\":\"$(key)\",\"hash\":\"$(etag)\",\"bucket\":\"$(bucket)\",\"fsize\":$(fsize),\"user\":\"$(x:user)\",\"age\",$(x:age)}");

或者

putPolicy.put("callbackBody", "{\"key\":\"$(key)\",\"hash\":\"$(etag)\",\"bucket\":\"$(bucket)\",\"fsize\":$(fsize),\"user\":\"$(x:user)\",\"age\",$(x:age)}");

综合上传凭证
上面的生成上传凭证的方法，都是通过设置上传策略?相关的参数来支持的，这些参数可以通过不同的组合方式来满足不同的业务需求，可以灵活地组织你所需要的上传凭证。

上传凭证额外参数
默认会拒绝不在预定义集中的参数。即：

String upToken = auth.uploadToken(bucket, key, expireSeconds, putPolicy, true);

若允许添加额外参数，可以将参数设置为false。

String upToken = auth.uploadToken(bucket, key, expireSeconds, putPolicy, false);

服务端直传
服务端直传是指客户利用七牛服务端SDK从服务端直接上传文件到七牛云，交互的双方一般都在机房里面，所以服务端可以自己生成上传凭证，然后利用SDK中的上传逻辑进行上传，最后从七牛云获取上传的结果，这个过程中由于双方都是业务服务器，所以很少利用到上传回调的功能，而是直接自定义returnBody来获取自定义的回复内容。

构建配置类
七牛存储支持空间创建在不同的机房，在使用七牛的Java SDK中的UploadManager上传文件之前，必须要构建一个上传用的Configuration对象，在该对象中，可以指定空间对应的Zone以及其他的一些影响上传的参数。

//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释
UploadManager uploadManager = new UploadManager(cfg);
//…生成上传凭证，然后准备上传
其中关于Zone对象和机房的关系如下：

机房 Zone对象
华东 Zone.zone0()
华北 Zone.zone1()
华南 Zone.zone2()
北美 Zone.zoneNa0()
东南亚 Zone.zoneAs0()

文件上传
最简单的就是上传本地文件，直接指定文件的完整路径即可上传。

//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释
UploadManager uploadManager = new UploadManager(cfg);
//…生成上传凭证，然后准备上传
String accessKey = “your access key”;
String secretKey = “your secret key”;
String bucket = “your bucket name”;
//如果是Windows情况下，格式是 D:\qiniu\test.png
String localFilePath = “/home/qiniu/test.png”;
//默认不指定key的情况下，以文件内容的hash值作为文件名

String key = null;
Auth auth = Auth.create(accessKey, secretKey);
String upToken = auth.uploadToken(bucket);
try {
    Response response = uploadManager.put(localFilePath, key, upToken);
    //解析上传成功的结果
    DefaultPutRet putRet = new Gson().fromJson(response.bodyString(), DefaultPutRet.class);
    System.out.println(putRet.key);
    System.out.println(putRet.hash);
} catch (QiniuException ex) {
    Response r = ex.response;
    System.err.println(r.toString());
    try {
        System.err.println(r.bodyString());
    } catch (QiniuException ex2) {
        //ignore
    }
}

字节数组上传
可以支持将内存中的字节数组上传到空间中。

//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释
UploadManager uploadManager = new UploadManager(cfg);
//…生成上传凭证，然后准备上传

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";

//默认不指定key的情况下，以文件内容的hash值作为文件名

String key = null;
try {
    byte[] uploadBytes = "hello qiniu cloud".getBytes("utf-8");
    Auth auth = Auth.create(accessKey, secretKey);
    String upToken = auth.uploadToken(bucket);
    try {
        Response response = uploadManager.put(uploadBytes, key, upToken);
        //解析上传成功的结果
        DefaultPutRet putRet = new Gson().fromJson(response.bodyString(), DefaultPutRet.class);
        System.out.println(putRet.key);
        System.out.println(putRet.hash);
    } catch (QiniuException ex) {
        Response r = ex.response;
        System.err.println(r.toString());
        try {
            System.err.println(r.bodyString());
        } catch (QiniuException ex2) {
            //ignore
        }
    }
} catch (UnsupportedEncodingException ex) {
    //ignore
}

数据流上传
这里演示的是InputStream对象的上传，适用于所有的InputStream子类。这里的ByteInputStream只用于演示目的，实际用法根据情况而定。

//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释
UploadManager uploadManager = new UploadManager(cfg);
//…生成上传凭证，然后准备上传

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";

//默认不指定key的情况下，以文件内容的hash值作为文件名

String key = null;
try {
    byte[] uploadBytes = "hello qiniu cloud".getBytes("utf-8");
    ByteArrayInputStream byteInputStream=new ByteArrayInputStream(uploadBytes);
    Auth auth = Auth.create(accessKey, secretKey);
    String upToken = auth.uploadToken(bucket);
    try {
        Response response = uploadManager.put(byteInputStream,key,upToken,null, null);
        //解析上传成功的结果
        DefaultPutRet putRet = new Gson().fromJson(response.bodyString(), DefaultPutRet.class);
        System.out.println(putRet.key);
        System.out.println(putRet.hash);
    } catch (QiniuException ex) {
        Response r = ex.response;
        System.err.println(r.toString());
        try {
            System.err.println(r.bodyString());
        } catch (QiniuException ex2) {
            //ignore
        }
    }
} catch (UnsupportedEncodingException ex) {
    //ignore
}

断点续上传
//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释
//…生成上传凭证，然后准备上传

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";

//如果是Windows情况下，格式是 D:\qiniu\test.png
String localFilePath = “/home/qiniu/test.mp4”;
//默认不指定key的情况下，以文件内容的hash值作为文件名

String key = null;
Auth auth = Auth.create(accessKey, secretKey);
String upToken = auth.uploadToken(bucket);
String localTempDir = Paths.get(System.getenv("java.io.tmpdir"), bucket).toString();
try {
    //设置断点续传文件进度保存目录
    FileRecorder fileRecorder = new FileRecorder(localTempDir);
    UploadManager uploadManager = new UploadManager(cfg, fileRecorder);
    try {
        Response response = uploadManager.put(localFilePath, key, upToken);
        //解析上传成功的结果
        DefaultPutRet putRet = new Gson().fromJson(response.bodyString(), DefaultPutRet.class);
        System.out.println(putRet.key);
        System.out.println(putRet.hash);
    } catch (QiniuException ex) {
        Response r = ex.response;
        System.err.println(r.toString());
        try {
            System.err.println(r.bodyString());
        } catch (QiniuException ex2) {
            //ignore
        }
    }
} catch (IOException ex) {
    ex.printStackTrace();
}

解析自定义回复内容
有些情况下，七牛返回给上传端的内容不是默认的hash和key形式，这种情况下，可能出现在自定义returnBody或者自定义了callbackBody的情况下，前者一般是服务端直传的场景，而后者则是接受上传回调的场景，这两种场景之下，都涉及到需要将自定义的回复内容解析为Java的类对象，一般建议在交互过程中，都采用JSON的方式，这样处理起来方法比较一致，而且JSON的方法最通用。

遇到诸如自定义returnBody的情况：

putPolicy.put("returnBody", "{\"key\":\"$(key)\",\"hash\":\"$(etag)\",\"bucket\":\"$(bucket)\",\"fsize\":$(fsize)}");

或者是自定义了callbackBody的情况：

putPolicy.put("callbackBody", "{\"key\":\"$(key)\",\"hash\":\"$(etag)\",\"bucket\":\"$(bucket)\",\"fsize\":$(fsize)}");

我们只需要自己定义了对应的类，例如：

class MyPutRet {
    public String key;
    public String hash;
    public String bucket;
    public long fsize;
}

然后在获取到上传回复的Response对象时，使用如下的方法就可以转为自定义回复的类对象了：

MyPutRet myPutRet=response.jsonToObject(MyPutRet.class);

业务服务器验证七牛回调
在上传策略里面设置了上传回调相关参数的时候，七牛在文件上传到服务器之后，会主动地向callbackUrl发送POST请求的回调，回调的内容为callbackBody模版所定义的内容，如果这个模版里面引用了魔法变量或者自定义变量，那么这些变量会被自动填充对应的值，然后在发送给业务服务器。

业务服务器在收到来自七牛的回调请求的时候，可以根据请求头部的Authorization字段来进行验证，查看该请求是否是来自七牛的未经篡改的请求。具体可以参考七牛的回调鉴权。

注意：业务端服务器回调鉴权的Content-Type类型应该与上传策略中指定的callbackBodyType相同，默认为 application/x-www-form-urlencoded，当 Content-Type 为 application/x-www-form-urlencoded 时，签名内容必须包括请求内容。当 Content-Type 为 application/json 时，签名内容不包括请求内容。

String accessKey = "your access key";
String secretKey = "your secret key";
/*
* 这两个参数就是在定义PutPolicy参数时指定的内容
*/
//回调地址
String callbackUrl = "http://api.example.com/qiniu/callback";
//定义回调内容的组织格式，与上传策略中的callbackBodyType要保持一致
//String callbackBodyType = "application/x-www-form-urlencoded"; //回调鉴权的签名包括请求内容callbackBody
String callbackBodyType = "application/json";//回调鉴权的签名不包括请求内容
/**
 * 这两个参数根据实际所使用的HTTP框架进行获取
 */
//通过获取请求的HTTP头部Authorization字段获得
String callbackAuthHeader = "xxx";
//通过读取回调POST请求体获得，不要设置为null
byte[] callbackBody = null;
Auth auth = Auth.create(accessKey, secretKey);
//检查是否为七牛合法的回调请求
boolean validCallback = auth.isValidCallback(callbackAuthHeader, callbackUrl, callbackBody, callbackBodyType);
if (validCallback) {
    //继续处理其他业务逻辑
} else {
    //这是哪里的请求，被劫持，篡改了吧？
}

下载文件
公开空间
私有空间
文件下载分为公开空间的文件下载和私有空间的文件下载。

公开空间
对于公开空间，其访问的链接主要是将空间绑定的域名（可以是七牛空间的默认域名或者是绑定的自定义域名）拼接上空间里面的文件名即可访问，标准情况下需要在拼接链接之前，将文件名进行urlencode以兼容不同的字符。

String fileName = "七牛/云存储/qiniu.jpg";
String domainOfBucket = "http://devtools.qiniu.com";
String encodedFileName = URLEncoder.encode(fileName, "utf-8");
String finalUrl = String.format("%s/%s", domainOfBucket, encodedFileName);
System.out.println(finalUrl);

私有空间
对于私有空间，首先需要按照公开空间的文件访问方式构建对应的公开空间访问链接，然后再对这个链接进行私有授权签名。

String fileName = "七牛/云存储/qiniu.jpg";
String domainOfBucket = "http://devtools.qiniu.com";
String encodedFileName = URLEncoder.encode(fileName, "utf-8");
String publicUrl = String.format("%s/%s", domainOfBucket, encodedFileName);
String accessKey = "your access key";
String secretKey = "your secret key";
Auth auth = Auth.create(accessKey, secretKey);
long expireInSeconds = 3600;//1小时，可以自定义链接过期时间
String finalUrl = auth.privateDownloadUrl(publicUrl, expireInSeconds);
System.out.println(finalUrl);

资源管理
资源管理包括的主要功能有：

获取文件信息
修改文件类型
移动或重命名文件
复制文件副本
删除空间中的文件
设置或更新文件生存时间
获取空间文件列表
抓取网络资源到空间
资源管理批量操作
批量获取文件信息
批量修改文件类型
批量删除文件
批量移动或重命名文件
批量复制文件
批量混合指令操作
更新镜像存储空间中的文件内容
更新镜像存储空间中文件内容

获取文件信息
//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";
String key = "your file key";
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
try {
    FileInfo fileInfo = bucketManager.stat(bucket, key);
    System.out.println(fileInfo.hash);
    System.out.println(fileInfo.fsize);
    System.out.println(fileInfo.mimeType);
    System.out.println(fileInfo.putTime);
} catch (QiniuException ex) {
    System.err.println(ex.response.toString());
}

修改文件类型
//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";
String key = "your file key";
String newMimeType = "new mime type";
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
//修改文件类型
try {
    bucketManager.changeMime(bucket, key, newMimeType);
} catch (QiniuException ex) {
    System.out.println(ex.response.toString());
}

移动或重命名文件
移动操作本身支持移动文件到相同，不同空间中，在移动的同时也可以支持文件重命名。唯一的限制条件是，移动的源空间和目标空间必须在同一个机房。

源空间 目标空间 源文件名 目标文件名 描述
BucketA BucketA KeyA KeyB 相当于同空间文件重命名
BucketA BucketB KeyA KeyA 移动文件到BucketB，文件名一致
BucketA BucketB KeyA KeyB 移动文件到BucketB，文件名变成KeyB
move操作支持强制覆盖选项，即如果目标文件已存在，可以设置强制覆盖参数force来覆盖那个文件的内容。

//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "your access key";
String secretKey = "your secret key";
String fromBucket = "from bucket name";
String fromKey = "from key";
String toBucket = "to bucket name";
String toKey = "to key";
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
try {
    bucketManager.move(fromBucket, fromKey, toBucket, toKey);
} catch (QiniuException ex) {
    //如果遇到异常，说明移动失败
    System.err.println(ex.code());
    System.err.println(ex.response.toString());
}

复制文件副本
文件的复制和文件移动其实操作一样，主要的区别是移动后源文件不存在了，而复制的结果是源文件还存在，只是多了一个新的文件副本。

//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "your access key";
String secretKey = "your secret key";
String fromBucket = "from bucket name";
String fromKey = "from key";
String toBucket = "to bucket name";
String toKey = "to key";
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
try {
    bucketManager.copy(fromBucket, fromKey, toBucket, toKey);
} catch (QiniuException ex) {
    //如果遇到异常，说明复制失败
    System.err.println(ex.code());
    System.err
}

删除空间中的文件
//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";
String key = "your file key";
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
try {
    bucketManager.delete(bucket, key);
} catch (QiniuException ex) {
    //如果遇到异常，说明删除失败
    System.err.println(ex.code());
    System.err.println(ex.response.toString());
}

设置或更新文件的生存时间
可以给已经存在于空间中的文件设置文件生存时间，或者更新已设置了生存时间但尚未被删除的文件的新的生存时间。

//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "access key";
String secretKey = "secret key";
String bucket = "bucket name";
String key = "file key";
//过期天数，该文件10天后删除
int days = 10;
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
try {
    bucketManager.deleteAfterDays(bucket, key, days);
} catch (QiniuException ex) {
    System.err.println(ex.response.toString());
}

获取空间文件列表
//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
//文件名前缀
String prefix = "";
//每次迭代的长度限制，最大1000，推荐值 1000
int limit = 1000;
//指定目录分隔符，列出所有公共前缀（模拟列出目录效果）。缺省值为空字符串
String delimiter = "";
//列举空间文件列表
BucketManager.FileListIterator fileListIterator = bucketManager.createFileListIterator(bucket, prefix, limit, delimiter);
while (fileListIterator.hasNext()) {
    //处理获取的file list结果
    FileInfo[] items = fileListIterator.next();
    for (FileInfo item : items) {
        System.out.println(item.key);
        System.out.println(item.hash);
        System.out.println(item.fsize);
        System.out.println(item.mimeType);
        System.out.println(item.putTime);
        System.out.println(item.endUser);
    }
}

抓取网络资源到空间
//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";
String key = "your file key";
String remoteSrcUrl = "http://devtools.qiniu.com/qiniu.png";
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
//抓取网络资源到空间
try {
    FetchRet fetchRet = bucketManager.fetch(remoteSrcUrl, bucket, key);
    System.out.println(fetchRet.hash);
    System.out.println(fetchRet.key);
    System.out.println(fetchRet.mimeType);
    System.out.println(fetchRet.fsize);
} catch (QiniuException ex) {
    System.err.println(ex.response.toString());
}

资源管理批量操作

批量获取文件信息
//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
try {
    //单次批量请求的文件数量不得超过1000
    String[] keyList = new String[]{
            "qiniu.jpg",
            "qiniu.mp4",
            "qiniu.png",
    };
    BucketManager.BatchOperations batchOperations = new BucketManager.BatchOperations();
    batchOperations.addStatOps(bucket, keyList);
    Response response = bucketManager.batch(batchOperations);
    BatchStatus[] batchStatusList = response.jsonToObject(BatchStatus[].class);
    for (int i = 0; i < keyList.length; i++) {
        BatchStatus status = batchStatusList[i];
        String key = keyList[i];
        System.out.print(key+"\t");
        if (status.code == 200) {
            //文件存在
            System.out.println(status.data.hash);
            System.out.println(status.data.mimeType);
            System.out.println(status.data.fsize);
            System.out.println(status.data.putTime);
        } else {
            System.out.println(status.data.error);
        }
    }
} catch (QiniuException ex) {
    System.err.println(ex.response.toString());
}

批量修改文件类型
//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
try {
    //单次批量请求的文件数量不得超过1000
    HashMap<String, String> keyMimeMap = new HashMap<>();
    keyMimeMap.put("qiniu.jpg", "image/jpg");
    keyMimeMap.put("qiniu.png", "image/png");
    keyMimeMap.put("qiniu.mp4", "video/mp4");
    BucketManager.BatchOperations batchOperations = new BucketManager.BatchOperations();
    //添加指令
    for (Map.Entry<String, String> entry : keyMimeMap.entrySet()) {
        String key = entry.getKey();
        String newMimeType = entry.getValue();
        batchOperations.addChgmOp(bucket, key, newMimeType);
    }
    Response response = bucketManager.batch(batchOperations);
    BatchStatus[] batchStatusList = response.jsonToObject(BatchStatus[].class);
    int index = 0;
    for (Map.Entry<String, String> entry : keyMimeMap.entrySet()) {
        String key = entry.getKey();
        System.out.print(key + "\t");
        BatchStatus status = batchStatusList[index];
        if (status.code == 200) {
            System.out.println("change mime success");
        } else {
            System.out.println(status.data.error);
        }
        index += 1;
    }
} catch (QiniuException ex) {
    System.err.println(ex.response.toString());
}

批量删除文件
//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
try {
    //单次批量请求的文件数量不得超过1000
    String[] keyList = new String[]{
            "qiniu.jpg",
            "qiniu.mp4",
            "qiniu.png",
    };
    BucketManager.BatchOperations batchOperations = new BucketManager.BatchOperations();
    batchOperations.addDeleteOp(bucket, keyList);
    Response response = bucketManager.batch(batchOperations);
    BatchStatus[] batchStatusList = response.jsonToObject(BatchStatus[].class);
    for (int i = 0; i < keyList.length; i++) {
        BatchStatus status = batchStatusList[i];
        String key = keyList[i];
        System.out.print(key + "\t");
        if (status.code == 200) {
            System.out.println("delete success");
        } else {
            System.out.println(status.data.error);
        }
    }
} catch (QiniuException ex) {
    System.err.println(ex.response.toString());
}

批量移动或重命名文件
//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
try {
    //单次批量请求的文件数量不得超过1000
    String[] keyList = new String[]{
            "qiniu.jpg",
            "qiniu.mp4",
            "qiniu.png",
    };
    BucketManager.BatchOperations batchOperations = new BucketManager.BatchOperations();
    for (String key : keyList) {
        batchOperations.addMoveOp(bucket, key, bucket, key + "_move");
    }
    Response response = bucketManager.batch(batchOperations);
    BatchStatus[] batchStatusList = response.jsonToObject(BatchStatus[].class);
    for (int i = 0; i < keyList.length; i++) {
        BatchStatus status = batchStatusList[i];
        String key = keyList[i];
        System.out.print(key + "\t");
        if (status.code == 200) {
            System.out.println("move success");
        } else {
            System.out.println(status.data.error);
        }
    }
} catch (QiniuException ex) {
    System.err.println(ex.response.toString());
}

批量复制文件
//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
try {
    //单次批量请求的文件数量不得超过1000
    String[] keyList = new String[]{
            "qiniu.jpg",
            "qiniu.mp4",
            "qiniu.png",
    };
    BucketManager.BatchOperations batchOperations = new BucketManager.BatchOperations();
    for (String key : keyList) {
        batchOperations.addCopyOp(bucket, key, bucket, key + "_copy");
    }
    Response response = bucketManager.batch(batchOperations);
    BatchStatus[] batchStatusList = response.jsonToObject(BatchStatus[].class);
    for (int i = 0; i < keyList.length; i++) {
        BatchStatus status = batchStatusList[i];
        String key = keyList[i];
        System.out.print(key + "\t");
        if (status.code == 200) {
            System.out.println("copy success");
        } else {
            System.out.println(status.data.error);
        }
    }
} catch (QiniuException ex) {
    System.err.println(ex.response.toString());
}

批量混合指令操作
其实batch接口支持混合指令的处理，不过为了方便解析请求的回复，一般不推荐这样做。

//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
try {
    //单次批量请求的文件数量不得超过1000
    BucketManager.BatchOperations batchOperations = new BucketManager.BatchOperations();
    //添加混合指令
    batchOperations.addStatOps(bucket, "qiniu.png", "qiniu.jpg");
    batchOperations.addCopyOp(bucket, "qiniu.png", bucket, "qiniu_copy1.png");
    batchOperations.addMoveOp(bucket, "qiniu2.png", bucket, "qiniu3.png");
    batchOperations.addDeleteOp(bucket, "qiniu4.png");
    Response response = bucketManager.batch(batchOperations);
    BatchStatus[] batchStatusList = response.jsonToObject(BatchStatus[].class);
    for (BatchStatus status : batchStatusList) {
        if (status.code == 200) {
            System.out.println("operation success");
        } else {
            System.out.println(status.data.error);
        }
    }
} catch (QiniuException ex) {
    System.err.println(ex.response.toString());
}

更新镜像存储空间中文件内容
对于配置了镜像存储的空间，如果镜像源站更新了文件内容，则默认情况下，七牛不会再主动从客户镜像源站同步新的副本，这个时候就需要利用这个prefetch接口来主动地将空间中的文件和更新后的源站副本进行同步。调用方式很简单，指定空间和文件名即可。

//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//…其他参数参考类注释

String accessKey = "your access key";
String secretKey = "your secret key";
String bucket = "your bucket name";
String key = "your file key";
Auth auth = Auth.create(accessKey, secretKey);
BucketManager bucketManager = new BucketManager(auth, cfg);
try {
    bucketManager.prefetch(bucket, key);
} catch (QiniuException ex) {
    //如果遇到异常，说明更新失败
    System.err.println(ex.code());
    System.err.println(ex.response.toString());
}

持久化数据处理

发送数据处理请求
对于已经保存到七牛空间的文件，可以通过发送持久化的数据处理指令来进行处理，这些指令支持七牛官方提供的指令，也包括客户自己开发的自定义数据处理的指令。数据处理的结果还可以通过七牛主动通知的方式告知业务服务器。

String accessKey = "access key";
String secretKey = "secret key";
//待处理文件所在空间
String bucket = "bucket name";
//待处理文件名
String key = "file key";
Auth auth = Auth.create(accessKey, secretKey);
//数据处理指令，支持多个指令
String saveMp4Entry = String.format("%s:avthumb_test_target.mp4", bucket);
String saveJpgEntry = String.format("%s:vframe_test_target.jpg", bucket);
String avthumbMp4Fop = String.format("avthumb/mp4|saveas/%s", UrlSafeBase64.encodeToString(saveMp4Entry));
String vframeJpgFop = String.format("vframe/jpg/offset/1|saveas/%s", UrlSafeBase64.encodeToString(saveJpgEntry));
//将多个数据处理指令拼接起来
String persistentOpfs = StringUtils.join(new String[]{
        avthumbMp4Fop, vframeJpgFop
}, ";");
//数据处理队列名称，必须
String persistentPipeline = "mps-pipe1";
//数据处理完成结果通知地址
String persistentNotifyUrl = "http://api.example.com/qiniu/pfop/notify";
//构造一个带指定Zone对象的配置类
Configuration cfg = new Configuration(Zone.zone0());
//...其他参数参考类注释
//构建持久化数据处理对象
OperationManager operationManager = new OperationManager(auth, cfg);
try {
    String persistentId = operationManager.pfop(bucket, key, persistentOpfs, persistentPipeline, persistentNotifyUrl, true);
    //可以根据该 persistentId 查询任务处理进度
    System.out.println(persistentId);
    OperationStatus operationStatus = operationManager.prefop(persistentId);
    //解析 operationStatus 的结果
} catch (QiniuException e) {
    System.err.println(e.response.toString());
}

查询数据处理请求状态
由于数据处理是异步处理，可以根据发送处理请求时返回的 persistentId 去查询任务的处理进度，如果在设置了persistentNotifyUrl 的情况下，直接业务服务器等待处理结果通知即可，如果需要主动查询，可以采用如上代码中的：

OperationStatus operationStatus = operationManager.prefop(persistentId);
//解析 operationStatus 的结果

CDN相关功能
文件刷新
目录刷新
文件预取操作
获取域名流量
获取域名带宽
获取日志下载链接
构建时间戳防盗链访问链接

文件刷新

String accessKey = "your access key";
String secretKey = "your secret key";
Auth auth = Auth.create(accessKey, secretKey);
CdnManager c = new CdnManager(auth);
//待刷新的链接列表
String[] urls = new String[]{
        "http://javasdk.qiniudn.com/gopher1.jpg",
        "http://javasdk.qiniudn.com/gopher2.jpg",
        //....
};
try {
    //单次方法调用刷新的链接不可以超过100个
    CdnResult.RefreshResult result = c.refreshUrls(urls);
    System.out.println(result.code);
    //获取其他的回复内容
} catch (QiniuException e) {
    System.err.println(e.response.toString());
}

目录刷新

String accessKey = "your access key";
String secretKey = "your secret key";
Auth auth = Auth.create(accessKey, secretKey);
CdnManager c = new CdnManager(auth);
//待刷新的目录列表，目录必须以 / 结尾
String[] dirs = new String[]{
        "http://javasdk.qiniudn.com/gopher1/",
        "http://javasdk.qiniudn.com/gopher2/",
        //....
};
try {
    //单次方法调用刷新的目录不可以超过10个，另外刷新目录权限需要联系技术支持开通
    CdnResult.RefreshResult result = c.refreshDirs(dirs);
    System.out.println(result.code);
    //获取其他的回复内容
} catch (QiniuException e) {
    System.err.println(e.response.toString());
}

文件预取

String accessKey = "your access key";
String secretKey = "your secret key";
Auth auth = Auth.create(accessKey, secretKey);
CdnManager c = new CdnManager(auth);
//待预取的文件链接
String[] urls = new String[]{
        "http://javasdk.qiniudn.com/gopher1.jpg",
        "http://javasdk.qiniudn.com/gopher2.jpg",
        //...
};
try {
    //单次调用方法预取的链接数量不得超过100个
    CdnResult.PrefetchResult result = c.prefetchUrls(urls);
    System.out.println(result.code);
    //获取其他的回复内容
} catch (QiniuException e) {
    System.err.println(e.response.toString());
}

获取域名流量

String accessKey = "your access key";
String secretKey = "your secret key";
Auth auth = Auth.create(accessKey, secretKey);
CdnManager c = new CdnManager(auth);
//域名列表
String[] domains = new String[]{
        "img1.example.com",
        "img2.example.com",
};
//开始和结束日期
String fromDate = "2017-01-02";
String toDate = "2017-01-10";
//数据粒度，支持的取值为 5min ／ hour ／day
String granularity = "day";
try {
    CdnResult.FluxResult fluxResult = c.getFluxData(domains, fromDate, toDate, granularity);
    //处理得到的结果数据
    //...
} catch (QiniuException e) {
    System.err.println(e.response.toString());
}

获取域名带宽

String accessKey = "your access key";
String secretKey = "your secret key";
Auth auth = Auth.create(accessKey, secretKey);
CdnManager c = new CdnManager(auth);
//域名列表
String[] domains = new String[]{
        "img1.example.com",
        "img2.example.com",
};
//开始和结束日期
String fromDate = "2017-01-02";
String toDate = "2017-01-10";
//数据粒度，支持的取值为 5min ／ hour ／day
String granularity = "day";
try {
    CdnResult.BandwidthResult bandwidthResult = c.getBandwidthData(domains, fromDate, toDate, granularity);
    //处理得到的结果数据
    //...
} catch (QiniuException e) {
    System.err.println(e.response.toString());
}

获取日志下载链接

String accessKey = "your access key";
String secretKey = "your secret key";
Auth auth = Auth.create(accessKey, secretKey);
CdnManager c = new CdnManager(auth);
//域名列表
String[] domains = new String[]{
        "img1.example.com",
        "img2.example.com",
};
//具体日期
String logDate = "2017-01-02";
try {
    CdnResult.LogListResult logListResult = c.getCdnLogList(domains, logDate);
    //处理得到的结果数据
    //...
} catch (QiniuException e) {
    System.err.println(e.response.toString());
}

构建时间戳防盗链访问链接
具体算法可以参考：时间戳防盗链

String host = "http://video.example.com";
String fileName = "基本概括.mp4";
//查询参数
StringMap queryStringMap = new StringMap();
queryStringMap.put("name", "七牛");
queryStringMap.put("year", 2017);
queryStringMap.put("年龄", 28);
//链接过期时间
long deadline = System.currentTimeMillis() / 1000 + 3600;
//签名密钥，从后台域名属性中获取
String encryptKey = "xxx";
String signedUrl;
try {
    signedUrl = CdnManager.createTimestampAntiLeechUrl(host, fileName,
            queryStringMap, encryptKey, deadline);
    System.out.println(signedUrl);
} catch (Exception ex) {
    ex.printStackTrace();
}

API 参考
存储 API 参考
融合CDN API 参考
官方数据处理 API 参考

常见问题
QiniuExeption 保留了请求响应的信息，失败情况下会抛出此异常，可以提交给我们排查问题。
API 的使用，demo 可以参考单元测试。

相关资源
如果您有任何关于我们文档或产品的建议和想法，欢迎您通过以下方式与我们互动讨论：

技术论坛 - 在这里您可以和其他开发者愉快的讨论如何更好的使用七牛云服务
提交工单 - 如果您的问题不适合在论坛讨论或希望及时解决，您也可以提交一个工单，我们的技术支持人员会第一时间回复您
博客 - 这里会持续更新发布市场活动和技术分享文章
微博
常见问题

贡献代码
创建您的特性分支 git checkout -b my-new-feature
提交您的改动 git commit -am ‘Added some feature’
将您的修改记录提交到远程 git 仓库 git push origin my-new-feature
然后到 github 网站的该 git 远程仓库的 my-new-feature 分支下发起 Pull Request

许可证 Copyright © 2014 qiniu.com
基于 MIT 协议发布: www.opensource.org/licenses/MIT

星河_赵梓宇
关注
专栏目录
Java 代码实现七牛云存储图片
u013123030的博客
11-26 757
前言 项目想把图片上传到七牛云存储上，笔者把七牛最简单的用法示范一下，方便初学者。文章如有错误，欢迎各位指出。   准备工作   登录七牛开发者自助平台，查看 Access Key 和 Secret Key （这两个 Key 代码会用到） 下载七牛依赖 jar 包 可以用包管理器 gradle 下载（查看这篇文章 《Eclipse 使用 Gradle 下载...
七牛云--java获取域空间文件列表
许小乖……是总攻
03-02 3436
      首先，注册七牛云，获取密钥，个人中心--&gt;密钥管理           当然，我们可以在对象存储中jia建立存储空间，在内容管理中上传图片和下载图片。在七牛上的每一张图片都有自己单一的链接，但是随着业务的扩展，需要访问到一个域下面的所有图片，图片的具体名称并不确定，或者以后会有变动。所以需要实现获取空间文件列表。看了七牛云的java SDK文档实现过程如下：//构造一个带指定Zo...
七牛云存储Java sdk
07-10
七牛云存储 java 开发平台
图片服务器 java代码_使用七牛云做图片服务器（Java代码）
weixin_32340873的博客
02-16 257
首先得去七牛云注册账号，然后去控制台创建存储空间6.png这里申请的是测试域名，所以只有30天的有效期，到期了图片就会被清除。所以只是供我们玩一下，真正的开发得用自己的域名。接下来就是申请AK和SK，在个人中心7.png做好了这些准备，那么就可以开始写代码了。我这里使用的是SpringBoot，这样可以省去很多配置，在这个项目中，几乎是零配置。图片上传，这里需要两个jar包com.alibabaf...
七牛云存储高速处理图片等文件
张相逢的博客
03-02 3881
七牛云存储(www.qiniu.com)为中小型企业web站点提供了一套图片文档处理方案。 目的在于解决:企业服务器由于处理图片/文档等工作内容,而降低服务器的工作效率,节约开支，七牛云来存储企业上传的图片或者文档,使企业的Web应用快速响应用户的需求。 例如说,我上传(手动上传或代码上传)一张test.png的图片在七牛空间上样式1：裁剪正中部分，等比缩小生成200x200缩略图 http:
Java实现七牛云上传图片、读取图片链接
qq_54429571的博客
09-30 905
Java后端实现七牛云上传图片、读取图片链接。
Java开发案例-springboot-09-整合七牛云实现文件上传-源代码+文档.rar
05-31
Java开发案例-springboot-09-整合七牛云实现文件上传-源代码+文档.rar Java开发案例-springboot-09-整合七牛云实现文件上传-源代码+文档.rar Java开发案例-springboot-09-整合七牛云实现文件上传-源代码+文档.rar ...
springboot java 七牛云
06-03
用到了七牛云的开发者文档，可以在controller基础上增加一些功能，比如说，将回显的图片链接保存到数据库中，能实现用户头像的更改、上传等功能。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。...
SpringBoot整合七牛云图片上传
12-21
1. 引入七牛云Java SDK依赖。例如，对于版本7.2.28，可以在`pom.xml`中添加如下依赖： ```xml <groupId>com.qiniu</groupId> <artifactId>qiniu-java-sdk <version>7.2.28 ``` 2. 创建一个`...
java对七牛云的操作(包含所有jar包)
01-24
Java对七牛云的操作主要涉及的是使用Java SDK与七牛云服务进行交互，包括文件的上传、下载、管理等操作。七牛云是一家提供云端存储和CDN加速服务的公司，广泛应用于图片、视频等多媒体资源的托管。在Java中使用七...
java mysql 七牛云存储上传删除图片demo
12-29
内有sql文件 自己创建数据库 表，需要配置七牛的相关属性
qiniu-cache-refresh:基于配置的七牛缓存刷新命令行工具
04-30
qiniu-cache-refresh 基于配置的七牛缓存刷新命令行工具。 安装 yarn add qiniu-cache-refresh -D // 或者 npm i qiniu-cache-refresh -D 用法 配置 在项目根目录下新建 qiniu.config.js 文件，写入配置： module.exports = { accessKey: 'Access 密钥', secretKey: 'Secret 密钥', cacheRefresh: { urls: [ 'https://foo.bar/about.html', 'https://foo.bar/sitemap.html' // 更多 url ], dirs: [ 'https://foo.bar/images', 'htt
使用七牛云做图片服务器（Java代码）
秃头哥编程
12-30 2689
首先得去七牛云注册账号，然后去控制台创建存储空间 这里申请的是测试域名，所以只有30天的有效期，到期了图片就会被清除。所以只是供我们玩一下，真正的开发得用自己的域名。 接下来就是申请AK和SK，在个人中心 做好了这些准备，那么就可以开始写代码了。 我这里使用的是SpringBoot，这样可以省去很多配置，在这个项目中，几乎是零配置。 图片上传，这里需要两个jar包 &amp;lt;depend...
七牛 java_七牛云文件储存（java）
weixin_39980360的博客
02-20 202
七牛云文件工具类package com.xincd.cms.utils;import com.google.gson.Gson;import com.qiniu.common.QiniuException;import com.qiniu.common.Zone;import com.qiniu.http.Response;import com.qiniu.storage.BucketManage...
Java使用七牛云
wwwhhhgg的博客
05-02 720
Java使用七牛云上传图片文件并返回访问链接。
七牛云转码方式（java sdk）
11-15 575
在项目中使用七牛云的js sdk来上传视频文件，这样可以减少服务器压力，但七牛云的转码需要access token，出于安全考虑，在服务端转码比较好。以下搜集试验几种七牛云的转码。 预处理，也就是在生成token的时候policy带预处理接口。空间中只保存一份文档。官方文档参考http...
关于七牛云JavaSDK上传
u014627536的专栏
02-15 576
package com.bjb.util; import java.io.InputStream; import java.util.ArrayList; import java.util.List; import javax.crypto.Mac; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec;
Java上传图片至七牛云对象存储
m0_51079637的博客
10-28 1104
前言：该文章从注册七牛云到实现代码上传的步骤都有，若您只需要代码，请直接向下划 一、申请七牛云对象存储 申请七牛云对象存储不需要钱，免费使用！！！(我没打广告) 注册七牛云账号后进入 管理控制台 找到存储空间并新建存储空间 输入你的存储空间名，选择存储区域，以及控制访问.确定 二、绑定域名 这时你的存储空间就已经申请好了，它还需要一个访问域名用来访问空间中的内容，开始会送你一个月的域名使用期，等使用期过后你就要绑定域名了 点击绑定域名，后输入你的访问域名 其他选项默认即可 注意这里的加速域名的.
推荐开源项目：七牛云Pili流媒体云服务Java SDK
最新发布
gitblog_00094的博客
06-24 447
推荐开源项目：七牛云Pili流媒体云服务Java SDK pili-sdk-javaPili Streaming Cloud server-side library for Java项目地址:https://gitcode.com/gh_mirrors/pi/pili-sdk-java 在当今高速发展的数字时代，视频流服务已经成为互联网应用中不可或缺的一部分，无论是在线教育、直播互动还是企业会议...
七牛云存储Java SDK 7.0.8中英对照API文档
5. qiniu-java-sdk-7.0.8-javadoc-API文档-中文(简体)-英语-对照版.zip：这是经过翻译的API文档压缩包，其内容包含了中文和英文对照的文档，使得开发者能够在阅读API说明的同时，提高自己的英语阅读能力。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值