1. Overview
In this tutorial, we’ll explore how to rename an object (file or folder) in an Amazon S3 bucket using Java.
Amazon Simple Storage Service (Amazon S3) is a popular cloud storage service. It allows users to store and retrieve data in the cloud with high durability, availability, and scalability. We’ll interact with it in the following chapters using the AWS SDK for Java.
2. Prerequisites
To rename objects in an S3 bucket, we can utilize the S3Client class provided by the AWS SDK for Java.
2.1. Maven Dependencies
First of all, we need to declare the AWS S3 SDK dependency in our project’s pom.xml:
<dependency>
<groupId>software.amazon.awssdk</groupId>
<artifactId>s3</artifactId>
<version>2.24.9</version>
</dependency>
2.2. AWS Credentials
We also need an AWS account set up, install AWS CLI, and configure it with our AWS credentials (AWS_ACCESS_KEY_ID and AWS_SECERET_ACCESS_KEY) to be able to access the AWS resources programmatically. We can find all the steps to accomplish this in the AWS documentation.
2.3. Initializing the S3 Client
Now, we’ll create the client to handle all the communication with the S3 service. To create an S3 client, we must provide our AWS profile created with the credentials from the previous step and configure the AWS region:
S3Client s3Client = S3Client.builder()
.region(US_EAST_1)
.credentialsProvider(ProfileCredentialsProvider.create("default"))
.build();
We create the client using the Builder Design Pattern. This is a Creation Design Pattern that will help us create those complex objects. In our example, we’ll create our bucket in the US_EAST_1 region. We can find all the regions in the official documentation if we want to change our preferred region.
3. Renaming Objects Using Copy and Delete
Currently, the only way to rename an object using the SDK is to copy the object with a different name and then delete the original object. We’ll also exemplify this in this section, explaining each step.
3.1. Copy S3 Object
In this step, we’ll use the client created in the previous point to call the AWS API.
First of all, we’ll define the parameters for our request. Let’s say we have a bucket called baeldung-s3-bucket and a CSV file called simpleCSVFile.csv. We want to rename the file to renamedFile.csv. Let’s begin by outlining the parameters for our copy request:
String bucketName = "baeldung-s3-bucket";
String keyName = "simpleCSVFile.csv";
String destinationKeyName = "renamedFile.csv";
After defining the parameters, we can construct the CopyObjectRequest that will be sent to the AWS API:
CopyObjectRequest copyObjRequest = CopyObjectRequest.builder()
.sourceBucket(bucketName)
.sourceKey(keyName)
.destinationBucket(destinationKeyName)
.destinationKey(bucketName)
.build();
Now we can copy de object using the AmazonS3 client and the request:
s3Client.copyObject(copyRequest);
If we stop here and run our code, we’ll see that we now have two files, one with the new desired name and the original one.
3.2. Deleting S3 Object
We also need to delete the original object after copying to finish the renaming process. We’ll define the DeleteObjectRequest with the parameters from the previous point:
DeleteObjectRequest deleteRequest = DeleteObjectRequest.builder()
.bucket(bucketName)
.key(keyName)
.build();
And we’ll call the S3 Client one more time to delete the original object:
s3Client.deleteObject(deleteRequest);
4. Renaming Folders
The approach from the previous point only works well for renaming simple objects. But when we have to rename a folder, things change a little. Renaming an entire folder in Amazon S3 involves iterating through all the objects within the folder and renaming each one individually.
4.1. List All Objects from the Source Folder
Let’s start by listing all objects from a given folder:
ListObjectsV2Request listRequest = ListObjectsV2Request.builder()
.bucket(bucketName)
.prefix(sourceFolderKey)
.build();
ListObjectsV2Response listResponse = s3Client.listObjectsV2(listRequest);
List<S3Object> objects = listResponse.contents();
We initialize the ListObjectsV2Request with the bucket name and the prefix. The objects in a folder are actually all the objects whose key prefix is the name of the respective folder.
4.2. Rename All Object Keys from Folder
Now that we have the code that lists all objects from our folder, all we have to do is copy all of them to the new destination and delete the original objects:
for (S3Object s3Object : objects) {
String newKey = destinationFolderKey + s3Object.key().substring(sourceFolderKey.length());
// Copy object to destination folder
CopyObjectRequest copyRequest = CopyObjectRequest.builder()
.sourceBucket(bucketName)
.sourceKey(s3Object.key())
.destinationBucket(bucketName)
.destinationKey(newKey)
.build();
s3Client.copyObject(copyRequest);
// Delete object from source folder
DeleteObjectRequest deleteRequest = DeleteObjectRequest.builder()
.bucket(bucketName)
.key(s3Object.key())
.build();
s3Client.deleteObject(deleteRequest);
}
We start by iterating through the list of objects, and for every item, we will generate a new key by replacing the old name of the folder with the desired new one. After getting the new key, all we have to do is to copy the object at the new destination and delete the original one.
5. Conclusion
In this article, we’ve explored ways to rename files and folders in an S3 bucket using the AWS SDK for Java. We explored two different situations which use the same concept for renaming the objects, to copy them with a new name and delete the original.
As always, the complete code of this article is available over on GitHub.
