Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Realizar operaciones por lotes
La API de cliente mejorado de DynamoDB ofrece dos métodos por lotes, [`batchGetItem`()](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbEnhancedClient.html#batchGetItem(java.util.function.Consumer)) y [`batchWriteItem`()](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbEnhancedClient.html#batchWriteItem(java.util.function.Consumer)).
## ejemplo de `batch GetItem ()`
Con el método [`DynamoDbEnhancedClient.batchGetItem()`](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbEnhancedClient.html#batchGetItem(java.util.function.Consumer)), puede recuperar hasta 100 elementos individuales de varias tablas en una solicitud general. En el siguiente ejemplo, se utilizan las clases de datos [`Customer`](ddb-en-client-gs-tableschema.md#ddb-en-client-gs-tableschema-anno-bean-cust) y [`MovieActor`](ddb-en-client-use-multirecord.md#ddb-en-client-use-movieactor-class) mostradas anteriormente.
En el ejemplo, después de las líneas 1 y 2, se crean objetos `[ReadBatch](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/ReadBatch.html)` que se añaden posteriormente como parámetros al método `batchGetItem()` después de la línea de comentarios 3.
El código que sigue a la línea de comentarios 1 crea el lote para leerlo de la tabla `Customer`. El código que sigue a la línea de comentario 1a muestra el uso de un compilador de `[GetItemEnhancedRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/GetItemEnhancedRequest.Builder.html)` que toma un valor de clave principal y un valor de clave de clasificación para especificar el elemento que se va a leer. Si la clase de datos tiene una clave compuesta, debe proporcionar tanto el valor de la clave de partición como el valor de la clave de clasificación.
A diferencia de especificar valores clave para solicitar un elemento, puede usar una clase de datos para solicitar un elemento, como se muestra después de la línea de comentario 1b. El SDK extrae automáticamente los valores clave de manera interna antes de enviar la solicitud.
Cuando especifique el elemento utilizando el enfoque basado en claves, como se muestra en las dos instrucciones posteriores a 2a, también puede especificar que DynamoDB realice una [lectura altamente coherente](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadConsistency.html). Cuando se utilice el método `consistentRead()`, se debe utilizar en todos los elementos solicitados de la misma tabla.
Para recuperar los elementos encontrados por DynamoDB, utilice el método `[resultsForTable() ](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/BatchGetResultPage.html#resultsForTable(software.amazon.awssdk.enhanced.dynamodb.MappedTableResource))` que se muestra después de la línea de comentarios 4. Llame al método de cada tabla que se haya leído en la solicitud. `resultsForTable()` devuelve una lista de los elementos encontrados que puede procesar mediante cualquier método `java.util.List`. En este ejemplo se registra cada elemento.
Para descubrir elementos que DynamoDB no procesó, utilice el enfoque que aparece después de la línea de comentarios 5. La clase `BatchGetResultPage` tiene el método `[unprocessedKeysForTable()](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/BatchGetResultPage.html#unprocessedKeysForTable(software.amazon.awssdk.enhanced.dynamodb.MappedTableResource))` que permite acceder a todas las claves que no se hayan procesado. La [referencia de la BatchGetItem API](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_BatchGetItem.html) contiene más información sobre situaciones que dan como resultado elementos sin procesar.
```
public static void batchGetItemExample(DynamoDbEnhancedClient enhancedClient,
DynamoDbTable customerTable,
DynamoDbTable movieActorTable) {
Customer customer2 = new Customer();
customer2.setId("2");
customer2.setEmail("cust2@example.org");
// 1. Build a batch to read from the Customer table.
ReadBatch customerBatch = ReadBatch.builder(Customer.class)
.mappedTableResource(customerTable)
// 1a. Specify the primary key value and sort key value for the item.
.addGetItem(b -> b.key(k -> k.partitionValue("1").sortValue("cust1@orgname.org")))
// 1b. Alternatively, supply a data class instances to provide the primary key values.
.addGetItem(customer2)
.build();
// 2. Build a batch to read from the MovieActor table.
ReadBatch moveActorBatch = ReadBatch.builder(MovieActor.class)
.mappedTableResource(movieActorTable)
// 2a. Call consistentRead(Boolean.TRUE) for each item for the same table.
.addGetItem(b -> b.key(k -> k.partitionValue("movie01").sortValue("actor1")).consistentRead(Boolean.TRUE))
.addGetItem(b -> b.key(k -> k.partitionValue("movie01").sortValue("actor4")).consistentRead(Boolean.TRUE))
.build();
// 3. Add ReadBatch objects to the request.
BatchGetResultPageIterable resultPages = enhancedClient.batchGetItem(b -> b.readBatches(customerBatch, moveActorBatch));
// 4. Retrieve the successfully requested items from each table.
resultPages.resultsForTable(customerTable).forEach(item -> logger.info(item.toString()));
resultPages.resultsForTable(movieActorTable).forEach(item -> logger.info(item.toString()));
// 5. Retrieve the keys of the items requested but not processed by the service.
resultPages.forEach((BatchGetResultPage pageResult) -> {
pageResult.unprocessedKeysForTable(customerTable).forEach(key -> logger.info("Unprocessed item key: " + key.toString()));
pageResult.unprocessedKeysForTable(movieActorTable).forEach(key -> logger.info("Unprocessed item key: " + key.toString()));
});
}
```
Suponga que los siguientes elementos están en las dos tablas antes de ejecutar el código de ejemplo.
### Elementos de la tabla
```
Customer [id=1, name=CustName1, email=cust1@example.org, regDate=2023-03-31T15:46:27.688Z]
Customer [id=2, name=CustName2, email=cust2@example.org, regDate=2023-03-31T15:46:28.688Z]
Customer [id=3, name=CustName3, email=cust3@example.org, regDate=2023-03-31T15:46:29.688Z]
Customer [id=4, name=CustName4, email=cust4@example.org, regDate=2023-03-31T15:46:30.688Z]
Customer [id=5, name=CustName5, email=cust5@example.org, regDate=2023-03-31T15:46:31.689Z]
MovieActor{movieName='movie01', actorName='actor0', actingAward='actingaward0', actingYear=2001, actingSchoolName='null'}
MovieActor{movieName='movie01', actorName='actor1', actingAward='actingaward1', actingYear=2001, actingSchoolName='actingschool1'}
MovieActor{movieName='movie01', actorName='actor2', actingAward='actingaward2', actingYear=2001, actingSchoolName='actingschool2'}
MovieActor{movieName='movie01', actorName='actor3', actingAward='actingaward3', actingYear=2001, actingSchoolName='null'}
MovieActor{movieName='movie01', actorName='actor4', actingAward='actingaward4', actingYear=2001, actingSchoolName='actingschool4'}
```
El siguiente resultado muestra los elementos devueltos y registrados después de la línea de comentarios 4.
```
Customer [id=1, name=CustName1, email=cust1@example.org, regDate=2023-03-31T15:46:27.688Z]
Customer [id=2, name=CustName2, email=cust2@example.org, regDate=2023-03-31T15:46:28.688Z]
MovieActor{movieName='movie01', actorName='actor4', actingAward='actingaward4', actingYear=2001, actingSchoolName='actingschool4'}
MovieActor{movieName='movie01', actorName='actor1', actingAward='actingaward1', actingYear=2001, actingSchoolName='actingschool1'}
```
## `ejemplo de batch WriteItem ()`
El método `batchWriteItem()` pone o borra varios elementos en una o varias tablas. Puede especificar hasta 25 operaciones individuales de colocación o borrado en la solicitud. En el siguiente ejemplo, se utilizan las clases de modelos [`ProductCatalog`](ddb-en-client-use.md#ddb-en-client-use-compare-cs3) y [`MovieActor`](ddb-en-client-use-multirecord.md#ddb-en-client-use-movieactor-class) mostradas anteriormente.
Los objetos de `WriteBatch` se crean después de las líneas de comentario 1 y 2. En la tabla `ProductCatalog`, el código coloca un elemento y elimina otro. En la tabla `MovieActor` situada después de la línea de comentarios 2, el código coloca dos elementos y elimina uno.
El método `batchWriteItem` se llama después de la línea de comentarios 3. El parámetro `[builder](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/BatchWriteItemEnhancedRequest.Builder.html)` proporciona las solicitudes de lote para cada tabla.
El objeto devuelto `[BatchWriteResult](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/BatchWriteResult.html)` proporciona métodos independientes para cada operación a fin de ver las solicitudes no procesadas. El código que sigue a la línea de comentarios 4a proporciona las claves para las solicitudes de eliminación sin procesar y el código que sigue a la línea de comentarios 4b proporciona los elementos de venta sin procesar.
```
public static void batchWriteItemExample(DynamoDbEnhancedClient enhancedClient,
DynamoDbTable catalogTable,
DynamoDbTable movieActorTable) {
// 1. Build a batch to write to the ProductCatalog table.
WriteBatch products = WriteBatch.builder(ProductCatalog.class)
.mappedTableResource(catalogTable)
.addPutItem(b -> b.item(getProductCatItem1()))
.addDeleteItem(b -> b.key(k -> k
.partitionValue(getProductCatItem2().id())
.sortValue(getProductCatItem2().title())))
.build();
// 2. Build a batch to write to the MovieActor table.
WriteBatch movies = WriteBatch.builder(MovieActor.class)
.mappedTableResource(movieActorTable)
.addPutItem(getMovieActorYeoh())
.addPutItem(getMovieActorBlanchettPartial())
.addDeleteItem(b -> b.key(k -> k
.partitionValue(getMovieActorStreep().getMovieName())
.sortValue(getMovieActorStreep().getActorName())))
.build();
// 3. Add WriteBatch objects to the request.
BatchWriteResult batchWriteResult = enhancedClient.batchWriteItem(b -> b.writeBatches(products, movies));
// 4. Retrieve keys for items the service did not process.
// 4a. 'unprocessedDeleteItemsForTable()' returns keys for delete requests that did not process.
if (batchWriteResult.unprocessedDeleteItemsForTable(movieActorTable).size() > 0) {
batchWriteResult.unprocessedDeleteItemsForTable(movieActorTable).forEach(key ->
logger.info(key.toString()));
}
// 4b. 'unprocessedPutItemsForTable()' returns keys for put requests that did not process.
if (batchWriteResult.unprocessedPutItemsForTable(catalogTable).size() > 0) {
batchWriteResult.unprocessedPutItemsForTable(catalogTable).forEach(key ->
logger.info(key.toString()));
}
}
```
Los siguientes métodos auxiliares proporcionan los objetos modelo para las operaciones de colocación y eliminación.
### Métodos auxiliares
```
1. public static ProductCatalog getProductCatItem1() {
2. return ProductCatalog.builder()
3. .id(2)
4. .isbn("1-565-85698")
5. .authors(new HashSet<>(Arrays.asList("a", "b")))
6. .price(BigDecimal.valueOf(30.22))
7. .title("Title 55")
8. .build();
9. }
10.
11. public static ProductCatalog getProductCatItem2() {
12. return ProductCatalog.builder()
13. .id(4)
14. .price(BigDecimal.valueOf(40.00))
15. .title("Title 1")
16. .build();
17. }
18.
19. public static MovieActor getMovieActorBlanchettPartial() {
20. MovieActor movieActor = new MovieActor();
21. movieActor.setActorName("Cate Blanchett");
22. movieActor.setMovieName("Blue Jasmine");
23. movieActor.setActingYear(2023);
24. movieActor.setActingAward("Best Actress");
25. return movieActor;
26. }
27.
28. public static MovieActor getMovieActorStreep() {
29. MovieActor movieActor = new MovieActor();
30. movieActor.setActorName("Meryl Streep");
31. movieActor.setMovieName("Sophie's Choice");
32. movieActor.setActingYear(1982);
33. movieActor.setActingAward("Best Actress");
34. movieActor.setActingSchoolName("Yale School of Drama");
35. return movieActor;
36. }
37.
38. public static MovieActor getMovieActorYeoh(){
39. MovieActor movieActor = new MovieActor();
40. movieActor.setActorName("Michelle Yeoh");
41. movieActor.setMovieName("Everything Everywhere All at Once");
42. movieActor.setActingYear(2023);
43. movieActor.setActingAward("Best Actress");
44. movieActor.setActingSchoolName("Royal Academy of Dance");
45. return movieActor;
46. }
```
Suponga que las tablas contienen los siguientes elementos antes de ejecutar el código de ejemplo.
```
MovieActor{movieName='Blue Jasmine', actorName='Cate Blanchett', actingAward='Best Actress', actingYear=2013, actingSchoolName='National Institute of Dramatic Art'}
MovieActor{movieName='Sophie's Choice', actorName='Meryl Streep', actingAward='Best Actress', actingYear=1982, actingSchoolName='Yale School of Drama'}
ProductCatalog{id=4, title='Title 1', isbn='orig_isbn', authors=[b, g], price=10}
```
Una vez finalizado el código de ejemplo, las tablas contienen los siguientes elementos.
```
MovieActor{movieName='Blue Jasmine', actorName='Cate Blanchett', actingAward='Best Actress', actingYear=2013, actingSchoolName='null'}
MovieActor{movieName='Everything Everywhere All at Once', actorName='Michelle Yeoh', actingAward='Best Actress', actingYear=2023, actingSchoolName='Royal Academy of Dance'}
ProductCatalog{id=2, title='Title 55', isbn='1-565-85698', authors=[a, b], price=30.22}
```
Observe en la tabla `MovieActor` que el elemento de la película `Blue Jasmine` se ha sustituido por el elemento utilizado en la solicitud de venta adquirida mediante el método auxiliar `getMovieActorBlanchettPartial()`. Si no se ha proporcionado el valor de un atributo de un objeto de datos, se elimina el valor de la base de datos. Esta es la razón por la que el `actingSchoolName` resultante es nulo para el elemento de la película `Blue Jasmine`.
**nota**
Aunque la documentación de la API sugiere que pueden utilizarse expresiones de condición y que las métricas de capacidad consumida y de recogida pueden devolverse con solicitudes individuales de [put](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/PutItemEnhancedRequest.html) y [delete](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/DeleteItemEnhancedRequest.html), esto no es así en un escenario de escritura por lotes. Para mejorar el rendimiento de las operaciones por lotes, se ignoran estas opciones individuales.