在AmazonS3Java中删除文件、目录和存储桶

我想知道怎么做。我查看了sdk文档并提供了一些示例，但对语法的一般用法感到困惑

如果我想删除一个文件，我假设我使用

deleteObject（path，key）

。然而，“关键”是什么

另外，如何删除目录？我似乎找不到这样做的方法。

S3中的“键”类似于文件路径：

http://bucket.s3.amazonaws.com/some/path/to/use

。。。位于名为

bucket

的bucket中，其键为

some/path/to/use

但它实际上不是一个路径，因为没有文件夹。S3键只是一个大目录（整个bucket）中文件的文件名。S3键可以包含

/

，但除非您设置了

换句话说，拥有一个名为

some/object

的对象并不能告诉您有关对象

some

的任何信息（它可能存在，也可能不存在——这两个对象不相关）

但是，您可以请求具有特定前缀的密钥，因此我可以说“给我所有以

some/path/to/

开头的密钥，它将返回

some/path/to/use

。它看起来像是“列出目录”，但实际上只是请求以特定字符串开头的文件

我可以很容易地说出这样的名字：

somepathtousea
somepathtouseb

然后说“给我所有从

somethodouse

开始的东西”（它会说

somethodouse

和

somethodouseb

）

注意：S3URL的输入：

编辑：

我看了一下，这是我看到的函数签名（对于

AmazonS3Client

）：

再次编辑：

文件夹现在确实存在，作为零长度对象，其内容类型为

application/x-directory

，键以

/

结尾：

$ AWS_PROFILE=prod aws s3api head-object --bucket example-bucket --key example-directory/
{
    "AcceptRanges": "bytes",
    "LastModified": "Mon, 29 Apr 2019 14:59:36 GMT",
    "ContentLength": 0,
    "ETag": "\"d41d8cd98f00b204e9800998ecf8427e\"",
    "ContentType": "application/x-directory",
    "ServerSideEncryption": "AES256",
    "Metadata": {}
}

---

这仍然只是惯例，没有任何东西可以阻止您拥有以

/

结尾的文件或“文件夹”中不存在的文件。

您可能想看看这一点，快速了解如何从S3中删除对象

delete

的语法实际上是

deleteObject（bucketName，key）

其中bucketName是放置文件的存储桶，key是要在存储桶中删除的文件的名称

---

将bucket视为您的硬盘驱动器，如C:\、D:\等，将key视为您要删除的文件的绝对路径名。

这段代码适合我。folderPath类似于“topDir/secondDir/”

---

适合我，当心截断

    long start = System.currentTimeMillis();
    long totalSize = 0;
    int totalItems = 0;

    String key ="path/to/folder/"
    String bucket = "my-bucket"

    final ListObjectsRequest listObjectsRequest = new ListObjectsRequest().withBucketName(bucketName).withPrefix(key);

    ObjectListing objects = s3.listObjects(listObjectsRequest);
    do {
        for (S3ObjectSummary objectSummary : objects.getObjectSummaries()) {
            totalSize += objectSummary.getSize();
            totalItems++;
            s3.deleteObject(bucketName, objectSummary.getKey());
        }
        objects = s3.listNextBatchOfObjects(objects);
    } while (objects.isTruncated());

    long stop = System.currentTimeMillis();

    LOG.trace("User {} had {} items with {} Kb, took {} ms to delete", user.getName(), totalItems, totalSize / 1024, stop
            - start);

---

/*这是一个适合我的解决方案。这里Bucket_Name是我在S3上的Bucket Name，key是Bucket_Name下的路径。因此，如果S3上的绝对路径是：

s3://my_bucket/Path/to/my/folder

那么，下面的代码应该可以工作了*/

---

---

ListObjectsV2结果对我有效。请再试一次

private void deleteObjectsInFolder() {
    try {
        ListObjectsV2Result result;
        do {
            String folderPath =   " ";



            result = s3.listObjectsV2(Constants.BUCKET_NAME, folderPath);

            Log.e("count:", result.getKeyCount() + "");

            if (result.getKeyCount() != 0) {

                for (S3ObjectSummary objectSummary :
                        result.getObjectSummaries()) {
                    s3.deleteObject(Constants.BUCKET_NAME, objectSummary.getKey());
                }

            }


            System.out.println("Next Continuation Token : " + result.getNextContinuationToken());
        } while (result.isTruncated() == true);

    } catch (AmazonServiceException ase) {
        System.out.println("Caught an AmazonServiceException, " +
                "which means your request made it " +
                "to Amazon S3, but was rejected with an error response " +
                "for some reason.");
        System.out.println("Error Message:    " + ase.getMessage());
        System.out.println("HTTP Status Code: " + ase.getStatusCode());
        System.out.println("AWS Error Code:   " + ase.getErrorCode());
        System.out.println("Error Type:       " + ase.getErrorType());
        System.out.println("Request ID:       " + ase.getRequestId());
    } catch (AmazonClientException ace) {
        System.out.println("Caught an AmazonClientException, " +
                "which means the client encountered " +
                "an internal error while trying to communicate" +
                " with S3, " +
                "such as not being able to access the network.");
        System.out.println("Error Message: " + ace.getMessage());
    }
}

---

当问题是关于在AmazonS3Java中删除文件、目录和存储桶时，我想提供删除非空S3存储桶（）的代码：

public void deleteBucket（最终字符串bucketName）{
最终AmazonS3 s3=AmazonS3ClientBuilder.defaultClient（）；
试一试{
ObjectListing ObjectListing=s3.listObjects（bucketName）；
while（true）{
for（Iterator Iterator=objectListing.getObjectSummaries（）.Iterator（）；Iterator.hasNext（）；）{
S3ObjectSummary=（S3ObjectSummary）迭代器.next（）；
s3.deleteObject（bucketName，summary.getKey（））；
}
if（objectListing.isTruncated（））{
objectListing=s3.ListNextBatchOfObject（objectListing）；
}否则{
打破
}
}
VersionListing VersionListing=s3.listVersions（新ListVersionsRequest（）.withBucketName（bucketName））；
while（true）{
for（Iterator Iterator=versionListing.getVersionSummaries（）.Iterator（）；Iterator.hasNext（）；）{
S3VersionSummary vs=（S3VersionSummary）迭代器；
s3.deleteVersion（bucketName，vs.getKey（），vs.getVersionId（））；
}
if（versionListing.isTruncated（））{
versionListing=s3.listNextBatchOfVersions（versionListing）；
}否则{
打破
}
}
s3.删除Bucket（bucketName）；
}捕获（AmazonServiceException e）{
System.err.println（e.getErrorMessage（））；
}
}

按批量从S3 bucket中删除对象列表：

public void deleteObjects(String bucketName, List<String> keys) {

    List<KeyVersion> bulk = new ArrayList<>();
    for (int i = 0; i < keys.size(); i++) {
        bulk.add(new KeyVersion(keys.get(i)));
        if (i % 100 == 0) {
            try {
                s3Client.deleteObjects(new DeleteObjectsRequest(bucketName).withKeys(bulk));
            } catch (Exception e) {
                System.err.println(e.getErrorMessage());
            }
            bulk.clear();
        }
    }
    if (bulk.size() > 0) {
        try {
            s3Client.deleteObjects(new DeleteObjectsRequest(bucketName).withKeys(bulk));
        } catch (Exception e) {
            System.err.println(e.getErrorMessage());
        }
    }
}

public void deleteObjects（字符串bucketName，列表键）{
List bulk=new ArrayList（）；
对于（int i=0；i0）{
试一试{
s3Client.deleteObjects（新的DeleteObjectsRequest（bucketName）.withKeys（bulk））；
}捕获（例外e）{
System.err.println（e.getErrorMessage（））；
}
}
}

---

来源：

这行代码适用于我的情况，

keyName

是文件名：

s3Client.deleteObject(new DeleteObjectRequest(bucketName, keyName));

---

因此，语法应该是

deleteObject（bucketName，path）

？@cfarm54-除了键不是路径之外。它们的键-桶关系更像..键是一个文件名（可能包含

/

），而桶是一个大文件夹。谢谢，你如何删除目录和桶？@cfarm54-看看。

deleteBucket（String bucketName）

删除整个bucket。。您必须列出它们（

列出对象（String bucketName，String prefix）

），然后分别删除它们

    String Bucket_Name = "my_bucket";
    String key = "Path/to/my/folder";   
    ObjectListing objects = s3Client.listObjects(BUCKET_NAME, key);
        for (S3ObjectSummary objectSummary : objects.getObjectSummaries()) 
            {
            s3Client.deleteObject(BUCKET_NAME, objectSummary.getKey());
            }           

private void deleteObjectsInFolder() {
    try {
        ListObjectsV2Result result;
        do {
            String folderPath =   " ";



            result = s3.listObjectsV2(Constants.BUCKET_NAME, folderPath);

            Log.e("count:", result.getKeyCount() + "");

            if (result.getKeyCount() != 0) {

                for (S3ObjectSummary objectSummary :
                        result.getObjectSummaries()) {
                    s3.deleteObject(Constants.BUCKET_NAME, objectSummary.getKey());
                }

            }


            System.out.println("Next Continuation Token : " + result.getNextContinuationToken());
        } while (result.isTruncated() == true);

    } catch (AmazonServiceException ase) {
        System.out.println("Caught an AmazonServiceException, " +
                "which means your request made it " +
                "to Amazon S3, but was rejected with an error response " +
                "for some reason.");
        System.out.println("Error Message:    " + ase.getMessage());
        System.out.println("HTTP Status Code: " + ase.getStatusCode());
        System.out.println("AWS Error Code:   " + ase.getErrorCode());
        System.out.println("Error Type:       " + ase.getErrorType());
        System.out.println("Request ID:       " + ase.getRequestId());
    } catch (AmazonClientException ace) {
        System.out.println("Caught an AmazonClientException, " +
                "which means the client encountered " +
                "an internal error while trying to communicate" +
                " with S3, " +
                "such as not being able to access the network.");
        System.out.println("Error Message: " + ace.getMessage());
    }
}

 public void deleteBucket(final String bucketName) {

        final AmazonS3 s3 = AmazonS3ClientBuilder.defaultClient();

        try {
            ObjectListing objectListing = s3.listObjects(bucketName);
            while (true) {
                for (Iterator<?> iterator = objectListing.getObjectSummaries().iterator(); iterator.hasNext(); ) {
                    S3ObjectSummary summary = (S3ObjectSummary) iterator.next();
                    s3.deleteObject(bucketName, summary.getKey());
                }

                if (objectListing.isTruncated()) {
                    objectListing = s3.listNextBatchOfObjects(objectListing);
                } else {
                    break;
                }
            }

            VersionListing versionListing = s3.listVersions(new ListVersionsRequest().withBucketName(bucketName));
            while (true) {
                for (Iterator<?> iterator = versionListing.getVersionSummaries().iterator(); iterator.hasNext(); ) {
                    S3VersionSummary vs = (S3VersionSummary) iterator.next();
                    s3.deleteVersion(bucketName, vs.getKey(), vs.getVersionId());
                }

                if (versionListing.isTruncated()) {
                    versionListing = s3.listNextBatchOfVersions(versionListing);
                } else {
                    break;
                }
            }

            s3.deleteBucket(bucketName);
        } catch (AmazonServiceException e) {
            System.err.println(e.getErrorMessage());
        }
    }

public void deleteObjects(String bucketName, List<String> keys) {

    List<KeyVersion> bulk = new ArrayList<>();
    for (int i = 0; i < keys.size(); i++) {
        bulk.add(new KeyVersion(keys.get(i)));
        if (i % 100 == 0) {
            try {
                s3Client.deleteObjects(new DeleteObjectsRequest(bucketName).withKeys(bulk));
            } catch (Exception e) {
                System.err.println(e.getErrorMessage());
            }
            bulk.clear();
        }
    }
    if (bulk.size() > 0) {
        try {
            s3Client.deleteObjects(new DeleteObjectsRequest(bucketName).withKeys(bulk));
        } catch (Exception e) {
            System.err.println(e.getErrorMessage());
        }
    }
}

s3Client.deleteObject(new DeleteObjectRequest(bucketName, keyName));