文档中心

删除对象（Java SDK）

最近更新时间：2024.02.04 18:30:54

首次发布时间：2021.11.27 17:58:44

当对象不再使用时，您可以删除对象，降低成本开销。TOS Java SDK 支持删除桶中的单个对象、删除指定的多个对象。对于开启多版本的桶，您可删除对象的指定版本数据。

注意事项

要删除对象，您的账号必须具备 tos:DeleteObject 权限，具体操作，请参见权限配置指南。
要删除多版本对象，您的账号必须具备tos:DeleteObjectVersion权限，具体操作，请参见权限配置指南。
请您谨慎使用删除操作，文件删除后将无法恢复。

示例代码

删除指定对象

以下代码展示如何删除指定桶 bucket-example 中的 example_dir 目录下的 example_object.txt 文件。

import com.volcengine.tos.TOSV2;
import com.volcengine.tos.TOSV2ClientBuilder;
import com.volcengine.tos.TosClientException;
import com.volcengine.tos.TosServerException;
import com.volcengine.tos.model.object.DeleteObjectInput;
import com.volcengine.tos.model.object.DeleteObjectOutput;

public class DeleteObjectExample {
    public static void main(String[] args) {
        String endpoint = "your endpoint";
        String region = "your region";
        String accessKey = System.getenv("TOS_ACCESS_KEY");
        String secretKey = System.getenv("TOS_SECRET_KEY");

        String bucketName = "bucket-example";
        String objectKey = "example_dir/example_object.txt";

        TOSV2 tos = new TOSV2ClientBuilder().build(region, endpoint, accessKey, secretKey);

        try{
            DeleteObjectInput input = new DeleteObjectInput().setBucket(bucketName).setKey(objectKey);
            DeleteObjectOutput output = tos.deleteObject(input);
            System.out.println("deleteObject succeed.");
        } catch (TosClientException e) {
            // 操作失败，捕获客户端异常，一般情况是请求参数错误，此时请求并未发送
            System.out.println("deleteObject failed");
            System.out.println("Message: " + e.getMessage());
            if (e.getCause() != null) {
                e.getCause().printStackTrace();
            }
        } catch (TosServerException e) {
            // 操作失败，捕获服务端异常，可以获取到从服务端返回的详细错误信息
            System.out.println("deleteObject failed");
            System.out.println("StatusCode: " + e.getStatusCode());
            System.out.println("Code: " + e.getCode());
            System.out.println("Message: " + e.getMessage());
            System.out.println("RequestID: " + e.getRequestID());
        } catch (Throwable t) {
            // 作为兜底捕获其他异常，一般不会执行到这里
            System.out.println("deleteObject failed");
            System.out.println("unexpected exception, message: " + t.getMessage());
        }
    }
}

删除指定版本对象

以下代码展示如何指定版本号删除多版本桶 bucket-example 中的 example_dir 目录下的 example_object.txt 文件。

import com.volcengine.tos.TOSV2;
import com.volcengine.tos.TOSV2ClientBuilder;
import com.volcengine.tos.TosClientException;
import com.volcengine.tos.TosServerException;
import com.volcengine.tos.model.object.DeleteObjectInput;
import com.volcengine.tos.model.object.DeleteObjectOutput;

public class DeleteObjectWithVersionIdExample {
    public static void main(String[] args) {
        String endpoint = "your endpoint";
        String region = "your region";
        String accessKey = System.getenv("TOS_ACCESS_KEY");
        String secretKey = System.getenv("TOS_SECRET_KEY");

        String bucketName = "bucket-example";
        String objectKey = "example_dir/example_object.txt";
        // 对象版本号，最新版本可以通过 headObject 接口获取
        // 如果需要获取对象的历史版本号，可以通过 listObjectVersions 接口获取
        String versionId = "the specific version id";

        TOSV2 tos = new TOSV2ClientBuilder().build(region, endpoint, accessKey, secretKey);

        try{
            DeleteObjectInput input = new DeleteObjectInput().setBucket(bucketName).setKey(objectKey).setVersionID(versionId);
            DeleteObjectOutput output = tos.deleteObject(input);
            System.out.println("deleteObject succeed.");
            System.out.println("is the object a delete marker? " + output.isDeleteMarker());
            System.out.println("the deleted version id is " + output.getVersionID());
        } catch (TosClientException e) {
            // 操作失败，捕获客户端异常，一般情况是请求参数错误，此时请求并未发送
            System.out.println("deleteObject failed");
            System.out.println("Message: " + e.getMessage());
            if (e.getCause() != null) {
                e.getCause().printStackTrace();
            }
        } catch (TosServerException e) {
            // 操作失败，捕获服务端异常，可以获取到从服务端返回的详细错误信息
            System.out.println("deleteObject failed");
            System.out.println("StatusCode: " + e.getStatusCode());
            System.out.println("Code: " + e.getCode());
            System.out.println("Message: " + e.getMessage());
            System.out.println("RequestID: " + e.getRequestID());
        } catch (Throwable t) {
            // 作为兜底捕获其他异常，一般不会执行到这里
            System.out.println("deleteObject failed");
            System.out.println("unexpected exception, message: " + t.getMessage());
        }
    }
}

批量删除对象

您可以通过 Java SDK 的 deleteMultiObjects 接口在一次请求中删除多个对象。以下代码展示如何删除指定桶 bucket-example 中的多个对象。

说明

批量删除对象支持的响应方式可以通过quiet进行设置：

quiet为false时，是指在返回响应时，不管对象是否删除成功都将删除结果包含在响应里。
quiet为true时，是指在返回响应时，只返回删除失败的对象结果，没有返回的认为删除成功。

import com.volcengine.tos.TOSV2;
import com.volcengine.tos.TOSV2ClientBuilder;
import com.volcengine.tos.TosClientException;
import com.volcengine.tos.TosServerException;
import com.volcengine.tos.model.object.*;

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

public class DeleteMultiObjectsExample {
    public static void main(String[] args) {
        String endpoint = "your endpoint";
        String region = "your region";
        String accessKey = System.getenv("TOS_ACCESS_KEY");
        String secretKey = System.getenv("TOS_SECRET_KEY");

        String bucketName = "bucket-example";
        String objectKey = "example_dir/example_object.txt";
        String objectKey1 = "example_dir/example_object_1.txt";
        String objectKey2 = "example_dir/example_object_2.txt";

        TOSV2 tos = new TOSV2ClientBuilder().build(region, endpoint, accessKey, secretKey);

        try{
            List<ObjectTobeDeleted> objs = new ArrayList<>();
            objs.add(new ObjectTobeDeleted().setKey(objectKey));
            objs.add(new ObjectTobeDeleted().setKey(objectKey1));
            objs.add(new ObjectTobeDeleted().setKey(objectKey2));
            DeleteMultiObjectsV2Input input = new DeleteMultiObjectsV2Input().setBucket(bucketName).setObjects(objs);
            DeleteMultiObjectsV2Output output = tos.deleteMultiObjects(input);
            System.out.println("deleteMultiObjects succeed.");
            if (output.getDeleteds() != null) {
                for (int i = 0; i < output.getDeleteds().size(); i++){
                    Deleted deleted = output.getDeleteds().get(i);
                    System.out.println("deleted object is " + deleted);
                }
            }
            if (output.getErrors() != null) {
                for (int i = 0; i < output.getErrors().size(); i++){
                    DeleteError error = output.getErrors().get(i);
                    System.out.println("delete error is " + error);
                }
            }
        } catch (TosClientException e) {
            // 操作失败，捕获客户端异常，一般情况是请求参数错误，此时请求并未发送
            System.out.println("deleteMultiObjects failed");
            System.out.println("Message: " + e.getMessage());
            if (e.getCause() != null) {
                e.getCause().printStackTrace();
            }
        } catch (TosServerException e) {
            // 操作失败，捕获服务端异常，可以获取到从服务端返回的详细错误信息
            System.out.println("deleteMultiObjects failed");
            System.out.println("StatusCode: " + e.getStatusCode());
            System.out.println("Code: " + e.getCode());
            System.out.println("Message: " + e.getMessage());
            System.out.println("RequestID: " + e.getRequestID());
        } catch (Throwable t) {
            // 作为兜底捕获其他异常，一般不会执行到这里
            System.out.println("deleteMultiObjects failed");
            System.out.println("unexpected exception, message: " + t.getMessage());
        }
    }
}

批量删除带版本的对象

以下代码展示如何携带版本号删除指定桶 bucket-example 中的多个对象。

import com.volcengine.tos.TOSV2;
import com.volcengine.tos.TOSV2ClientBuilder;
import com.volcengine.tos.TosClientException;
import com.volcengine.tos.TosServerException;
import com.volcengine.tos.model.object.*;

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

public class DeleteMultiObjectsWithVersionsExample {
    public static void main(String[] args) {
        String endpoint = "your endpoint";
        String region = "your region";
        String accessKey = System.getenv("TOS_ACCESS_KEY");
        String secretKey = System.getenv("TOS_SECRET_KEY");

        String bucketName = "bucket-example";
        String objectKey = "example_dir/example_object.txt";
        String versionId = "the version id of objectKey";
        String objectKey1 = "example_dir/example_object_1.txt";
        String versionId1 = "the version id of objectKey1";
        String objectKey2 = "example_dir/example_object_2.txt";
        String versionId2 = "the version id of objectKey2";

        TOSV2 tos = new TOSV2ClientBuilder().build(region, endpoint, accessKey, secretKey);

        try{
            List<ObjectTobeDeleted> objs = new ArrayList<>();
            objs.add(new ObjectTobeDeleted().setKey(objectKey).setVersionID(versionId));
            objs.add(new ObjectTobeDeleted().setKey(objectKey1).setVersionID(versionId1));
            objs.add(new ObjectTobeDeleted().setKey(objectKey2).setVersionID(versionId2));
            DeleteMultiObjectsV2Input input = new DeleteMultiObjectsV2Input().setBucket(bucketName).setObjects(objs);
            DeleteMultiObjectsV2Output output = tos.deleteMultiObjects(input);
            System.out.println("deleteMultiObjects succeed.");
            if (output.getDeleteds() != null) {
                for (int i = 0; i < output.getDeleteds().size(); i++){
                    Deleted deleted = output.getDeleteds().get(i);
                    System.out.println("deleted object is " + deleted);
                }
            }
            if (output.getErrors() != null) {
                for (int i = 0; i < output.getErrors().size(); i++){
                    DeleteError error = output.getErrors().get(i);
                    System.out.println("delete error is " + error);
                }
            }
        } catch (TosClientException e) {
            // 操作失败，捕获客户端异常，一般情况是请求参数错误，此时请求并未发送
            System.out.println("deleteMultiObjects failed");
            System.out.println("Message: " + e.getMessage());
            if (e.getCause() != null) {
                e.getCause().printStackTrace();
            }
        } catch (TosServerException e) {
            // 操作失败，捕获服务端异常，可以获取到从服务端返回的详细错误信息
            System.out.println("deleteMultiObjects failed");
            System.out.println("StatusCode: " + e.getStatusCode());
            System.out.println("Code: " + e.getCode());
            System.out.println("Message: " + e.getMessage());
            System.out.println("RequestID: " + e.getRequestID());
        } catch (Throwable t) {
            // 作为兜底捕获其他异常，一般不会执行到这里
            System.out.println("deleteMultiObjects failed");
            System.out.println("unexpected exception, message: " + t.getMessage());
        }
    }
}

删除桶中指定前缀的对象

以下代码展示如何删除指定桶 bucket-example 中的 example_dir/ 前缀的对象。

警告

以下代码中如果不设置 prefix 参数（即 prefix 为 null）或设置 prefix = "" 空字符串，将会删除桶中所有对象数据，请谨慎检查使用！

import com.volcengine.tos.TOSV2;
import com.volcengine.tos.TOSV2ClientBuilder;
import com.volcengine.tos.TosClientException;
import com.volcengine.tos.TosServerException;
import com.volcengine.tos.model.object.DeleteObjectInput;
import com.volcengine.tos.model.object.ListObjectsType2Input;
import com.volcengine.tos.model.object.ListObjectsType2Output;

public class DeleteObjectWithPrefixExample {
    public static void main(String[] args) {
        String endpoint = "your endpoint";
        String region = "your region";
        String accessKey = System.getenv("TOS_ACCESS_KEY");
        String secretKey = System.getenv("TOS_SECRET_KEY");

        String bucketName = "bucket-example";
        String prefix = "example_dir/";

        TOSV2 tos = new TOSV2ClientBuilder().build(region, endpoint, accessKey, secretKey);

        try{
            boolean isTruncated = true;
            String continuationToken = null;
            while (isTruncated) {
                ListObjectsType2Input input = new ListObjectsType2Input().setBucket(bucketName)
                        .setPrefix(prefix).setContinuationToken(continuationToken);
                ListObjectsType2Output output = tos.listObjectsType2(input);
                if (output.getContents() != null){
                    for (int i = 0; i < output.getContents().size(); i++) {
                        String objectKey = output.getContents().get(i).getKey();
                        DeleteObjectInput deleteInput = new DeleteObjectInput().setBucket(bucketName)
                                .setKey(output.getContents().get(i).getKey());
                        tos.deleteObject(deleteInput);
                        System.out.println("deleteObject succeed, deleted key is " + objectKey);
                    }
                }
                isTruncated = output.isTruncated();
                continuationToken = output.getNextContinuationToken();
            }

        } catch (TosClientException e) {
            // 操作失败，捕获客户端异常，一般情况是请求参数错误，此时请求并未发送
            System.out.println("deleteObject failed");
            System.out.println("Message: " + e.getMessage());
            if (e.getCause() != null) {
                e.getCause().printStackTrace();
            }
        } catch (TosServerException e) {
            // 操作失败，捕获服务端异常，可以获取到从服务端返回的详细错误信息
            System.out.println("deleteObject failed");
            System.out.println("StatusCode: " + e.getStatusCode());
            System.out.println("Code: " + e.getCode());
            System.out.println("Message: " + e.getMessage());
            System.out.println("RequestID: " + e.getRequestID());
        } catch (Throwable t) {
            // 作为兜底捕获其他异常，一般不会执行到这里
            System.out.println("deleteObject failed");
            System.out.println("unexpected exception, message: " + t.getMessage());
        }
    }
}

对象存储