File management

Updated at：2025-11-03

Upload files

In BOS, the basic data unit for user operations is an object. An object consists of a key, metadata, and data. The key is the object’s name, the metadata provides a user-defined description as a set of name-value pairs, and the data is the content of the object.

The BOS Java SDK provides a rich set of file upload APIs, and files can be uploaded in the following ways:

Simple upload
Append upload
Multipart upload
Resumable upload

Simple upload

In simple upload scenarios, BOS supports uploading objects in the form of specified files, data streams, binary strings, and character strings. Please refer to the following code or Simple Upload Demo.

                Java
                
            

                public void PutObject(BosClient client, String bucketName, String objectKey, byte[] byte1, String string1){
 // Get specified file
    File file = new File("/path/to/file.zip");
 // Obtain data stream
    InputStream inputStream = new FileInputStream("/path/to/test.zip");
	
 // Upload object as a file
    PutObjectResponse putObjectFromFileResponse = client.putObject(bucketName, objectKey, file);
 // Upload an object in the form of a data stream
    PutObjectResponse putObjectResponseFromInputStream = client.putObject(bucketName, objectKey, inputStream);
 // Upload object as binary string
    PutObjectResponse putObjectResponseFromByte = client.putObject(bucketName, objectKey, byte1);
 // Upload object in string form
    PutObjectResponse putObjectResponseFromString = client.putObject(bucketName, objectKey, string1);
 // Create an empty directory. The objectKey must end with a forward slash, such as test/
 // The BOS console will, by default, display objects ending with a forward slash (/) as file directories
    PutObjectResponse putObjectResponseFromString = client.putObject(bucketName, objectKey, "");
	
 // Print ETag
    System.out.println(putObjectFromFileResponse.getETag());
}
            

Files are uploaded to BOS as objects. The PutObject function supports uploading objects with a size of up to 5 GB. Upon successful processing of a PutObject request, BOS returns the object's ETag in the response header as its unique identifier.

Set file meta information

Object metadata refers to the attributes of files provided by users when uploading to BOS. It is mainly divided into two categories: standard HTTP attribute settings (HTTP headers) and user-defined metadata.

Set Http header of object

The BOS Java SDK essentially interacts with the backend HTTP API, allowing users to customize the HTTP headers of the object when uploading files. The following describes some commonly used HTTP headers:

Name	Description	Default value
Content-MD5	File data verification: After setting, BOS will enable file content MD5 verification, compare the MD5 you provide with the MD5 of the file, and throw an error if they are inconsistent	None
Content-Type	File MIME: This defines the file type and web page encoding, determining how the browser reads the file. If unspecified, BOS generates it based on the file's extension. If the file lacks an extension, a default value will be applied.	application/octet-stream
Content-Disposition	Indicate how the MIME user agent displays the attached file, whether to open or download it, and the file name	None
Content-Length	The length of the uploaded file. If it exceeds the length of the stream/file, it will be truncated; if it is insufficient, it will be the actual value	Stream/file duration
Expires	Cache expiration time	None
Cache-Control	Specify the caching behavior of the web page when the object is downloaded	None
x-bce-content-crc32	The CRC value (cyclic redundancy check code) of uploaded object	None

Reference code is as follows:

                Java
                
            

                //Initialize the upload input stream
ObjectMetadata meta = new ObjectMetadata();
 // Set ContentLength size
meta.setContentLength(1000);
 // Set ContentType
meta.setContentType("application/json");
 //Set cache-control
meta.setCacheControl("no-cache");
 // Set x-bce-content-crc32. The file’s CRC32 check code must be calculated by the user themselves
meta.setxBceCrc("0x74E947D0");
client.putObject(bucketName, objectKey, content, meta);
            

Set file meta information

BOS lets users set object ACL permissions during upload, with options like “private” and “public-read,” as shown in the following code:

                Java
                
                // Set ACL to private
PutObjectRequest request = new PutObjectRequest(bucketName, key, file);
request.setxBceAcl("private");
    
 // Upload Object
client.putObject(bucketName, objectKey, content, meta);

User-defined meta information

BOS supports user-defined metadata for describing objects. Example usage is shown in the following code:

                Java
                
                // Set the value of custom metadata name to my-data
meta.addUserMetadata("name", "my-data");
    
 // Upload Object
client.putObject(bucketName, objectKey, content, meta);

Prompt:

In the above code, the user has customized a metadata with the name "name" and value "my-data".

When users download this object, this metadata can also be obtained.

An object may have multiple similar parameters, but the total size of all user meta must not exceed 2KB.

Set storage class when uploading an object

BOS supports standard storage, infrequent access storage, and cold storage. Uploading an object and storing it as an infrequent access storage class is achieved by specifying the StorageClass. The parameters corresponding to the three storage classes are as follows:

Storage class	Parameters
Standard storage	STANDRAD
Infrequent access storage	STANDARD_IA
Cold storage	COLD

Taking infrequent access storage as an example, the code is as follows:

                Java
                
            

                public void putObjectStorageClass(){
    PutObjectRequest request = new PutObjectRequest(bucketName, key, file);
    request.withStorageClass(BosClient.STORAGE_CLASS_STANDARD_IA);
    client.putObject(request);
}
            

Append upload

Objects created using the simple upload method described above are all of a standard type and do not support append writes. This limitation can be inconvenient in scenarios where frequent data overwriting occurs, such as log files, video surveillance, and live video streaming.

To address this, Baidu AI Cloud Object Storage (BOS) specifically supports the AppendObject method, which allows files to be uploaded in an append-write fashion. Objects created through the AppendObject operation are categorized as Appendable Objects, enabling data to be appended to them. The size limit for AppendObject files is 0–5 GB.

The sample code for uploading via the AppendObject method is as follows, or refer to Append Upload Demo.

                Java
                
            

                public void AppendObject(BosClient client, String bucketName, String objectKey, byte[] byte1, String string1) {
 // Get specified file
        File file = new File("/path/to/file.zip");
 // Obtain data stream
        InputStream inputStream = new FileInputStream("/path/to/test.zip");
 // Upload object as a file
        AppendObjectResponse appendObjectFromFileResponse = client.appendObject(bucketName, objectKey, file);
 // Upload an object in the form of a data stream
        AppendObjectResponse appendObjectResponseFromInputStream = client.appendObject(bucketName, objectKey, inputStream);
 // Upload object as binary string
        AppendObjectResponse appendObjectResponseFromByte = client.appendObject(bucketName, objectKey, byte1);
 // Upload object in string form
        AppendObjectResponse appendObjectResponseFromString = client.appendObject(bucketName, objectKey, string1);
 // Print ETag
        System.out.println(appendObjectFromFileResponse.getETag());
 //Print NextAppendOffset
        System.out.println(appendObjectFromFileResponse.getNextAppendOffset());
 // Print ContentMd5
        System.out.println(appendObjectFromFileResponse.getContentMd5());
 //Example of append upload, need to add the position of the next append write in the request
        Long nextAppendOffset = appendObjectFromFileResponse.getNextAppendOffset();
        AppendObjectRequest appendObjectFromFileRequest = new AppendObjectRequest(bucketName,objectKey,file);
        appendObjectFromFileRequest.setOffset(nextAppendOffset);
        AppendObjectResponse appendObjectFromFileResponse = client.appendObject(appendObjectFromFileRequest);
    }
            

Multipart upload

Besides uploading files to BOS using simple upload and append upload modes, BOS also supports another option—Multipart Upload. Users can use Multipart Upload mode in various scenarios, including but not limited to the ones below:

When resumable uploads are required.
When uploading files larger than 5GB.
When the connection to the BOS server is frequently interrupted due to unstable network conditions.
Enable streaming file uploads.
The file size cannot be determined before uploading.

The following will introduce the implementation of Multipart Upload step by step. Suppose there is a file with the local path /path/to/file.zip. Since the file is large, it will be transmitted to BOS in parts. Or refer to Multipart Upload Demo

Initialize multipart upload

Use initiateMultipartUpload method to initialize a multipart upload event:

                Java
                
            

                // Initiate Multipart Upload
InitiateMultipartUploadRequest initiateMultipartUploadRequest =
        new InitiateMultipartUploadRequest(bucketName, objectKey);
InitiateMultipartUploadResponse initiateMultipartUploadResponse =
        client.initiateMultipartUpload(initiateMultipartUploadRequest);
    
 // Print UploadId
System.out.println("UploadId: " + initiateMultipartUploadResponse.getUploadId());
            

The return result of initiateMultipartUpload contains UploadId, which is the unique identifier for distinguishing multipart upload events, and we will use it in subsequent operations.

Initialization for uploading infrequent access storage class objects

Initialize a multipart upload event for infrequent access storage:

                Java
                
            

                public void putMultiUploadStorageClass(){
    InitiateMultipartUploadRequest iniReq = new InitiateMultipartUploadRequest(bucketName, key);
    iniReq.withStorageClass(BosClient.STORAGE_CLASS_STANDARD_IA);
    client.initiateMultipartUpload(iniReq);
}
            

Initialization for uploading a cold storage class object

Initialize a multipart upload event for infrequent access storage:

                Java
                
            

                public void putMultiUploadStorageClass(){
    InitiateMultipartUploadRequest iniReq = new InitiateMultipartUploadRequest(bucketName, key);
    iniReq.withStorageClass(BosClient.STORAGE_CLASS_COLD);
    client.initiateMultipartUpload(iniReq);
}
            

Upload parts

The file is then uploaded in multiple parts.

                Java
                
            

                // Set each part to 5MB
final long partSize = 1024 * 1024 * 5L;
    
File partFile = new File("/path/to/file.zip");
    
 // Calculate the count of parts
int partCount = (int) (partFile.length() / partSize);
if (partFile.length() % partSize != 0){
    partCount++;
}
    
 // Create a list to save the ETag and PartNumber of each uploaded part
List<PartETag> partETags = new ArrayList<PartETag>();
    
for(int i = 0; i < partCount; i++){
 // Get file stream
    FileInputStream fis = new FileInputStream(partFile);
    
 //Jump to the beginning of each part
    long skipBytes = partSize * i;
    fis.skip(skipBytes);
    
 // Calculate the size of each part
    long size = partSize < partFile.length() - skipBytes ?
            partSize : partFile.length() - skipBytes;
    
 // Create UploadPartRequest to upload parts
    UploadPartRequest uploadPartRequest = new UploadPartRequest();
    uploadPartRequest.setBucketName(bucketName);
    uploadPartRequest.setKey(objectKey);
    uploadPartRequest.setUploadId(initiateMultipartUploadResponse.getUploadId());
    uploadPartRequest.setInputStream(fis);
    uploadPartRequest.setPartSize(size);
    uploadPartRequest.setPartNumber(i + 1);
    UploadPartResponse uploadPartResponse = client.uploadPart(uploadPartRequest);
    
 // Save the returned PartETag to the List.
    partETags.add(uploadPartResponse.getPartETag());
   
 // Close the file
    fis.close();
}
            

The core of the above code is to call the UploadPart method to upload each part, but the following points should be noted:

The uploadPart method requires that the size of each part, except the last one, must be greater than or equal to 100KB. However, the Upload Part interface does not immediately validate the Part size; validation occurs only during completing multipart upload.
To ensure no errors during network transmission, it is recommended to use the Content-MD5 value returned by BOS for each part after UploadPart to verify the correctness of the uploaded part data. When all part data is combined into one Object, it no longer contains the MD5 value.
The part number must be within the range of 1 to 10,000. If this limit is exceeded, BOS will return an InvalidArgument error code.
For each uploaded part, the stream must be positioned at the beginning of the respective part.
After each Part upload, the return result of BOS will include a PartETag object, which is a combination of the uploaded block's ETag and block number (PartNumber). It will be used in subsequent steps to complete the multipart upload, so it must be saved. Generally speaking, these PartETag objects will be saved in a List.

Complete multipart upload

Complete the multipart upload as shown in the following code:

                Java
                
                CompleteMultipartUploadRequest completeMultipartUploadRequest =
        new CompleteMultipartUploadRequest(bucketName, objectKey, initiateMultipartUploadResponse.getUploadId(), partETags);
    
 // Complete multipart upload
CompleteMultipartUploadResponse completeMultipartUploadResponse =
        client.completeMultipartUpload(completeMultipartUploadRequest);
    
 // Print Object's ETag
System.out.println(completeMultipartUploadResponse.getETag());

The partETags in the above code is the list of partETag saved in the second step. After BOS receives the part list submitted by the user, it will verify the validity of each data Part one by one. Once all data parts are validated, BOS will assemble the data parts into a complete Object.

Cancel multipart upload event

Users can cancel multipart uploads by using the abortMultipartUpload method.

                Java
                
                AbortMultipartUploadRequest abortMultipartUploadRequest =
        new AbortMultipartUploadRequest(bucketName, objectKey, uploadId);
    
 // Cancel multipart upload
client.abortMultipartUpload(abortMultipartUploadRequest);

Retrieve unfinished multipart upload event

Users can obtain the unfinished multipart upload events in the bucket by the listMultipartUploads method.

                Java
                
            

                ListMultipartUploadsRequest listMultipartUploadsRequest =
    new ListMultipartUploadsRequest(bucketName);
 // Retrieve all upload events within the bucket
ListMultipartUploadsResponse listing = client.listMultipartUploads(listMultipartUploadsRequest);
    
 // Traverse all upload events
for (MultipartUploadSummary multipartUpload : listing.getMultipartUploads()) {
    System.out.println("Key: " + multipartUpload.getKey() + " UploadId: " + multipartUpload.getUploadId());
}
            

Note:

By default, if the number of multipart upload events in a bucket surpasses 1,000, only 1,000 records will be returned. In such cases, the IsTruncated value in the response will be True, and the NextKeyMarker will indicate the starting point for the next query.

To retrieve more multipart upload events, you can utilize the KeyMarker parameter for batch reading.

Get all uploaded part information

Users can obtain all uploaded parts in an upload event by the listParts method.

                Java
                
                ListPartsRequest listPartsRequest = new ListPartsRequest(bucketName, objectKey, uploadId);
    
 // Retrieve all uploaded part information
ListPartsResponse partListing = client.listParts(listPartsRequest);
    
 // Traverse all parts
for (PartSummary part : partListing.getParts()) {
    System.out.println("PartNumber: " + part.getPartNumber() + " ETag: " + part.getETag());
}

If you need to view the storage class of an object, use the following code:

                Java
                
                public void listPartsStorageClass(){
    ListResponse listPartsResponse = client.listParts(bucketName, key, uploadId);
    String storageClass = listPartsResponse.getStorageClass();
}

Note:

By default, if the number of multipart upload events in a bucket surpasses 1,000, only 1,000 records will be returned. In such cases, the IsTruncated value in the response will be True, and the NextPartNumberMarker will indicate the starting point for the next query.

To fetch additional multipart upload events, you can utilize the PartNumberMarker parameter for batch reading.

Encapsulate multipart upload

In the Java SDK, Bos provides users with the putSuperObjectFromFile API, which encapsulates the three methods involved in multipart upload: initiateMultipartUpload, UploadPart and completeMultipartUpload. Users only need to call this API to complete the multipart upload.

                Java
                
                File file = new File("/path/to/file.zip");
PutSuperObjectRequest request = new PutSuperObjectRequest(bucketName, objectKey, file);
bosClient.putSuperObjectFromFile(request);

The parameters of PutSuperObjectRequest include:

Parameters	Description
chunkSize	Part size: The default is 5 MB, and it cannot be less than 100 KB
nThreads	Number of threads in the thread pool for multipart upload: The default is equal to the number of CPU cores
isSuperObjectUploadCanced	Cancel multipart upload or not
File	Upload files

If uploading a large file takes too long and the user wishes to end the multipart upload, they can call the cancel() method in PutSuperObjectRequest to set isSuperObjectUploadCanceled to true, thereby canceling the multipart upload operation.

Resumable upload

When users upload large files to BOS, if the network is unstable or the program crashes, the entire upload will fail, and the parts that have been uploaded before the failure will also be invalid. Users have to start over. This not only wastes resources but also often fails to complete the upload after multiple retries in an unstable network environment. Based on the above scenarios, BOS provides the capability of resumable upload:

In a generally stable network, it is recommended to use the three-step upload method, dividing the object into 5 MB blocks, refer to [Multipart Upload](#Multipart upload).
If your network condition is very poor, it is recommended to use the appendObject method for resumable upload, appending small data (256 KB) each time, refer to [Append Upload](#Append upload).

Tips

Resumable upload is an encapsulation and enhancement of multipart upload, implemented using multipart upload;

For large files or poor network environments, it is recommended to use multipart upload;

Fetch and upload

The following code retrieves resources from a specified URL and stores them in a designated bucket. This process requires the requester to have write permissions for the bucket. Only one object can be fetched at a time, and the user can specify a custom object name. For details, refer to the FetchObject API.

                Java
                
                String fetchurl = "bj.bcebos.com/sourbucket/sourceobject";
FetchObjectRequest req = new FetchObjectRequest(bucketname, objectname, fetchurl);
bosClient.fetchObject(req);

Obtain upload progress

Supports providing real-time upload progress updates during the upload process. It currently supports four APIs: PutObject, AppendObject, UploadPart, and PutSuperObjectFromFile. The progress upload API accepts optional custom data.

The Java SDK defines upload progress callback APIs that allow users to define actions needed during upload, such as updating the API.

                Java
                
                public interface ProgressCallback<T> {
    void onProgress(long currentSize, long totalSize, T data);
}

PutObject example code:

                Java
                
            

                BosProgressCallback<Object> callback = new BosProgressCallback<Object>() {
    @Override
    public void onProgress(long currentSize, long totalSize, Object data) {
        System.out.println("put " + currentSize + "/" + totalSize);
    }
};
 // If you need to use custom data in onProgress
callback.setData(obj);
PutObjectRequest request = new PutObjectRequest(bucketName, objectKey, file);
request.setProgressCallback(callback);
client.putObject(request);
            

AppendObject example code:

                Java
                
            

                BosProgressCallback<Object> callback = new BosProgressCallback<Object>() {
    @Override
    public void onProgress(long currentSize, long totalSize, Object data) {
        System.out.println("put " + currentSize + "/" + totalSize);
    }
};
 // If you need to use custom data in onProgress
callback.setData(obj);
AppendObjectRequest request = new AppendObjectRequest(bucketName, objectKey, file);
request.setProgressCallback(callback);
AppendObjectResponse response = client.appendObject(request);
Long nextAppendOffset = response.getNextAppendOffset();
            

UploadPart example code:

                Java
                
            

                BosProgressCallback<Object> callback = new BosProgressCallback<Object>() {
    @Override
    public void onProgress(long currentSize, long totalSize, Object data) {
        System.out.println("put " + currentSize + "/" + totalSize);
    }
};
 // If you need to use custom data in onProgress
callback.setData(obj);
UploadPartRequest request = new UploadPartRequest();
request.setBucketName(bucketName);
request.setKey(objectKey);
request.setUploadId(id);
request.setInputStream(inputStream);
request.setPartSize(size);
request.setPartNumber(i);
request.setProgressCallback(callback);
client.uploadPart((request);
            

PutSuperObjectFromFile example code:

                Java
                
            

                BosProgressCallback<Object> callback = new BosProgressCallback<Object>() {
    @Override
    public void onProgress(long currentSize, long totalSize, Object data) {
        System.out.println("put " + currentSize + "/" + totalSize);
    }
};
 // If you need to use custom data in onProgress
callback.setData(obj);
PutSuperObjectRequest request = new PutSuperObjectRequest(bucketName, objectKey, file);
request.setProgressCallback(callback);
client.putSuperObjectFromFile(request);
            

Download file

The BOS Java SDK provides a variety of file download APIs, allowing users to download files from BOS in the following ways:

Simple streaming download
Download to a local file
Resumable download
Range download
Download progress bar

For the complete sample code, please refer to File Download Demo

Simple streaming download

Users can read the object into a stream using the following code:

                Java
                
            

                public void getObject(BosClient client, String bucketName, String objectKey)
    throws IOException {
 //Obtain the object, with returned result BosObject object
    BosObject object = client.getObject(bucketName, objectKey);
 // Retrieve ObjectMeta
    ObjectMetadata meta = object.getObjectMetadata();
 //Obtain the object's input stream
    InputStream objectContent = object.getObjectContent();
 // Process object
    ...
 // Close stream
    objectContent.close();
}
            

Note:

The BosObject includes various details about the object, such as the bucket it belongs to, the object’s name, metadata, and an input stream. Users can read the object's content into a file or memory by interacting with the input stream.

ObjectMetadata contains information such as the ETag defined during object upload, HTTP headers, and custom metadata.

Users can also use the getObjectContent method of BosObject to obtain the input stream of the returned object, enabling operations on the object's content.

Directly download an object to a file

Users can directly download an object to the specified file using the following code:

                Java
                
                // Create GetObjectRequest
GetObjectRequest getObjectRequest = new GetObjectRequest(bucketName, objectKey);
    
 // Download object to file
ObjectMetadata objectMetadata = client.getObject(getObjectRequest, new File("/path/to/file","filename"));

When downloading an object directly to a specified file using the mentioned method, the method returns an ObjectMetadata object.

Range download

To implement more functions, you can use GetObjectRequest to specify the download range for more refined acquisition of the object. If the specified download range is 0-100, it will return data from byte 0 to byte 100, including byte 100, with a total of 101 bytes of data, i.e., [0, 100].

                Java
                
            

                // Create GetObjectRequest
GetObjectRequest getObjectRequest = new GetObjectRequest(bucketName, objectKey);
 // Obtain data within the 0~100 byte range
getObjectRequest.setRange(0, 100);
 //Obtain the object, with returned result BosObject object
BosObject object = client.getObject(getObjectRequest);
            

The range of the returned object can be configured using the setRange method of the getObjectRequest. This allows users to perform segmented downloads and resumable uploads of files.

Download the image-processed file

The Java SDK supports image processing while downloading files. You only need to set the x-bce-process parameter in the request. For the usage of specific parameters, please refer to Image Processing. Example code is as follows:

                Java
                
            

                // Create GetObjectRequest
GetObjectRequest getObjectRequest = new GetObjectRequest(bucketName, objectKey);
 // Set image processing to zoom
getObjectRequest.setxBceProcess("image/resize,m_fixed,w_200,h_100");
 // Get the object, with the processed BosObject returned
BosObject object = client.getObject(getObjectRequest);
            

Other methods

Get the storage class of the object

The storage class attributes of an object are divided into STANDARD (standard storage), STANDARD_IA (infrequent access storage), and COLD (cold storage). This can be achieved through the following code:

                Java
                
                public void getObjectStorageClass(){
    ObjectMetadata meta = client.getObjectMetadata(bucketName, key);
    String storageClass = meta.getStorageClass();
}

Get only ObjectMetadata

The getObjectMetadata method is designed to retrieve only the ObjectMetadata, not the object itself. This can be demonstrated in the following code:

                Java
                
                ObjectMetadata objectMetadata = client.getObjectMetadata(bucketName, objectKey);

The parameters available for calling in the getObjectMetadata parsing class are:

Parameters	Description
contentType	Object type
contentLength	Object size
contentMd5	Object MD5
etag	The HTTP protocol entity tag of object
storageClass	Storage class of the object
userMetadata	If userMetadata custom meta is specified in PutObject, this item will be returned
xBceCrc	If the CRC value (Cyclic Redundancy Check code) of the object is specified in PutObject, this item will be returned

Restore archived storage class files

Restore archived class files

When a user uploads an archived file, it enters a frozen state. To download it, the archived file must first be restored. The requester must have read permissions for the archived file, and the file must remain in its frozen state.

Examples of restoring archived files are as follows:

                Java
                
            

                RestoreObjectRequest request = new RestoreObjectRequest(bucketName, objectKey);
request.setRestoreDays(10);
 // Expedited restoration (RESTORE_TIER_EXPEDITED), standard restoration (RESTORE_TIER_STANDARD), deferred restoration (RESTORE_TIER_LOWCOST)
request.setRestoreTier(RESTORE_TIER_EXPEDITED);
client.restoreObject(request);
            

Parameters	Types	Description	Required or not
days	int	Defines the duration of the restored state in days, with a numeric value greater than 0 and less than 30. By default, the restoration duration is 7 days, with a maximum duration of 30 days.	No
tier	string	Restore priority. The available values are as follows: Expedited: Fast restoration that is completed within 30 minutes. Standard: Standard restoration, indicating completion within 2~5 hours LowCost: Deferred restoration, indicating completion within 12 hours	No

Change file storage class

As mentioned above, BOS supports three storage classes for files: STANDARD (standard storage), STANDARD_IA (infrequent access storage), and COLD (cold storage). Meanwhile, the BOS java SDK also allows users to perform operations to change the storage class of specific files. The relevant parameters are as follows:

Parameters	Description
x-bce-storage-class	Define the object's storage class. STANDARD_IA indicates infrequent access storage, COLD indicates cold storage, and if no class is specified, the default is standard storage.

An example is as follows:

                Java
                
            

                // Convert standard storage to infrequent access storage
CopyObjectRequest copyObjectRequest = new CopyObjectRequest(srcBucketName, srcKey, destBucketName, destKey);
copyObjectRequest.setStorageClass("STANDARD_IA");
client.copyObject(copyObjectRequest);
 // Convert infrequent access storage to cold storage
CopyObjectRequest copyObjectRequest = new CopyObjectRequest(srcBucketName, srcKey, destBucketName, destKey);
copyObjectRequest.setStorageClass("COLD");
client.copyObject(copyObjectRequest);
            

Get file download URL

Users can obtain the URL of a specified object through the following code:

                Java
                
            

                public String generatePresignedUrl(BosClient client, String bucketName, String objectKey, int expirationInSeconds) {
   URL url = client.generatePresignedUrl(＜bucketName＞, ＜objectKey＞, <expirationInSeconds>);
 //Specify the name of the bucket where the object that the user needs to get is located, the name of the object, timestamp and the valid duration of the URL
    return url.toString();
}
            

Description:

Before calling this function, users need to manually set the endpoint to the domain name of the corresponding region. Baidu AI Cloud currently supports multiple regions. Please refer to[Region Selection Guide](Reference/Region Selection Instructions/Region.md). Currently, the supported regions include "North China-Beijing," "South China-Guangzhou" and "East China-Suzhou." Beijing region: http://bj.bcebos.com, Guangzhou region: http://gz.bcebos.com, Suzhou region: http://su.bcebos.com.

expirationInSeconds is the specified URL validity period, calculated from the current time. It is an optional parameter, and the system default value is 1,800 seconds if not configured. To set a permanent non-expiration time, the ExpirationInSeconds parameter can be set to -1. You cannot set it to any other negative value.

If the file to be obtained is expected to be publicly readable, the corresponding URL link can be quickly concatenated and obtained through simple rules: http://$bucketName.$region.bcebos.com/$objectKey or http://$region.bcebos.com/$bucketName/$objectKey

List files in the storage space

The BOS SDK allows users to list objects in the following two ways:

Simple listing
Advanced listing via parameters

In addition, users can also simulate folders while listing files. For the complete sample code, please refer to File Listing Demo

Simple listing

To quickly and easily list the needed files, users can use the listObjects method, which returns a ListObjectsResponse object containing the results of the listObject request. Users can retrieve details of all objects using the getContents method in the ListObjectsResponse.

                Java
                
            

                public void listObjects(BosClient client, String bucketName) {
 // Obtain all object information under the specified bucket
    ListObjectsResponse listing = client.listObjects(bucketName);
 // Traverse all objects
    for (BosObjectSummary objectSummary : listing.getContents()) {
        System.out.println("ObjectKey: " + objectSummary.getKey());
    }
}
            

Note:

By default, if the number of objects in the bucket exceeds 1,000, only 1,000 objects will be returned. In this case, the IsTruncated value in the returned result will be set to True, and NextMarker will be provided as the starting point for the next retrieval.

To retrieve more objects, the marker parameter can be used to enable batch reading.

Advanced listing via parameters

In addition to simple listing, users can achieve various flexible queries by adjusting the parameters of ListObjectsRequest. The available parameters for ListObjectsRequest include:

Parameters	Function	Usage method
Prefix	Restrict the returned object keys to those starting with a specific prefix	setPrefix(String prefix)
Delimiter	A character used to group object names. Only objects containing the specified prefix and appearing for the first time are included. Objects between the delimiter characters are treated as a single group element: CommonPrefixes.	setDelimiter(String delimiter)
Marker	Set the result to start returning from the first object in alphabetical order after the marker	setMarker(String marker)
MaxKeys	Set the maximum number of objects to return, with a default and upper limit of 1,000. Specifying a value greater than 1,000 will default to 1,000.	setMaxKeys(int maxKeys)

Note:

If there is an object named with the prefix, querying only by prefix will return all keys, including the object with the prefix.

If there is an object named with the prefix, querying with both a prefix and a delimiter will result in Null for all returned keys, and the key names will not include the prefix.

The following are several examples to illustrate the method of listing via parameters:

Specify the maximum number of returned items

                Java
                
            

                //Specify the maximum number of returned items as 500
ListObjectsRequest listObjectsRequest = new ListObjectsRequest("bucketName");
listObjectsRequest.withMaxKeys(500);
ListObjectsResponse listObjectsResponse = client.listObjects(listObjectsRequest);
for(BosObjectSummary objectSummary :listObjectsResponse.getContents()) {
    System.out.println("ObjectKey:" + objectSummary.getKey());
}
            

Return objects with a specified prefix

                Java
                
            

                //Specify to return objects with the prefix “test"
ListObjectsRequest listObjectsRequest = new ListObjectsRequest("bucketName");
listObjectsRequest.withPrefix("test");
ListObjectsResponse listObjectsResponse = client.listObjects(listObjectsRequest);
for(BosObjectSummary objectSummary :listObjectsResponse.getContents()) {
    System.out.println("ObjectKey:" + objectSummary.getKey());
}
            

Return from after a specified object

                Java
                
            

                //Users can define to exclude a certain object and start returning from after it
ListObjectsRequest listObjectsRequest = new ListObjectsRequest("bucketName");
listObjectsRequest.withMarker("object");
ListObjectsResponse listObjectsResponse = client.listObjects(listObjectsRequest);
for(BosObjectSummary objectSummary :listObjectsResponse.getContents()) {
    System.out.println("ObjectKey:" + objectSummary.getKey());
}
            

Pagination to get all objects

                Java
                
            

                //Users can set a maximum of 500 records per page
ListObjectsRequest listObjectsRequest = new ListObjectsRequest("bucketName");
listObjectsRequest.withMaxKeys(500);
ListObjectsResponse listObjectsResponse;
boolean isTruncated = true;
while (isTruncated) {
    listObjectsResponse = client.listObjects(listObjectsRequest);
    isTruncated = listObjectsResponse.isTruncated();
    if (listObjectsResponse.getNextMarker() != null) {
        listObjectsRequest.withMarker(listObjectsResponse.getNextMarker());
    }
}
            

Results of paginated restoration of all objects after a specific object

                Java
                
            

                //Users can set a maximum of 500 records per page and start getting from after a specific object
ListObjectsRequest listObjectsRequest = new ListObjectsRequest("bucketName");
listObjectsRequest.withMaxKeys(500);
listObjectsRequest.withMarker("object");
ListObjectsResponse listObjectsResponse;
boolean isTruncated = true;
while (isTruncated) {
    listObjectsResponse = client.listObjects(listObjectsRequest);
    isTruncated = listObjectsResponse.isTruncated();
    if (listObjectsResponse.getNextMarker() != null) {
        listObjectsRequest.withMarker(listObjectsResponse.getNextMarker());
    }
}
            

Results of paginated restoration of all objects after a specific object

                Java
                
            

                //Users can set pagination to get objects with a specified prefix, with a maximum of 500 records per page
ListObjectsRequest listObjectsRequest = new ListObjectsRequest("bucketName");
listObjectsRequest.withMaxKeys(500);
listObjectsRequest.withPrefix("object");
ListObjectsResponse listObjectsResponse;
boolean isTruncated = true;
while (isTruncated) {
    listObjectsResponse = client.listObjects(listObjectsRequest);
    isTruncated = listObjectsResponse.isTruncated();
    if (listObjectsResponse.getNextMarker() != null) {
        listObjectsRequest.withMarker(listObjectsResponse.getNextMarker());
    }
}
            

The parameters available for calling in the resolution class returned by the listObject method are as follows:

Parameters	Description
name	Bucket name
prefix	The matched objects from prefix to the first Delimiter character are returned as a group of elements
marker	Starting point of this query
maxKeys	Maximum number of requests returned
isTruncated	Indicate whether all queries are returned; false - all results are returned this time; true - not all results are returned this time
contents	A container for the returned objects
+key	Object name
+lastModified	Last modification time of the object
+eTag	The HTTP protocol entity tag of object.
+storageClass	Storage class of object
+size	The size of the object content (in bytes)
+owner	User information of the bucket corresponding to the object
++id	User ID of bucket owner
++displayName	Name of bucket owner

Simulate folder function

In BOS storage, there is no concept of folders. All elements are stored as objects. However, when using data, BOS users often need to manage files in folders. Therefore, BOS provides the ability to create simulated folders, which essentially involves creating an object with a size of 0. This object can be uploaded and downloaded, but the console will display objects ending with “/” as folders.

By combining the delimiter and prefix parameters, users can simulate folder functionalities. The combined effect of delimiter and prefix is as follows:

If prefix is set to a folder name, files starting with the prefix can be listed, including all files and subfolders (directory) recursively listed under the folder. File names are displayed in contents. If delimiter is set to /, the return values only list the files and subfolders (directory) under the folder. The names of subfolders (directory) under the folder are returned in the CommonPrefixes. The files and folders recursively listed under the subfolders are not displayed.

The following are several application methods:

List all files in the bucket

When users need to get all files under a bucket, they can refer to [Pagination to Get All Objects](#Advanced listing via parameters)

Recursively list all files in a directory

You can obtain all files in the a directory by setting the Prefix parameter:

                Java
                
            

                // Construct a ListObjectsRequest request
ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
    
 // Recursively list all files under the fun directory
listObjectsRequest.setPrefix("fun/");
    
ListObjectsResponse listing = client.listObjects(listObjectsRequest);
    
 // Traverse all objects
System.out.println("Objects:");
for (BosObjectSummary objectSummary : listing.getContents()) {
    System.out.println(objectSummary.getKey());
	}
}
            

Output:

Plain Text

1Objects:
2fun/
3fun/movie/001.avi
4fun/movie/007.avi
5fun/test.jpg

View files and subdirectories in a directory

With the combination of Prefix and Delimiter, it can list files and subdirectories under the directory:

                Java
                
            

                // Construct a ListObjectsRequest request
ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
    
 // "/" is the delimiter for folders
listObjectsRequest.setDelimiter("/");
    
 //List all files and folders under the “fun” directory
listObjectsRequest.setPrefix("fun/");
    
ListObjectsResponse listing = client.listObjects(listObjectsRequest);
    
 // Traverse all objects
System.out.println("Objects:");
for (BosObjectSummary objectSummary : listing.getContents()) {
    System.out.println(objectSummary.getKey());
}
    
 // Traverse all CommonPrefix
System.out.println("\nCommonPrefixs:");
for (String commonPrefix : listing.getCommonPrefixes()) {
    System.out.println(commonPrefix);
}
            

Output:

Plain Text

1Objects:
2fun/
3fun/test.jpg
4
5CommonPrefixs:
6fun/movie/

In the returned results, the list in ObjectSummaries shows the files under the fun directory. The list in CommonPrefixs shows all subfolders under the fun directory. It can be seen that the two files fun/movie/001.avi and fun/movie/007.avi are not listed because they belong to the movie directory under the fun folder.

List storage properties of objects in a bucket

After users complete the upload, if they need to view the storage class properties of all objects in a specified bucket, it can be achieved through the following code:

                Java
                
            

                public void listObjectsStorageClass(){
    ListObjectsResponse listObjectResponse = client.listObjects("bucketName");
    List<BosObjectSummary> objectList = listObjectResponse.getContents();
    for(int i=0; i<objectList.length(); i++) {
        System.out.println(objectList[i].getStorageClass());
    }
}
            

Get directory capacity overview

Users can get the current capacity, number of objects, and number of files under a bucket or a specified prefix through the following code. Here, the term “file” refers to ordinary files, excluding folders, let alone directories in the logical sense of delimiters. An “object” is the number of keys actually stored in the bucket. That is, the number of files is equal to the number of objects minus the number of objects ending with a delimiter. For example, if there are 9 objects in the current directory, 5 of which are folders and 4 are files, then the number of files found is 4, and the number of objects is 9.

                Java
                
            

                public void stateSummary(BosClient client, String bucketName, String prefix) {
 // Get the current capacity, number of objects, and number of files under the bucket
    StateSummaryResponse response = client.stateSummary(bucketName);
    System.out.println("currSize : " + response.getTotalSize());
    System.out.println("objectsCount : " + response.getObjectsCount());
    System.out.println("filesCount : " + response.getFilesCount());
}
            

Get the capacity, number of objects, and number of files of objects with a specified prefix:

                Java
                
            

                public StateSummaryResponse stateSummaryWithPrefix(BosClient client, String bucketName, String prefix) {
    StateSummaryRequest request = new StateSummaryRequest();
    request.setBucketName(this.bucketName);
    request.setPrefix("dir/x");
    StateSummaryResponse response = client.stateSummary(request);
    return response;
}
            

Object permission control

Set access permission for an object.

Currently, BOS supports two methods for setting ACLs. The first method is to use Canned ACL. During PutObjectAcl, the object access permission is set via the header "x-bce-acl" or "x-bce-grant-permission". Currently configurable permissions include private and public-read. The two types of headers cannot appear in the same request simultaneously. The second method is to upload an ACL file.

For detailed information, please refer to Setting Object Access Control, or check Demo Examples.

Set object access permission using the headers "x-bce-acl" or "x-bce-grant-permission"

set object acl First method (Set via request headers)

                Java
                
                SetObjectAclRequest setObjectAclRequest = new SetObjectAclRequest("yourBucketName","objectKey",CannedAccessControlList.PublicRead);
client.setObjectAcl(setObjectAclRequest);

set object acl First method (Set xBceGrantRead via request headers)

                Java
                
            

                String xBceGrantRead = "id=\"user_id1\""+",id=\"user_id2\"";
SetObjectAclRequest setObjectAclRequest = new SetObjectAclRequest();
setObjectAclRequest.withBucketName("yourBucketName");
setObjectAclRequest.withKey("objectKey");
setObjectAclRequest.setxBceGrantRead(xBceGrantRead);
client.setObjectAcl(setObjectAclRequest);
            

set object acl First method (Set xBceGrantFullControl via request headers)

                Java
                
            

                String xBceGrantFullControl = "id=\"user_id1\""+",id=\"user_id2\"";
SetObjectAclRequest setObjectAclRequest = new SetObjectAclRequest();
setObjectAclRequest.withBucketName("yourBucketName");
setObjectAclRequest.withKey("objectKey");
setObjectAclRequest.setxBceGrantFullControl(xBceGrantFullControl);
client.setObjectAcl(setObjectAclRequest);
            

Set object access permission via setObjectAcl

set object acl Second Method (JSON string)

                Java
                
                String jsonObjectAcl = "{\"accessControlList\":["+ "{\"grantee\":[{\"id\":\"*\"}], "+ "\"permission\":[\"FULL_CONTROL\"]"+"}]}";
SetObjectAclRequest setObjectAclRequest = new SetObjectAclRequest("yourBucketName","objectKey",jsonObjectAcl);
client.setObjectAcl(setObjectAclRequest);

set object acl Second Method, by which users only need to specify the specified parameters

                Java
                
            

                List<Grant> grants = new ArrayList<Grant>();
List<Grantee> grantees = new ArrayList<Grantee>();
List<Permission> permissions = new ArrayList<Permission>();
 // Grant permission to specific user
grantees.add(new Grantee("user_id1"));
grantees.add(new Grantee("user_id2"));
grantees.add(new Grantee("user_id3"));
 // Set permissions
permissions.add(Permission.READ);
grants.add(new Grant().withGrantee(grantees).withPermission(permissions));
SetObjectAclRequest setObjectAclRequest = new SetObjectAclRequest("yourBucketName","objectKey", grants);
client.setObjectAcl(setObjectAclRequest);
            

View object permissions

The following code can be used to check the object permissions:

                Java
                
                GetObjectAclRequest getObjectRequest = new GetObjectAclRequest();
getObjectRequest.withBucketName("yourBucketName");
getObjectRequest.withKey("objectKey");
GetObjectAclResponse response = client.getObjectAcl(getObjectRequest);

The parameters available for calling in the resolution class returned by the getObjectAcl method are as follows:

Parameters	Description
accessControlList	Identify the permission list of the object
grantee	Identify the grantee
-id	Authorized person ID
permission	Identify the grantee permissions

Delete object permissions

The following code can be used to delete the object permissions:

                Java
                
                DeleteObjectAclRequest deleteObjectAclRequest = new DeleteObjectAclRequest("yourBucketName","objectKey");
client.deleteObjectAcl(deleteObjectAclRequest);

Delete file

For the sample code, please refer to File Deletion Demo

Delete single file

The following code can be referenced to delete an object:

                Java
                
                public void deleteObject(BosClient client, String bucketName, String objectKey) {
 // Delete Object
 client.deleteObject(＜BucketName＞, ＜ObjectKey＞);   //Specify the name of the bucket where the object to be deleted is located and the name of the object
}

Delete multiple files

Delete multiple files

You can refer to the following two methods to delete multiple objects:

                Java
                
            

                // 1. In the form of a Json string
String jsonObjectKeys = "{\"objects\": ["+"{\"key\": \"token1.h\"},"+"{\"key\": \"token2.h\"}"+"]}";
DeleteMultipleObjectsRequest request = new DeleteMultipleObjectsRequest();
request.setBucketName("yourBucketName");
request.setJsonDeleteObjects(jsonObjectKeys);
client.deleteMultipleObjects(request);
            

                Java
                
            

                // 2. Users only need to specify the parameters
List<String> objectKeys = new ArrayList<String>();
objectKeys.add("object1");
objectKeys.add("object2");
DeleteMultipleObjectsRequest request = new DeleteMultipleObjectsRequest();
request.setBucketName("yourBucketName");
request.setObjectKeys(objectKeys);
DeleteMultipleObjectsResponse response = client.deleteMultipleObjects(request);
            

1,000 objects can be deleted at most via a single request. The message body (body) does not exceed 2 M. The returned message body only includes erroneous object results in the deletion process; no message body is returned if all objects are deleted successfully.

Check if a file exists

Users can check if a file exists through the following operations:

                Java
                
                // Returns true if it exists, false if it does not exist, and other exceptions will be thrown
bool exists = client.doesObjectExist("bucketName", "objectKey");

Get and update file meta information

File metadata, or object metadata, describes the attributes of files uploaded to BOS. It includes two types: HTTP standard attributes (HTTP headers) and user-defined metadata.

Get file meta information

Refer to [Retrieve Only ObjectMetadata](#Other methods), or Demo

Modify file meta information

BOS modifies object metadata by copying the object. When copying, set the destination bucket and object as the source bucket and object, then apply the new metadata. If new metadata is not specified, an error will occur.

                Java
                
            

                  public void setObjectMeta(BosClient client, String bucketName, String objectKey, ObjectMetadata newObjectMetadata) {
        
        CopyObjectRequest request = new CopyObjectRequest(bucketName, objectKey, bucketName, objectKey);
 //Set new ObjectMetadata
        request.setNewObjectMetadata(newObjectMetadata);
 // Copy Object
        CopyObjectResponse copyObjectResponse = client.copyObject(request);
 // Print results
        System.out.println("ETag: " + copyObjectResponse.getETag() + " LastModified: " + copyObjectResponse.getLastModified());
    }
            

Copy files

For the sample code, please refer to File Copy Demo

Copy a file

Users can copy an object using the copyObject method, as shown in the following code:

                Java
                
                public void copyObject(BosClient client, String srcBucketName, String srcKey, String destBucketName, String destKey) {
    
 // Copy Object
    CopyObjectResponse copyObjectResponse = client.copyObject(srcBucketName, srcKey, destBucketName, destKey);
    
 // Print results
    System.out.println("ETag: " + copyObjectResponse.getETag() + " LastModified: " + copyObjectResponse.getLastModified());
}

The copyObject method returns a CopyObjectResponse object containing the new object's ETag and modification time.

Copy Object via CopyObjectRequest

Users can also copy object via CopyObjectRequest. the code is as follows:

                Java
                
            

                // Initialize BosClient
BosClient client = ...;
    
 // Create CopyObjectRequest object
CopyObjectRequest copyObjectRequest = new CopyObjectRequest(srcBucketName, srcKey, destBucketName, destKey);
    
 // Set new Metadata
Map<String, String> userMetadata = new HashMap<String, String>();
userMetadata.put('<user-meta-key>','<user-meta-value>');
ObjectMetadata meta = new ObjectMetadata();
meta.setUserMetadata(userMetadata);
copyObjectRequest.setNewObjectMetadata(meta);
    
 // Copy Object
CopyObjectResponse copyObjectResponse = client.copyObject(copyObjectRequest);
    
System.out.println("ETag: " + copyObjectResponse.getETag() + " LastModified: " + copyObjectResponse.getLastModified());
            

CopyObjectRequest allows users to modify the ObjectMeta of the target object and also provides the setting of the MatchingETagConstraints parameter.

Set the copy attribute of the object

BOS provides a CopyObject API for copying an existing object to a different object. During the copying process, it evaluates the source object’s ETag or modification status to determine whether to proceed. Detailed parameter descriptions are as follows:

Name	Types	Description	Whether required
x-bce-copy-source-if-match	String	If the ETag value of the source object matches the ETag value provided by the user, the copy operation is performed; otherwise, it fails.	No
x-bce-copy-source-if-none-match	String	If the ETag value of the source object does not match the ETag value provided by the user, the copy operation is performed; otherwise, it fails.	No
x-bce-copy-source-if-unmodified-since	String	If the source object has not been modified since x-bce-copy-source-if-unmodified-since, the copy operation will proceed; otherwise, it will fail.	No
x-bce-copy-source-if-modified-since	String	If the source object has been modified since x-bce-copy-source-if-modified-since, the copy operation will proceed; otherwise, it will fail.	No

The corresponding example code:

                Java
                
            

                // Initialize BosClient
BosClient client = ...;
 // Create CopyObjectRequest object
CopyObjectRequest copyObjectRequest = new CopyObjectRequest(srcBucketName, srcKey, destBucketName, destKey);
 // Set new Metadata
Map<String, String> userMetadata = new HashMap<String, String>();
userMetadata.put("<user-meta-key>","<user-meta-value>");
        
meta.setUserMetadata(userMetadata);
copyObjectRequest.setNewObjectMetadata(meta);
//copy-source-if-match
copyObjectRequest.withETag("111111111183bf192b57a4afc76fa632");
//copy-source-if-none-match
copyObjectRequest.withNoMatchingETagConstraint("111111111183bf192b57a4afc76fa632");
        
Date modifiedSinceConstraint = new Date();    
SimpleDateFormat df = new SimpleDateFormat("E, dd MMM yyyy HH:mm:ss z", Locale.UK);  
df.setTimeZone(new java.util.SimpleTimeZone(0, "GMT"));        
String date = df.format(modifiedSinceConstraint);
//copy-source-if-modified-since
copyObjectRequest.withModifiedSinceConstraint(date);
//copy-source-if-unmodified-since
copyObjectRequest.withUnmodifiedSinceConstraint(date);
 // Copy Object
CopyObjectResponse copyObjectResponse = client.copyObject(copyObjectRequest);
System.out.println("ETag: " + copyObjectResponse.getETag() + " LastModified: " + copyObjectResponse.getLastModified());
            

Synchronous copy function

Currently, BOS’s CopyObject API operates in a synchronous manner. This means BOS waits until the copy operation is fully completed before returning a success status. While synchronous copying provides a more accurate status for users, it also takes longer and is proportional to the file size.

The synchronous copy approach aligns better with industry standards and improves compatibility with other platforms. It also simplifies the server’s business logic and enhances service efficiency.

If you are using an SDK version earlier than bce-java-sdk-0.10.8, you might encounter scenarios where the copy request succeeds but the actual file copy fails. It is therefore recommended to use the latest version of the SDK.

Multipart copy

Apart from using the CopyObject API for copying, BOS offers another method—Multipart Upload Copy. This method is suitable for the following application scenarios (but not limited to these):

When a resumable copy process is required.
For copying files larger than 5GB.
When the connection to the BOS server frequently disconnects due to poor network conditions.

The following section introduces the step-by-step process for implementing the three-step copy method.

The three-step copy process includes three stages: initialization ("init"), "copy part," and completion. The initialization and completion steps are the same as those for multipart uploads.

For easier understanding, the complete code for three-step copy is provided below:

                Java
                
            

                //Step I: init
InitiateMultipartUploadRequest initiateMultipartUploadRequest =
        new InitiateMultipartUploadRequest("targetBucketName","targetObjectName");
InitiateMultipartUploadResponse initiateMultipartUploadResponse =
        client.initiateMultipartUpload(initiateMultipartUploadRequest);
 //Step II: Multipart copy
long left_size=client.getObjectMetadata("sourceBucketName","sourceObjectName").getContentLength();
long skipBytes = 0;
int partNumber = 1;
List<PartETag> partETags = new ArrayList<PartETag>();
while (left_size > 0) {
    long partSize = 1024 * 1024 * 1L;
    if (left_size < partSize) {
        partSize = left_size;
    }
    UploadPartCopyRequest uploadPartCopyRequest = new UploadPartCopyRequest();
    uploadPartCopyRequest.setBucketName("targetBucketName");
    uploadPartCopyRequest.setKey("targetObjectName");
    uploadPartCopyRequest.setSourceBucketName("sourceBucketName");
    uploadPartCopyRequest.setSourceKey("sourceObjectName");
    uploadPartCopyRequest.setUploadId(initiateMultipartUploadResponse.getUploadId());
    uploadPartCopyRequest.setPartSize(partSize);
    uploadPartCopyRequest.setOffSet(skipBytes);
    uploadPartCopyRequest.setPartNumber(partNumber);
    UploadPartCopyResponse uploadPartCopyResponse = client.uploadPartCopy(uploadPartCopyRequest);
 // Save the returned PartETag to the list
    PartETag partETag = new PartETag(partNumber,uploadPartCopyResponse.getETag());
    partETags.add(partETag);
    left_size -= partSize;
    skipBytes += partSize;
    partNumber+=1;
}
 //Step III: complete
CompleteMultipartUploadRequest completeMultipartUploadRequest =
        new CompleteMultipartUploadRequest("targetBucketName", "targetObjectName", initiateMultipartUploadResponse.getUploadId(), partETags);
CompleteMultipartUploadResponse completeMultipartUploadResponse =
        client.completeMultipartUpload(completeMultipartUploadRequest);
            

Note:

The offset parameter is specified in bytes and represents the starting position of the part within the file.

The size parameter is in bytes and defines the size of each part. Except for the last part, the size of other Parts must be larger than 5MB。

Select file

The BOS Java SDK provides the SelectObject API, which is used to execute SQL statements on specified objects in the bucket and return the selected content. Please refer to [Select Object](BOS/API Reference/Object-Related Interface/Select scanning/SelectObject.md). Currently, supported object types are CSV (including TSV and other CSV-like files) and JSON files:

For the sample code, please refer to File Selection Demo

Select CSV files
Select JSON files

Select CSV files

For selecting CSV files with the Java SDK, please refer to the following code:

                Java
                
            

                final String csvContent = "header1,header2,header3\r\n" +
                          "1,2,3.4\r\n" +
                          "a,b,c\r\n" +
                          "\"d\",\"e\",\"f\"\r\n" +
                          "true,false,true\r\n" +
                          "2006-01-02 15:04:06,2006-01-02 16:04:06,2006-01-02 17:04:06";
client.putObject("bucketName", "test-csv", new ByteArrayInputStream(csvContent.getBytes()));
SelectObjectRequest request = new SelectObjectRequest("bucketName", "test-csv")
        .withSelectType("csv")                                   
        .withExpression("select * from BosObject limit 3")
        .withInputSerialization(new InputSerialization()
                .withCompressionType("NONE")
                .withFileHeaderInfo("NONE")
                .withRecordDelimiter("\r\n")
                .withFieldDelimiter(",")
                .withQuoteCharacter("\"")
                .withCommentCharacter("#"))
        .withOutputSerialization(new OutputSerialization()
                .withOutputHeader(false)
                .withQuoteFields("ALWAYS")
                .withRecordDelimiter("\n")
                .withFieldDelimiter(",")
                .withQuoteCharacter("\""))
        .withRequestProgress(false);
SelectObjectResponse response = client.selectObject(request);
 // Output the returned records
SelectObjectResponse.Messages messages = response.getMessages();
while (messages.hasNext()) {
    SelectObjectResponse.CommonMessage message = messages.next();
    if (message.Type.equals("Records")) {
        for (String record: message.getRecords()) {
            System.out.println(record);
        }
    }
}
            

Results of selecting CSV files:

                Java
                
                "header1","header2","header3"
"1","2","3.4"
"a","b","c"

Note:

In Unix/Linux systems, each line ends with only a "", i.e., "\n";

In Windows systems, each line ends with a "", i.e., "\r\n";

In Mac systems, each line ends with a "", i.e., "". Only Mac OS before version 9 uses '\r'.

Set the recordDelimiter appropriately based on the file content.

Select JSON files

For selecting JSON files with the Java SDK, please refer to the following code:

                Java
                
            

                final String jsonContent = "{\n" +
        "\t\"name\": \"Smith\",\n" +
        "\t\"age\": 16,\n" +
        "\t\"org\": null\n" +
        "}\n" +
        "{\n" +
        "\t\"name\": \"charles\",\n" +
        "\t\"age\": 27,\n" +
        "\t\"org\": \"baidu\"\n" +
        "}\n" +
        "{\n" +
        "\t\"name\": \"jack\",\n" +
        "\t\"age\": 35,\n" +
        "\t\"org\": \"bos\"\n" +
        "}";
client.putObject("bucketName", "test-json", new ByteArrayInputStream(jsonContent.getBytes()));
SelectObjectRequest request = new SelectObjectRequest("bucketName", "test-json")
        .withSelectType("json")
        .withExpression("select * from BosObject where age > 20")
        .withInputSerialization(new InputSerialization()
                .withCompressionType("NONE")
                .withJsonType("LINES"))
        .withOutputSerialization(new OutputSerialization()
                .withRecordDelimiter("\n"))
        .withRequestProgress(false);
SelectObjectResponse response = client.selectObject(request);
 // Output the returned records
SelectObjectResponse.Messages messages = response.getMessages();
while (messages.hasNext()) {
    SelectObjectResponse.CommonMessage message = messages.next();
    if (message.Type.equals("Records")) {
        for (String record: message.getRecords()) {
            System.out.println(record);
        }
    }
}
            

Results of selecting JSON files:

                Java
                
                {"name":"charles","age":27,"org":"baidu"}
{"name":"jack","age":35,"org":"bos"}

Note that when querying CSV and JSON files, the parameters for initializing SelectObjectRequest differ significantly. For detailed parameter settings, please refer to [SelectObject API](BOS/API Reference/Object-Related Interface/Select scanning/SelectObject.md).

Initialization

FAQs