--- title: "Subir objeto" url: https://docs.catalyst.zoho.com/es/sdk/java/v1/cloud-scale/stratus/upload-object/ description: "Esta página lista el método del Java SDK para subir objetos a un bucket." last_updated: 2026-03-30T08:10:30Z service: Cloud Scale type: general related_links: - name: "Stratus Component Help Documentation" url: /es/cloud-scale/help/stratus/introduction - name: "Upload Object Help Documentation" url: /es/cloud-scale/help/stratus/objects/upload-object/ - name: "Node.js SDK" url: /es/sdk/nodejs/v2/cloud-scale/stratus/upload-object/ - name: "Python SDK" url: /es/sdk/python/v1/cloud-scale/stratus/upload-object/ - name: "Web SDK" url: /es/sdk/web/v4/cloud-scale/stratus/upload-object/ - name: "iOS SDK" url: /es/sdk/ios/v2/cloud-scale/stratus/upload-object/ - name: "Android SDK" url: /es/sdk/android/v2/cloud-scale/stratus/upload-object/ - name: "Flutter SDK" url: /es/sdk/flutter/v2/cloud-scale/stratus/upload-object/ - name: "REST API" url: /es/api/code-reference/cloud-scale/stratus/get-all-buckets/#GetAllBuckets --- # Subir objeto Los métodos del SDK listados en esta sección te permitirán [subir objetos](https://docs.catalyst.zoho.com/es/cloud-scale/help/stratus/objects/upload-object/) al [bucket](https://docs.catalyst.zoho.com/es/cloud-scale/help/stratus/buckets/name-bucket/) de diversas maneras. Puedes subir objetos como un **string** o como un **stream**. La referencia de Bucket utilizada en el siguiente fragmento de código es la [instancia del componente](https://docs.catalyst.zoho.com/es/sdk/java/v1/cloud-scale/stratus/create-bucket-instance/). Si no tienes habilitado [Versioning](https://docs.catalyst.zoho.com/es/cloud-scale/help/stratus/stratus-config/general-settings/#versioning) para tu objeto, y si Stratus recibe múltiples solicitudes de escritura para el mismo objeto, el objeto se sobrescribirá continuamente. La última carga del objeto será el único objeto que se almacene. Sin embargo, con Versioning habilitado, cada carga se considerará una versión del objeto, y todas se almacenarán en el bucket, cada una con un `versionId` único. > **Nota:** Los siguientes caracteres, incluido el espacio, no son compatibles al crear una ruta o un objeto: comillas dobles, ambos corchetes angulares, numeral, barra invertida y símbolo de barra vertical. ### Subir objeto como stream Usando este método del SDK, puedes subir objetos a un bucket como stream. Almacena el stream en una variable y luego pasa esa variable en el método de carga. #### Fragmento de código de ejemplo **Package Imports** ```java import com.zc.component.stratus.beans.ZCPutObjectOptions; import java.nio.file.Path; import java.nio.file.Files; import java.nio.file.StandardCopyOption; import java.io.*; ``` ```java InputStream file =new FileInputStream("filePath"); Boolean res = bucket.putObject("sam/out/sample.txt", file); System.out.println(res); ``` ### Subir objeto como string Usando este método del SDK, puedes subir el objeto como un string. Pasarás el nombre del objeto y los datos a almacenar en el objeto en formato string en el método de carga; `putObject()` #### Fragmento de código de ejemplo **Package Imports** ```java import com.zc.component.stratus.beans.ZCPutObjectOptions; import java.nio.file.Path; import java.nio.file.Files; import java.nio.file.StandardCopyOption; import java.io.*; ``` ```java Boolean res = bucket.putObject("sam/out/sample.txt", "content of the file"); System.out.println(res); ``` ### Subir objeto con opciones Usando este método del SDK, puedes usar las siguientes opciones al subir un objeto. * `setOverwrite()`: Esta es una opción que puedes usar si *Versioning* no está habilitado para tu bucket. Sin versionado, necesitas usar esta opción si deseas sobrescribir un recurso. El valor predeterminado es '**false**'. * `setTTL()`: Esta es una opción que puedes usar para establecer el **Time-to-Live** (TTL) en segundos para un objeto. El valor debe ser mayor o igual a **60 segundos**. * `setMetaData()`: Esta es una opción que puedes usar para subir los [detalles de metadatos](https://docs.catalyst.zoho.com/es/cloud-scale/help/stratus/objects/introduction/#metadata) del objeto que se está subiendo. * `contentType`: Esta es una opción que puedes proporcionar si necesitas establecer el tipo MIME del objeto. #### Fragmento de código de ejemplo **Package Imports** ```java import com.zc.component.stratus.beans.ZCPutObjectOptions; import java.nio.file.Path; import java.nio.file.Files; import java.nio.file.StandardCopyOption; import java.util.Map; import java.io.*; ``` ```java ZCPutObjectOptions options = ZCPutObjectOptions.getInstance(); options.setTTL("1000"); options.setOverwrite("true"); Map<String, String> metaData = new HashMap<String, String>(); metaData.put("author", "John"); options.setMetaData(metaData); InputStream file = new FileInputStream("filePath"); Boolean res = bucket.putObject("sam/out/sample.txt", file, options); System.out.println(res); ``` ### Subir objeto con opción de extracción Cuando subes un objeto comprimido usando el método del SDK `putZipObject()`, los objetos presentes en el zip se extraerán y se subirán. #### Fragmento de código de ejemplo **Package Imports** ```java import com.zc.component.stratus.ZCBucket; import com.zc.component.stratus.ZCStratus; import com.zc.component.stratus.beans.ZCPutObjectOptions; ``` ```java ZCStratus stratus = ZCStratus.getInstance(); ZCBucket bucket = stratus.bucketInstance("sam1"); ZCPutObjectOptions options = ZCPutObjectOptions.getInstance(); options.setOverwrite("true"); InputStream stream = new FileInputStream("file_path"); JSONObject object = bucket.putZipObject("sam.zip", stream, options); ``` Este método del SDK devolverá el valor de un `taskId`. Puedes usar este valor para conocer el estado de la extracción usando este [método del SDK](https://docs.catalyst.zoho.com/es/sdk/java/v1/cloud-scale/stratus/extract-zipped-object/#get-zip-extraction-status). **Ejemplo de respuesta** ```json { 'task_id': '1234263749' } ``` ### Subir un objeto usando operaciones multipart Cuando el objeto que necesitas subir es demasiado grande para subirlo de una vez, puedes realizar una operación multipart. La operación multipart dividirá el objeto en múltiples partes y realizará una carga más rápida. En esta sección del SDK, vamos a revisar todos los métodos del SDK disponibles para realizar la carga multipart de objetos en Stratus. #### Iniciar carga multipart Usando el siguiente método del SDK, vamos a devolver un `uploadId`. Este ID nos permitirá subir múltiples partes del objeto. #### Fragmento de código de ejemplo **Package Imports** ```java import com.zc.component.stratus.beans.ZCInitiateMultipartUpload; ``` ```java ZCInitiateMultipartUpload multipart = bucket.initiateMultipartUpload("sam/out/sample.txt"); ``` #### Realizar carga multipart para partes del objeto En el siguiente método del SDK, vamos a realizar cargas de las partes individuales del objeto. Cada parte tendrá un `part_number` distinto que varía entre **1 y 1000**. Aunque esto representa el ordenamiento de las partes, estas no se subirán necesariamente en secuencia. Estas partes se combinarán en secuencia una vez que la carga de todas las partes del objeto se complete. **Parámetros utilizados**
Nombre del parámetro Tipo de dato Definición
`key` **String** Un parámetro **obligatorio**. Contendrá el nombre del objeto.
`uploadId` **String** Un parámetro **obligatorio**. Este valor se devuelve en el método Iniciar carga multipart.
`part` **InputStream** Un parámetro **obligatorio**. Contendrá los datos de la parte del objeto.
`partNumber` **Int** Un parámetro **obligatorio**. Tendrá el ordenamiento de las partes que se están subiendo.
#### Fragmento de código de ejemplo **Package Imports** ```java import java.io.*; ``` ```java int partNumber = 1; InputStream part = new FileInputStream("filePath"); Boolean res = bucket.uploadPart("sam/out/sample.txt", "uploadId", part, partNumber); System.out.println(res); ``` #### Obtener resumen de carga multipart El siguiente método del SDK se puede usar para obtener un resumen operativo de todas las partes subidas. Para ver el resumen, pasamos el `uploadId` al método `getMultipartUploadSummary()`. #### Fragmento de código de ejemplo **Package Imports** ```java import com.zc.component.stratus.beans.ZCMultipartObjectSummary; ``` ```java ZCMultipartObjectSummary summaryRes = bucket.getMultipartUploadSummary("sam/out/sample.txt", "uploadId"); // acceder a las partes subidas System.out.println("Object Name:" + summaryRes.getKey()); System.out.println("Upload Id:" + summaryRes.getUploadId()); System.out.println("Status:" + summaryRes.getStatus()); System.out.println(summaryRes.getParts().get(0).getUploadedAt()); System.out.println(summaryRes.getParts().get(0).getPartNumber()); ``` #### Completar operación de carga multipart El siguiente método nos permite terminar el proceso multipart una vez que todas las partes se han subido exitosamente. Para completar el proceso, pasaremos el `uploadId` al método `completeMultipartUpload()`. ```java Boolean completeRes = bucket.completeMultipartUpload("sam/out/sample.txt", "uploadId"); System.out.println(completeRes); ``` #### Ejemplo de fragmento que ilustra la implementación de operaciones multipart #### Fragmento de código de ejemplo **Package Imports** ```java import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.logging.Logger; import java.util.logging.Level; import java.util.ArrayList; import java.util.List; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import com.catalyst.advanced.CatalystAdvancedIOHandler; import com.zc.component.stratus.ZCBucket; import com.zc.component.stratus.ZCStratus; import com.zc.component.stratus.beans.ZCInitiateMultipartUpload; import com.zc.exception.ZCServerException; import java.io.InputStream; import java.io.FileInputStream; import java.io.ByteArrayInputStream; ``` ```java public class MultipartUpload implements CatalystAdvancedIOHandler { private static final Logger LOGGER = Logger.getLogger(Sample.class.getName()); @Override public void runner(HttpServletRequest request, HttpServletResponse response) throws Exception { try { switch (request.getRequestURI()) { case "/": { ZCStratus stratus = ZCStratus.getInstance(); // obtener instancia del bucket ZCBucket bucket = stratus.bucketInstance("sample"); // subida multiparte String key = "sample.mp4"; InputStream file = new FileInputStream( "/users/sam/sample.mp4"); ZCInitiateMultipartUpload initiateUploadResponse = bucket.initiateMultipartUpload(key); String uploadId = initiateUploadResponse.getUploadId(); System.out.println("Multipart upload initiated. Upload ID: " + uploadId); // Tamaño de archivo y tamaño de parte (50 MB mínimo) int partSize = 50 * 1024 * 1024; // 50 MB long fileSize = file.available(); double result = (double) fileSize / partSize; int noOfParts = (int) Math.ceil(result); // Subir partes en paralelo List<CompletableFuture<Void>> uploadedParts = new ArrayList<>(); ExecutorService executor = Executors.newFixedThreadPool(4); int partNumber = 1; while (noOfParts >= partNumber) { int currentPartNumber = partNumber; byte[] buffer = new byte[partSize]; file.read(buffer); InputStream fileData = new ByteArrayInputStream(buffer); uploadedParts.add(CompletableFuture.runAsync(() -> { try { bucket.uploadPart(key, uploadId, fileData, currentPartNumber); LOGGER.log(Level.INFO, "Part {0} Uploaded", currentPartNumber); } catch (Exception e) { throw new RuntimeException(e); } }, executor)); partNumber++; } CompletableFuture<Void> isUploaded = CompletableFuture .allOf(uploadedParts.toArray(new CompletableFuture[0])); try { isUploaded.get(); } catch (Exception e) { throw new ZCServerException("Error while uploading the object", e); } Boolean completeRes = bucket.completeMultipartUpload(key, uploadId); if (completeRes) { LOGGER.log(Level.INFO, "Upload Completed"); } } default: { response.setStatus(404); response.getWriter().write("You might find the page you are looking for at \"/\" path"); } } } catch (Exception e) { if (e instanceof ZCServerException) { int statusCode = ((ZCServerException) e).getStatus(); System.out.println("HTTP status code: " + statusCode); } LOGGER.log(Level.SEVERE, "Exception in Sample", e); } } } ``` ### Subir un objeto usando Transfer Manager #### Crear instancia de Transfer Manager #### Fragmento de código de ejemplo **Package Imports** ```java import com.zc.component.stratus.transfer.ZCTransferManager; ``` ```java ZCTransferManager transferManager= ZCTransferManager.getInstance(bucket); ``` #### Carga multipart **Crear instancia de carga multipart** El siguiente método del SDK creará una instancia multipart iniciando la carga multipart. #### Fragmento de código de ejemplo **Package Imports** ```java import com.zc.component.stratus.beans.ZCMultipartUpload; ``` ```java ZCMultipartUpload multipart = transferManager.createMultipartInstance("sam/out/sample.txt"); ``` Si necesitas crear una instancia para una operación de carga multipart ya inicializada, entonces copia y usa el siguiente fragmento de código ```java ZCMultipartUpload multipart = transferManager.createMultipartInstance("sam/out/sample.txt", "uploadId"); ``` #### Subir parte En el siguiente método del SDK vamos a usar la instancia `multipart` que inicializamos en la sección *Crear instancia de carga multipart*. #### Fragmento de código de ejemplo **Package Imports** ```java import java.io.InputStream; ``` ```java int partNumber = 1; InputStream part = new FileInputStream("filePath"); Boolean uploadRes = multipart.uploadPart(part, partNumber); System.out.println(uploadRes); ``` #### Resumen de carga #### Fragmento de código de ejemplo **Package Imports** ```java import com.zc.component.stratus.beans.ZCMultipartObjectSummary; ``` ```java ZCMultipartObjectSummary summaryRes = multipart.getUploadSummary(); // acceder a las partes subidas System.out.println("Object Name:" + summaryRes.getKey()); System.out.println("Upload Id:" + summaryRes.getUploadId()); System.out.println("Status:" + summaryRes.getStatus()); System.out.println(summaryRes.getParts().get(0).getUploadedAt()); System.out.println(summaryRes.getParts().get(0).getPartNumber()); System.out.println(summaryRes.getParts().get(0).getSize()); ``` #### Completar carga ```java Boolean completeRes = multipart.completeUpload(); System.out.println(completeRes); ``` #### Subir objeto usando wrapper El siguiente método del SDK actúa como un wrapper, donde toda la operación de carga multipart se realiza sin emplear múltiples pasos. Usando este método, el objeto se divide en múltiples partes, se sube al bucket en múltiples partes, y luego se combina una vez que todas las partes se han subido. ```java import java.io.InputStream; import com.zc.component.stratus.beans.ZCMultipartObjectSummary; ``` ```java InputStream file =new FileInputStream("filePath"); int partSize = 50; ZCMultipartObjectSummary res = transferManager.putObjectAsParts("objetName", file, partSize); ``` > **Nota:** Para objetos que son más grandes de **2GB**, recomendamos que uses los métodos individuales del SDK para realizar la operación de carga multipart exitosamente. ### Generar URL prefirmada para subir un objeto Las URLs prefirmadas son URLs seguras que los usuarios autenticados pueden compartir con sus usuarios no autenticados. Esta URL proporcionará a los usuarios no autenticados autorización temporal para acceder a objetos. La referencia de Bucket utilizada en el siguiente fragmento de código es la [instancia del componente](https://docs.catalyst.zoho.com/es/sdk/java/v1/cloud-scale/stratus/create-bucket-instance/). > **Info:** Para usar este método del SDK, necesitas inicializarlo con el scope **Admin**. Puedes obtener más información sobre este requisito en esta [sección](https://docs.catalyst.zoho.com/es/sdk/nodejs/v2/overview/#initialize-sdk-with-scopes) **Parámetros utilizados**
Nombre del parámetro Tipo de dato Definición
`key` **String** Un parámetro **obligatorio**. Contendrá el nombre completo del objeto junto con su [ruta](https://docs.catalyst.zoho.com/es/cloud-scale/help/stratus/objects/introduction/#path).
`URL_ACTION` **Enum** Un parámetro **obligatorio**. Este es el parámetro que te permitirá generar una URL prefirmada para una acción de carga.
  • `URL_ACTION.PUT`: Para subir un objeto
`expiry` **String** Este es un parámetro **opcional**. El tiempo de validez de la URL en segundos.
  • Valor predeterminado: **3600 segundos**
  • Valor mínimo: **30 segundos**
  • Valor máximo: **7 días**
`activeFrom` **String** Este es un parámetro **opcional**. Este parámetro contendrá el tiempo después del cual la URL es válida. El valor máximo es **7 días**. Las URLs se activan tan pronto como se generan por defecto.
#### Fragmento de código de ejemplo **Package Imports** ```java import com.zc.component.stratus.enums.URL_ACTION; import org.json.simple.JSONObject; ``` ```java JSONObject res = bucket.generatePreSignedUrl("sam/out/sample.txt", URL_ACTION.PUT); System.out.println(res.get("signature")); ``` ### Generar URL prefirmada con tiempo de expiración y activación #### Fragmento de código de ejemplo **Package Imports** ```java import com.zc.component.stratus.enums.URL_ACTION; import org.json.simple.JSONObject; ``` ```java JSONObject res = bucket.generatePreSignedUrl("object_name",URL_ACTION.GET, "expiry_in","active_from"); System.out.println(res.get("signature")); ``` **Ejemplo de respuesta para generar una URL prefirmada para carga** ```json { "signature": "https://sadi-development.zohostratus.com/_signed/sam.txt?organizationId=96862383&stsCredential=96858154-96862383&stsDate=1747904989454&stsExpiresAfter=300&stsSignedHeaders=host&stsSignature=UPyH5A4AdAaCpw6S6jVhKFSxg3B0B0p619YN0cAIn4c", "expiry_in_seconds": "100", "active_from": "1726492859577" } ``` **Ejemplo de fragmento que ilustra el uso de URL prefirmada para subir un objeto** **Package Imports** ```java import okhttp3.*; import java.io.File; import java.io.IOException; ``` ```java public class BinaryFileUpload { public static void main(String[] args) throws IOException { // Crear una instancia de OkHttpClient para realizar solicitudes HTTP OkHttpClient client = new OkHttpClient(); // Especificar el archivo a subir. Reemplazar "file_path" con la ubicación real del archivo File file = new File("file_path"); // Crear el cuerpo de la solicitud con contenido binario (octet-stream) RequestBody requestBody = RequestBody.create( MediaType.parse("application/octet-stream"), // Usar un tipo MIME específico si se conoce file ); // ️ Construir la solicitud PUT con la URL pre-firmada Request request = new Request.Builder() .url("https://sadi-development.zohostratus.com/_signed/sam.txt?organizationId=96862383&stsCredential=96858154-96862383&stsDate=1747904989454&stsExpiresAfter=300&stsSignedHeaders=host&stsSignature=UPyH5A4AdAaCpw6S6jVhKFSxg3B0B0p619YN0cAIn4c") // Reemplazar con una URL real .put(requestBody) // Solicitud PUT para subir archivo .build(); // Ejecutar la solicitud y manejar la respuesta try (Response response = client.newCall(request).execute()) { if (response.isSuccessful()) { System.out.println("Object uploaded successfully"); } else { // Imprimir error si la subida falla System.err.println("Error: " + response.code() + " - " + response.body().string()); } } } } ```