分段上传

初始化分段上传任务

使用分段上传方式传输数据前，必须先通知OBS初始化一个分段上传任务。该操作会返回一个OBS服务端创建的全局唯一标识（Upload ID），用于标识本次分段上传任务。您可以根据这个唯一标识来发起相关的操作，如取消分段上传任务、列举分段上传任务、列举已上传的段等。

您可以通过ObsClient.initiateMultipartUpload初始化一个分段上传任务：

import android.util.Log;

import com.obs.services.ObsClient;
import com.obs.services.exception.ObsException;
import com.obs.services.model.InitiateMultipartUploadRequest;
import com.obs.services.model.InitiateMultipartUploadResult;
import com.obs.services.model.ObjectMetadata;

public class InitiateMultipartUploadDemo {
    private static final String TAG = "InitiateMultipartUpload";

    public void initiateMultipartUpload() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量ACCESS_KEY_ID和SECRET_ACCESS_KEY_ID。
                // 您可以登录访问管理控制台获取访问密钥AK/SK
                String ak = System.getenv("ACCESS_KEY_ID");
                String sk = System.getenv("SECRET_ACCESS_KEY_ID");
                // endpoint填写桶所在的endpoint，此处以华北-北京四为例，其他地区请按实际情况填写
                String endPoint = "https://your-endpoint";

                // 创建ObsClient实例
                ObsClient obsClient = new ObsClient(ak, sk, endPoint);
                try {
                    // 初始化分段上传任务
                    InitiateMultipartUploadRequest request = new InitiateMultipartUploadRequest("examplebucket", "objectname");
                    // 设置对象元数据
                    ObjectMetadata metadata = new ObjectMetadata();
                    metadata.addUserMetadata("property", "property-value");
                    metadata.setContentType("text/plain");
                    request.setMetadata(metadata);

                    InitiateMultipartUploadResult result = obsClient.initiateMultipartUpload(request);
                    String uploadId = result.getUploadId();
                    Log.i(TAG, "initiateMultipartUpload successfully");
                    Log.i(TAG, "UploadId: " + uploadId);
                } catch (ObsException e) {
                    Log.e(TAG, "initiateMultipartUpload failed");
                    // 请求失败,打印http状态码
                    Log.e(TAG, "HTTP Code:" + e.getResponseCode());
                    // 请求失败,打印服务端错误码
                    Log.e(TAG, "Error Code:" + e.getErrorCode());
                    // 请求失败,打印详细错误信息
                    Log.e(TAG, "Error Message:" + e.getErrorMessage());
                    // 请求失败,打印请求id
                    Log.e(TAG, "Request ID:" + e.getErrorRequestId());
                    Log.e(TAG, "Host ID:" + e.getErrorHostId());
                } catch (Exception e) {
                    Log.e(TAG, "initiateMultipartUpload failed");
                    // 其他异常信息打印
                    Log.e(TAG, e.getMessage());
                } finally {
                    try {
                        obsClient.close();
                    } catch (Exception e) {
                        // 忽略关闭异常
                    }
                }
            }
        }).start();
    }
}

• 用InitiateMultipartUploadRequest指定上传对象的名称和所属桶。
• 在InitiateMultipartUploadRequest中，您可以设置对象MIME类型、对象存储类型、对象自定义元数据等对象属性。
• InitiateMultipartUploadResult.getUploadId返回分段上传任务的全局唯一标识（Upload ID），在后面的操作中将用到它。
• 由于 HTTP 编码规范限制，无法发送非 ASCII 码字符，SDK 会在发送请求时对您头域中的中文汉字进行 url 编码，发送编码后数据。如您设置的值 content-disposition 为“attachment; filename="中文.txt"” ，则对象元数据中存储的信息为“attachment; filename="%E4%B8%AD%E6%96%87.txt"”。使用浏览器访问时浏览器将会自动解码。
• 如果不需要 SDK 帮您编码，可以调用 InitiateMultipartUploadRequest.setIsEncodeHeaders(false) 关闭自动编码。

上传段

初始化一个分段上传任务之后，可以根据指定的对象名和Upload ID来分段上传数据。每一个上传的段都有一个标识它的号码——分段号（Part Number，范围是1~10000）。对于同一个Upload ID，该分段号不但唯一标识这一段数据，也标识了这段数据在整个对象内的相对位置。如果您用同一个分段号上传了新的数据，那么OBS上已有的这个段号的数据将被覆盖。除了最后一段以外，其他段的大小范围是100KB~5GB；最后段大小范围是0~5GB。每个段不需要按顺序上传，甚至可以在不同进程、不同机器上上传，OBS会按照分段号排序组成最终对象。

您可以通过ObsClient.uploadPart上传段：

import android.util.Log;

import com.obs.services.ObsClient;
import com.obs.services.exception.ObsException;
import com.obs.services.model.PartEtag;
import com.obs.services.model.UploadPartRequest;
import com.obs.services.model.UploadPartResult;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class UploadPartDemo {
    private static final String TAG = "UploadPart";

    public void uploadPart() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量ACCESS_KEY_ID和SECRET_ACCESS_KEY_ID。
                // 您可以登录访问管理控制台获取访问密钥AK/SK
                String ak = System.getenv("ACCESS_KEY_ID");
                String sk = System.getenv("SECRET_ACCESS_KEY_ID");
                // endpoint填写桶所在的endpoint，此处以华北-北京四为例，其他地区请按实际情况填写
                String endPoint = "https://your-endpoint";
                // uploadId从初始化分段上传任务中获得
                String uploadId = "upload id from initiateMultipartUpload";

                // 创建ObsClient实例
                ObsClient obsClient = new ObsClient(ak, sk, endPoint);
                try {
                    List<PartEtag> partEtags = new ArrayList<PartEtag>();

                    // 上传第一段
                    UploadPartRequest request = new UploadPartRequest("examplebucket", "objectname");
                    // 设置Upload ID
                    request.setUploadId(uploadId);
                    // 设置分段号，范围是1~10000
                    request.setPartNumber(1);
                    // 设置将要上传的大文件，其中localfile为待上传的本地文件路径，需要指定到具体的文件名
                    request.setFile(new File("/sdcard/Download/localfile.txt"));
                    // 设置分段大小
                    request.setPartSize(5 * 1024 * 1024L);
                    UploadPartResult result = obsClient.uploadPart(request);
                    partEtags.add(new PartEtag(result.getEtag(), result.getPartNumber()));

                    // 上传第二段
                    request = new UploadPartRequest("examplebucket", "objectname");
                    // 设置Upload ID
                    request.setUploadId(uploadId);
                    // 设置分段号
                    request.setPartNumber(2);
                    // 设置将要上传的大文件
                    request.setFile(new File("/sdcard/Download/localfile.txt"));
                    // 设置第二段的段偏移量
                    request.setOffset(5 * 1024 * 1024L);
                    // 设置分段大小
                    request.setPartSize(5 * 1024 * 1024L);
                    result = obsClient.uploadPart(request);
                    partEtags.add(new PartEtag(result.getEtag(), result.getPartNumber()));

                    Log.i(TAG, "uploadPart successfully");
                    Log.i(TAG, "Part count: " + partEtags.size());
                } catch (ObsException e) {
                    Log.e(TAG, "uploadPart failed");
                    // 请求失败,打印http状态码
                    Log.e(TAG, "HTTP Code:" + e.getResponseCode());
                    // 请求失败,打印服务端错误码
                    Log.e(TAG, "Error Code:" + e.getErrorCode());
                    // 请求失败,打印详细错误信息
                    Log.e(TAG, "Error Message:" + e.getErrorMessage());
                    // 请求失败,打印请求id
                    Log.e(TAG, "Request ID:" + e.getErrorRequestId());
                    Log.e(TAG, "Host ID:" + e.getErrorHostId());
                } catch (Exception e) {
                    Log.e(TAG, "uploadPart failed");
                    // 其他异常信息打印
                    Log.e(TAG, e.getMessage());
                } finally {
                    try {
                        obsClient.close();
                    } catch (Exception e) {
                        // 忽略关闭异常
                    }
                }
            }
        }).start();
    }
}

• 上传段接口要求除最后一段以外，其他的段大小都要大于100KB。但是上传段接口并不会立即校验上传段的大小（因为不知道是否为最后一块）；只有调用合并段接口时才会校验。
• OBS会将服务端收到段数据的ETag值（段数据的MD5值）返回给用户。
• 为了保证数据在网络传输过程中不出现错误，可以通过设置UploadPartRequest.setAttachMd5为true来让SDK自动计算每段数据的MD5值（仅在数据源为本地文件时有效），并放到Content-MD5请求头中；OBS服务端会计算上传数据的MD5值与SDK计算的MD5值比较，保证数据完整性。
• 可以通过UploadPartRequest.setContentMd5直接设置上传数据的MD5值，提供给OBS服务端用于校验数据完整性。如果设置了该值，UploadPartRequest.setAttachMd5参数会被忽略。
• 分段号的范围是1~10000。如果超出这个范围，OBS将返回400 Bad Request错误。

合并段

所有分段上传完成后，需要调用合并段接口在OBS服务端生成最终对象。在执行该操作时，需要提供所有有效的分段列表（包括分段号和分段ETag值）；OBS收到提交的分段列表后，会逐一验证每个段的有效性。当所有段验证通过后，OBS将把这些分段组合成最终的对象。

您可以通过ObsClient.completeMultipartUpload合并段：

import android.util.Log;

import com.obs.services.ObsClient;
import com.obs.services.exception.ObsException;
import com.obs.services.model.CompleteMultipartUploadRequest;
import com.obs.services.model.CompleteMultipartUploadResult;
import com.obs.services.model.PartEtag;

import java.util.ArrayList;
import java.util.List;

public class CompleteMultipartUploadDemo {
    private static final String TAG = "CompleteMultipartUpload";

    public void completeMultipartUpload() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量ACCESS_KEY_ID和SECRET_ACCESS_KEY_ID。
                // 您可以登录访问管理控制台获取访问密钥AK/SK
                String ak = System.getenv("ACCESS_KEY_ID");
                String sk = System.getenv("SECRET_ACCESS_KEY_ID");
                // endpoint填写桶所在的endpoint，此处以华北-北京四为例，其他地区请按实际情况填写
                String endPoint = "https://your-endpoint";
                // uploadId从初始化分段上传任务中获得
                String uploadId = "upload id from initiateMultipartUpload";

                // 创建ObsClient实例
                ObsClient obsClient = new ObsClient(ak, sk, endPoint);
                try {
                    List<PartEtag> partEtags = new ArrayList<PartEtag>();

                    // 第一段
                    PartEtag part1 = new PartEtag();
                    part1.setPartNumber(1);
                    part1.seteTag("etag1");
                    partEtags.add(part1);

                    // 第二段
                    PartEtag part2 = new PartEtag();
                    part2.setPartNumber(2);
                    part2.seteTag("etag2");
                    partEtags.add(part2);

                    CompleteMultipartUploadRequest request = new CompleteMultipartUploadRequest("examplebucket", "objectname", uploadId, partEtags);

                    CompleteMultipartUploadResult result = obsClient.completeMultipartUpload(request);
                    Log.i(TAG, "completeMultipartUpload successfully");
                    Log.i(TAG, "ETag: " + result.getEtag());
                } catch (ObsException e) {
                    Log.e(TAG, "completeMultipartUpload failed");
                    // 请求失败,打印http状态码
                    Log.e(TAG, "HTTP Code:" + e.getResponseCode());
                    // 请求失败,打印服务端错误码
                    Log.e(TAG, "Error Code:" + e.getErrorCode());
                    // 请求失败,打印详细错误信息
                    Log.e(TAG, "Error Message:" + e.getErrorMessage());
                    // 请求失败,打印请求id
                    Log.e(TAG, "Request ID:" + e.getErrorRequestId());
                    Log.e(TAG, "Host ID:" + e.getErrorHostId());
                } catch (Exception e) {
                    Log.e(TAG, "completeMultipartUpload failed");
                    // 其他异常信息打印
                    Log.e(TAG, e.getMessage());
                } finally {
                    try {
                        obsClient.close();
                    } catch (Exception e) {
                        // 忽略关闭异常
                    }
                }
            }
        }).start();
    }
}

• 上面代码中的 partEtags是进行上传段后保存的分段号和分段ETag值的列表，它必须是按分段号升序排列。
• 分段可以是不连续的。

并发分段上传

分段上传的主要目的是解决大文件上传或网络条件较差的情况。下面的示例代码展示了如何使用分段上传并发上传大文件：

import android.util.Log;
import com.obs.services.ObsClient;
import com.obs.services.exception.ObsException;
import com.obs.services.model.CompleteMultipartUploadRequest;
import com.obs.services.model.CompleteMultipartUploadResult;
import com.obs.services.model.InitiateMultipartUploadRequest;
import com.obs.services.model.InitiateMultipartUploadResult;
import com.obs.services.model.PartEtag;
import com.obs.services.model.UploadPartRequest;
import com.obs.services.model.UploadPartResult;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ConcurrentUploadPartDemo {
    private static final String TAG = "ConcurrentUploadPart";

    public void concurrentUploadPart() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量ACCESS_KEY_ID和SECRET_ACCESS_KEY_ID。
                // 您可以登录访问管理控制台获取访问密钥AK/SK
                String ak = System.getenv("ACCESS_KEY_ID");
                String sk = System.getenv("SECRET_ACCESS_KEY_ID");
                // endpoint填写桶所在的endpoint，此处以华北-北京四为例，其他地区请按实际情况填写
                String endPoint = "https://your-endpoint";
                final String bucketName = "examplebucket";
                final String objectKey = "objectname";

                // 创建ObsClient实例
                final ObsClient obsClient = new ObsClient(ak, sk, endPoint);

                // 初始化线程池
                ExecutorService executorService = Executors.newFixedThreadPool(20);
                final File largeFile = new File("/sdcard/Download/largefile.txt");

                try {
                    // 初始化分段上传任务
                    InitiateMultipartUploadRequest request = new InitiateMultipartUploadRequest(bucketName, objectKey);
                    InitiateMultipartUploadResult result = obsClient.initiateMultipartUpload(request);

                    final String uploadId = result.getUploadId();
                    Log.i(TAG, "UploadId: " + uploadId);

                    // 每段上传100MB
                    long partSize = 100 * 1024 * 1024L;
                    long fileSize = largeFile.length();

                    // 计算需要上传的段数
                    long partCount = fileSize % partSize == 0 ? fileSize / partSize : fileSize / partSize + 1;

                    final List<PartEtag> partEtags = Collections.synchronizedList(new ArrayList<PartEtag>());

                    // 执行并发上传段
                    for (int i = 0; i < partCount; i++) {
                        // 分段在文件中的起始位置
                        final long offset = i * partSize;
                        // 分段大小
                        final long currPartSize = (i + 1 == partCount) ? fileSize - offset : partSize;
                        // 分段号
                        final int partNumber = i + 1;
                        executorService.execute(new Runnable() {
                            @Override
                            public void run() {
                                UploadPartRequest uploadPartRequest = new UploadPartRequest();
                                uploadPartRequest.setBucketName(bucketName);
                                uploadPartRequest.setObjectKey(objectKey);
                                uploadPartRequest.setUploadId(uploadId);
                                uploadPartRequest.setFile(largeFile);
                                uploadPartRequest.setPartSize(currPartSize);
                                uploadPartRequest.setOffset(offset);
                                uploadPartRequest.setPartNumber(partNumber);

                                try {
                                    UploadPartResult uploadPartResult = obsClient.uploadPart(uploadPartRequest);
                                    Log.i(TAG, "Part#" + partNumber + " done");
                                    partEtags.add(new PartEtag(uploadPartResult.getEtag(), uploadPartResult.getPartNumber()));
                                } catch (ObsException e) {
                                    Log.e(TAG, "Part#" + partNumber + " failed", e);
                                    Log.e(TAG, "HTTP Code: " + e.getResponseCode());
                                    Log.e(TAG, "Error Code: " + e.getErrorCode());
                                    Log.e(TAG, "Error Message: " + e.getErrorMessage());
                                    Log.e(TAG, "Request ID: " + e.getErrorRequestId());
                                    Log.e(TAG, "Host ID: " + e.getErrorHostId());
                                }
                            }
                        });
                    }

                    // 等待上传完成
                    executorService.shutdown();
                    while (!executorService.isTerminated()) {
                        try {
                            executorService.awaitTermination(5, TimeUnit.SECONDS);
                        } catch (InterruptedException e) {
                            Log.e(TAG, "awaitTermination interrupted", e);
                        }
                    }

                    // 合并段
                    CompleteMultipartUploadRequest completeMultipartUploadRequest =
                            new CompleteMultipartUploadRequest(bucketName, objectKey, uploadId, partEtags);
                    CompleteMultipartUploadResult completeResult =
                            obsClient.completeMultipartUpload(completeMultipartUploadRequest);
                    Log.i(TAG, "ConcurrentUploadPart successfully");
                    Log.i(TAG, "ETag: " + completeResult.getEtag());
                } catch (ObsException e) {
                    Log.e(TAG, "ConcurrentUploadPart failed");
                    Log.e(TAG, "HTTP Code: " + e.getResponseCode());
                    Log.e(TAG, "Error Code: " + e.getErrorCode());
                    Log.e(TAG, "Error Message: " + e.getErrorMessage());
                    Log.e(TAG, "Request ID: " + e.getErrorRequestId());
                    Log.e(TAG, "Host ID: " + e.getErrorHostId());
                } catch (Exception e) {
                    Log.e(TAG, "ConcurrentUploadPart failed: " + e.getMessage());
                    e.printStackTrace();
                } finally {
                    try {
                        obsClient.close();
                    } catch (Exception e) {
                        // 忽略关闭异常
                    }
                }
            }
        }).start();
    }
}

取消分段上传任务

分段上传任务可以被取消，当一个分段上传任务被取消后，就不能再使用其Upload ID做任何操作，已经上传段也会被OBS删除。

采用分段上传方式上传对象过程中或上传对象失败后会在桶内产生段，这些段会占用您的存储空间，您可以通过取消该分段上传任务来清理掉不需要的段，节约存储空间。

您可以通过ObsClient.abortMultipartUpload取消分段上传任务：

import android.util.Log;
import com.obs.services.ObsClient;
import com.obs.services.exception.ObsException;
import com.obs.services.model.AbortMultipartUploadRequest;
import com.obs.services.model.HeaderResponse;

public class AbortMultipartUploadDemo {
    private static final String TAG = "AbortMultipartUpload";

    public void abortMultipartUpload() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量ACCESS_KEY_ID和SECRET_ACCESS_KEY_ID。
                // 您可以登录访问管理控制台获取访问密钥AK/SK
                String ak = System.getenv("ACCESS_KEY_ID");
                String sk = System.getenv("SECRET_ACCESS_KEY_ID");
                // endpoint填写桶所在的endpoint，此处以华北-北京四为例，其他地区请按实际情况填写
                String endPoint = "https://your-endpoint";

                // 创建ObsClient实例
                ObsClient obsClient = new ObsClient(ak, sk, endPoint);
                try {
                    String uploadId = "upload id from initiateMultipartUpload";
                    AbortMultipartUploadRequest request =
                            new AbortMultipartUploadRequest("examplebucket", "objectname", uploadId);
                    HeaderResponse response = obsClient.abortMultipartUpload(request);
                    Log.i(TAG, "AbortMultipartUpload successfully");
                    Log.i(TAG, "HTTP Code:" + response.getStatusCode());
                } catch (ObsException e) {
                    Log.e(TAG, "AbortMultipartUpload failed");
                    Log.e(TAG, "HTTP Code:" + e.getResponseCode());
                    Log.e(TAG, "Error Code:" + e.getErrorCode());
                    Log.e(TAG, "Error Message:" + e.getErrorMessage());
                    Log.e(TAG, "Request ID:" + e.getErrorRequestId());
                    Log.e(TAG, "Host ID:" + e.getErrorHostId());
                } catch (Exception e) {
                    Log.e(TAG, "AbortMultipartUpload failed");
                    Log.e(TAG, e.getMessage());
                } finally {
                    try {
                        obsClient.close();
                    } catch (Exception e) {
                        // 忽略关闭异常
                    }
                }
            }
        }).start();
    }
}

列举已上传的段

您可使用ObsClient.listParts列举出某一分段上传任务所有已经上传成功的段。

该接口可设置的参数如下：

• 简单列举

import android.util.Log;
import com.obs.services.ObsClient;
import com.obs.services.exception.ObsException;
import com.obs.services.model.ListPartsRequest;
import com.obs.services.model.ListPartsResult;
import com.obs.services.model.Multipart;

public class ListPartsDemo {
    private static final String TAG = "ListParts";

    public void listParts() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量ACCESS_KEY_ID和SECRET_ACCESS_KEY_ID。
                // 您可以登录访问管理控制台获取访问密钥AK/SK
                String ak = System.getenv("ACCESS_KEY_ID");
                String sk = System.getenv("SECRET_ACCESS_KEY_ID");
                String endPoint = "https://your-endpoint";

                ObsClient obsClient = new ObsClient(ak, sk, endPoint);
                try {
                    String uploadId = "upload id from initiateMultipartUpload";
                    // 列举已上传的段，其中uploadId来自于initiateMultipartUpload
                    ListPartsRequest request = new ListPartsRequest("examplebucket", "objectname");
                    request.setUploadId(uploadId);
                    ListPartsResult result = obsClient.listParts(request);

                    for (Multipart part : result.getMultipartList()) {
                        // 分段号，上传时候指定
                        Log.i(TAG, "PartNumber: " + part.getPartNumber());
                        // 段数据大小
                        Log.i(TAG, "Size: " + part.getSize());
                        // 分段的ETag值
                        Log.i(TAG, "ETag: " + part.getEtag());
                        // 段的最后上传时间
                        Log.i(TAG, "LastModified: " + part.getLastModified());
                    }
                    Log.i(TAG, "ListParts successfully");
                } catch (ObsException e) {
                    Log.e(TAG, "ListParts failed");
                    Log.e(TAG, "HTTP Code:" + e.getResponseCode());
                    Log.e(TAG, "Error Code:" + e.getErrorCode());
                    Log.e(TAG, "Error Message:" + e.getErrorMessage());
                    Log.e(TAG, "Request ID:" + e.getErrorRequestId());
                    Log.e(TAG, "Host ID:" + e.getErrorHostId());
                } catch (Exception e) {
                    Log.e(TAG, "ListParts failed");
                    Log.e(TAG, e.getMessage());
                } finally {
                    try {
                        obsClient.close();
                    } catch (Exception e) {
                        // 忽略关闭异常
                    }
                }
            }
        }).start();
    }
}

• 列举段至多返回1000个段信息，如果指定的Upload ID包含的段数量大于1000，则返回结果中ListPartsResult.isTruncated为true表明本次没有返回全部段，并可通过ListPartsResult.getNextPartNumberMarker获取下次列举的起始位置。
• 如果想获取指定Upload ID包含的所有分段，可以采用分页列举的方式。

• 列举所有段

由于ObsClient.listParts只能列举至多1000个段，如果段数量大于1000，列举所有分段请参考如下示例：

import android.util.Log;
import com.obs.services.ObsClient;
import com.obs.services.exception.ObsException;
import com.obs.services.model.ListPartsRequest;
import com.obs.services.model.ListPartsResult;
import com.obs.services.model.Multipart;

public class ListAllPartsDemo {
    private static final String TAG = "ListAllParts";

    public void listAllParts() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量ACCESS_KEY_ID和SECRET_ACCESS_KEY_ID。
                // 您可以登录访问管理控制台获取访问密钥AK/SK
                String ak = System.getenv("ACCESS_KEY_ID");
                String sk = System.getenv("SECRET_ACCESS_KEY_ID");
                String endPoint = "https://your-endpoint";

                ObsClient obsClient = new ObsClient(ak, sk, endPoint);
                try {
                    String uploadId = "upload id from initiateMultipartUpload";
                    // 列举所有已上传的段，其中uploadId来自于initiateMultipartUpload
                    ListPartsRequest request = new ListPartsRequest("examplebucket", "objectname");
                    request.setUploadId(uploadId);
                    ListPartsResult result;

                    do {
                        result = obsClient.listParts(request);
                        for (Multipart part : result.getMultipartList()) {
                            // 分段号，上传时候指定
                            Log.i(TAG, "PartNumber: " + part.getPartNumber());
                            // 段数据大小
                            Log.i(TAG, "Size: " + part.getSize());
                            // 分段的ETag值
                            Log.i(TAG, "ETag: " + part.getEtag());
                            // 段的最后上传时间
                            Log.i(TAG, "LastModified: " + part.getLastModified());
                        }
                        request.setPartNumberMarker(Integer.parseInt(result.getNextPartNumberMarker()));
                    } while (result.isTruncated());

                    Log.i(TAG, "ListAllParts successfully");
                } catch (ObsException e) {
                    Log.e(TAG, "ListAllParts failed");
                    Log.e(TAG, "HTTP Code:" + e.getResponseCode());
                    Log.e(TAG, "Error Code:" + e.getErrorCode());
                    Log.e(TAG, "Error Message:" + e.getErrorMessage());
                    Log.e(TAG, "Request ID:" + e.getErrorRequestId());
                    Log.e(TAG, "Host ID:" + e.getErrorHostId());
                } catch (Exception e) {
                    Log.e(TAG, "ListAllParts failed");
                    Log.e(TAG, e.getMessage());
                } finally {
                    try {
                        obsClient.close();
                    } catch (Exception e) {
                        // 忽略关闭异常
                    }
                }
            }
        }).start();
    }
}

列举分段上传任务

您可以通过ObsClient.listMultipartUploads列举分段上传任务。列举分段上传任务可设置的参数如下：

• 简单列举分段上传任务

import android.util.Log;
import com.obs.services.ObsClient;
import com.obs.services.exception.ObsException;
import com.obs.services.model.ListMultipartUploadsRequest;
import com.obs.services.model.MultipartUpload;
import com.obs.services.model.MultipartUploadListing;

public class ListMultipartUploadsDemo {
    private static final String TAG = "ListMultipartUploads";

    public void listMultipartUploads() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量ACCESS_KEY_ID和SECRET_ACCESS_KEY_ID。
                // 您可以登录访问管理控制台获取访问密钥AK/SK
                String ak = System.getenv("ACCESS_KEY_ID");
                String sk = System.getenv("SECRET_ACCESS_KEY_ID");
                String endPoint = "https://your-endpoint";

                ObsClient obsClient = new ObsClient(ak, sk, endPoint);
                try {
                    ListMultipartUploadsRequest request =
                            new ListMultipartUploadsRequest("examplebucket");

                    MultipartUploadListing result = obsClient.listMultipartUploads(request);
                    for (MultipartUpload upload : result.getMultipartTaskList()) {
                        Log.i(TAG, "UploadId: " + upload.getUploadId());
                        Log.i(TAG, "ObjectKey: " + upload.getObjectKey());
                        Log.i(TAG, "InitiatedDate: " + upload.getInitiatedDate());
                    }
                    Log.i(TAG, "ListMultipartUploads successfully");
                } catch (ObsException e) {
                    Log.e(TAG, "ListMultipartUploads failed");
                    Log.e(TAG, "HTTP Code:" + e.getResponseCode());
                    Log.e(TAG, "Error Code:" + e.getErrorCode());
                    Log.e(TAG, "Error Message:" + e.getErrorMessage());
                    Log.e(TAG, "Request ID:" + e.getErrorRequestId());
                    Log.e(TAG, "Host ID:" + e.getErrorHostId());
                } catch (Exception e) {
                    Log.e(TAG, "ListMultipartUploads failed");
                    Log.e(TAG, e.getMessage());
                } finally {
                    try {
                        obsClient.close();
                    } catch (Exception e) {
                        // 忽略关闭异常
                    }
                }
            }
        }).start();
    }
}

• 列举分段上传任务至多返回1000个任务信息，如果指定的桶包含的分段上传任务数量大于1000，则MultipartUploadListing.isTruncated为true表明本次没有返回全部结果，并可通过MultipartUploadListing.getNextKeyMarker和MultipartUploadListing.getNextUploadIdMarker获取下次列举的起点。
• 如果想获取指定桶包含的所有分段上传任务，可以采用分页列举的方式。

• 分页列举全部分段上传任务

import android.util.Log;
import com.obs.services.ObsClient;
import com.obs.services.exception.ObsException;
import com.obs.services.model.ListMultipartUploadsRequest;
import com.obs.services.model.MultipartUpload;
import com.obs.services.model.MultipartUploadListing;

public class ListAllMultipartUploadsDemo {
    private static final String TAG = "ListAllMultipartUploads";

    public void listAllMultipartUploads() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量ACCESS_KEY_ID和SECRET_ACCESS_KEY_ID。
                // 您可以登录访问管理控制台获取访问密钥AK/SK
                String ak = System.getenv("ACCESS_KEY_ID");
                String sk = System.getenv("SECRET_ACCESS_KEY_ID");
                String endPoint = "https://your-endpoint";

                ObsClient obsClient = new ObsClient(ak, sk, endPoint);
                try {
                    ListMultipartUploadsRequest request =
                            new ListMultipartUploadsRequest("examplebucket");
                    MultipartUploadListing result;

                    do {
                        result = obsClient.listMultipartUploads(request);
                        for (MultipartUpload upload : result.getMultipartTaskList()) {
                            Log.i(TAG, "UploadId: " + upload.getUploadId());
                            Log.i(TAG, "ObjectKey: " + upload.getObjectKey());
                            Log.i(TAG, "InitiatedDate: " + upload.getInitiatedDate());
                        }
                        request.setKeyMarker(result.getNextKeyMarker());
                        request.setUploadIdMarker(result.getNextUploadIdMarker());
                    } while (result.isTruncated());

                    Log.i(TAG, "ListAllMultipartUploads successfully");
                } catch (ObsException e) {
                    Log.e(TAG, "ListAllMultipartUploads failed");
                    Log.e(TAG, "HTTP Code:" + e.getResponseCode());
                    Log.e(TAG, "Error Code:" + e.getErrorCode());
                    Log.e(TAG, "Error Message:" + e.getErrorMessage());
                    Log.e(TAG, "Request ID:" + e.getErrorRequestId());
                    Log.e(TAG, "Host ID:" + e.getErrorHostId());
                } catch (Exception e) {
                    Log.e(TAG, "ListAllMultipartUploads failed");
                    Log.e(TAG, e.getMessage());
                } finally {
                    try {
                        obsClient.close();
                    } catch (Exception e) {
                        // 忽略关闭异常
                    }
                }
            }
        }).start();
    }
}