Document Center
edit-icon download-icon

Download objects

Last Updated: Oct 31, 2017

Simple download

You can download a specified object, and obtain the input stream of the downloaded object. This operation requires read permission on the object.

Synchronous call:

  1. // Construct an object download request
  2. GetObjectRequest get = new GetObjectRequest("<bucketName>", "<objectKey>");
  4. //Set download progress callback
  5. get.setProgressListener(new OSSProgressCallback<GetObjectRequest>() {
  6.             @Override
  7.             public void onProgress(GetObjectRequest request, long currentSize, long totalSize) {
  8.                 OSSLog.logDebug("getobj_progress: " + currentSize+"  total_size: " + totalSize, false);
  9.             }
  10.         });
  12. try {
  13.     // Process the download request synchronously and then return the result
  14.     GetObjectResult getResult = oss.getObject(get);
  16.     Log.d("Content-Length", "" + getResult.getContentLength());
  18.     // Obtain the object input stream
  19.     InputStream inputStream = getResult.getObjectContent();
  21.     byte[] buffer = new byte[2048];
  22.     int len;
  24.     while ((len = inputStream.read(buffer)) != -1) {
  25.         // Process the downloaded data, such as image display or object write
  26.     }
  28.     // Display the metadata of the downloaded object
  29.     ObjectMetadata metadata = getResult.getMetadata();
  30.     Log.d("ContentType", metadata.getContentType());
  33. } catch (ClientException e) {
  34.     // Local exception, such as a network exception
  35.     e.printStackTrace();
  36. } catch (ServiceException e) {
  37.     // Service exception
  38.     Log.e("RequestId", e.getRequestId());
  39.     Log.e("ErrorCode", e.getErrorCode());
  40.     Log.e("HostId", e.getHostId());
  41.     Log.e("RawMessage", e.getRawMessage());
  42. } catch (IOException e) {
  43.     e.printStackTrace();
  44. }

Asynchronous call:

  1. GetObjectRequest get = new GetObjectRequest("<bucketName>", "<objectKey>");
  2. //Set download progress callback
  3. get.setProgressListener(new OSSProgressCallback<GetObjectRequest>() {
  4.             @Override
  5.             public void onProgress(GetObjectRequest request, long currentSize, long totalSize) {
  6.                 OSSLog.logDebug("getobj_progress: " + currentSize+"  total_size: " + totalSize, false);
  7.             }
  8.         });
  9. OSSAsyncTask task = oss.asyncGetObject(get, new OSSCompletedCallback<GetObjectRequest, GetObjectResult>() {
  10.     @Override
  11.     public void onSuccess(GetObjectRequest request, GetObjectResult result) {
  12.         // Request succeeds
  13.         InputStream inputStream = result.getObjectContent();
  15.         byte[] buffer = new byte[2048];
  16.         int len;
  18.         try {
  19.             while ((len = inputStream.read(buffer)) != -1) {
  20.                 // Process the downloaded data
  21.             }
  22.         } catch (IOException e) {
  23.             e.printStackTrace();
  24.         }
  25.     }
  27.     @Override
  28.     public void onFailure(GetObjectRequest request, ClientException clientExcepion, ServiceException serviceException) {
  29.         // Request exception
  30.         if (clientExcepion != null) {
  31.             // Local exception, such as a network exception
  32.             clientExcepion.printStackTrace();
  33.         }
  34.         if (serviceException != null) {
  35.             // Service exception
  36.             Log.e("ErrorCode", serviceException.getErrorCode());
  37.             Log.e("RequestId", serviceException.getRequestId());
  38.             Log.e("HostId", serviceException.getHostId());
  39.             Log.e("RawMessage", serviceException.getRawMessage());
  40.         }
  41.     }
  42. });

Image processing

Image processing is a service provided to external users by Alibaba Cloud OSS that features massive processing power, security, low costs, and high reliability.

By uploading and storing source images in OSS, you can process images anytime, anywhere, and on any Internet device through a simple RESTful interface.

The OSS image processing offers image processing interfaces. For image uploads, use the OSS upload interfaces. You can build your own image processing service based on OSS image processing.

OSS image processing provides the following features:

While using SDK, you only need to call the request.setxOssProcess() method to process parameters when downloading images. Example:

  1. // Construct the image download request
  2. GetObjectRequest get = new GetObjectRequest("<bucketName>", "example.jpg");
  4. // Image processing
  5. request.setxOssProcess("image/resize,m_fixed,w_100,h_100");
  7. OSSAsyncTask task = oss.asyncGetObject(get, new OSSCompletedCallback<GetObjectRequest, GetObjectResult>() {
  8.     @Override
  9.     public void onSuccess(GetObjectRequest request, GetObjectResult result) {
  10.         // Request succeeds
  11.         InputStream inputStream = result.getObjectContent();
  13.         byte[] buffer = new byte[2048];
  14.         int len;
  16.         try {
  17.             while ((len = inputStream.read(buffer)) != -1) {
  18.                 // Process the downloaded data
  19.             }
  20.         } catch (IOException e) {
  21.             e.printStackTrace();
  22.         }
  23.     }
  25.     @Override
  26.     public void onFailure(GetObjectRequest request, ClientException clientExcepion, ServiceException serviceException) {
  27.         // Processing exception
  28.     }
  29. });

Download within a specified range

You can specify a range for downloading an object. This feature applies to large objects. If the Range parameter is specified in the request header, the returned message contains the length of the entire object and the range of the returned object content.

For example:

  1. GetObjectRequest get = new GetObjectRequest("<bucketName>", "<objectKey>");
  3. // Set the range
  4. get.setRange(new Range(0, 99)); // Download 100 (from 0 to 99) bytes starting from 0
  5. // get.setRange(new Range(100, Range.INFINITE)); // Download the range starting from the 100th byte to the end of the object 
  7. OSSAsyncTask task = oss.asyncGetObject(get, new OSSCompletedCallback<GetObjectRequest, GetObjectResult>() {
  8.     @Override
  9.     public void onSuccess(GetObjectRequest request, GetObjectResult result) {
  10.         // Request succeeds
  11.         InputStream inputStream = result.getObjectContent();
  13.         byte[] buffer = new byte[2048];
  14.         int len;
  16.         try {
  17.             while ((len = inputStream.read(buffer)) != -1) {
  18.                 // Process the downloaded data
  19.             }
  20.         } catch (IOException e) {
  21.             e.printStackTrace();
  22.         }
  23.     }
  25.     @Override
  26.     public void onFailure(GetObjectRequest request, ClientException clientExcepion, ServiceException serviceException) {
  27.         // Request exception
  28.         if (clientExcepion != null) {
  29.             // Local exception, such as a network exception
  30.             clientExcepion.printStackTrace();
  31.         }
  32.         if (serviceException != null) {
  33.             // Service exception
  34.             Log.e("ErrorCode", serviceException.getErrorCode());
  35.             Log.e("RequestId", serviceException.getRequestId());
  36.             Log.e("HostId", serviceException.getHostId());
  37.             Log.e("RawMessage", serviceException.getRawMessage());
  38.         }
  39.     }
  40. });

Retrieve the object metadata only

The headObject method can be used to obtain only the metadata of an object without the object body. The code is as follows:

  1. // Create a request for synchronously obtaining object metadata
  2. HeadObjectRequest head = new HeadObjectRequest("<bucketName>", "<objectKey>");
  4. OSSAsyncTask task = oss.asyncHeadObject(head, new OSSCompletedCallback<HeadObjectRequest, HeadObjectResult>() {
  5.     @Override
  6.     public void onSuccess(HeadObjectRequest request, HeadObjectResult result) {
  7.         Log.d("headObject", "object Size: " + result.getMetadata().getContentLength());
  8.         Log.d("headObject", "object Content Type: " + result.getMetadata().getContentType());
  9.     }
  11.     @Override
  12.     public void onFailure(HeadObjectRequest request, ClientException clientExcepion, ServiceException serviceException) {
  13.         // Request exception
  14.         if (clientExcepion != null) {
  15.             // Local exception, such as a network exception
  16.             clientExcepion.printStackTrace();
  17.         }
  18.         if (serviceException != null) {
  19.             // Service exception
  20.             Log.e("ErrorCode", serviceException.getErrorCode());
  21.             Log.e("RequestId", serviceException.getRequestId());
  22.             Log.e("HostId", serviceException.getHostId());
  23.             Log.e("RawMessage", serviceException.getRawMessage());
  24.         }
  25.     }
  26. });
  28. // task.waitUntilFinished();
Thank you! We've received your feedback.
Free Trial Free Trial