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. # Cambios en el trabajo con DynamoDB de la versión 1 a la versión 2 del AWS SDK para Java **Topics** + [Diferencias de la API de mapeo de DynamoDB entre la versión 1 y la versión 2 del AWS SDK para Java](ddb-mapping.md) + [Documente las diferencias de API entre la versión 1 y la versión 2 de AWS SDK para Java](dynamodb-mapping-document-api.md) + [Migración de la biblioteca de cifrado](ddb-encryption-lib-migrate.md) # Diferencias de la API de mapeo de DynamoDB entre la versión 1 y la versión 2 del AWS SDK para Java El APIs mapeo de DynamoDB cambió significativamente entre la versión 1 y la versión 2 de. AWS SDK para Java En la versión 1, se utiliza `DynamoDBMapper` para trabajar con Java. POJOs En la versión 2, se utiliza `DynamoDbEnhancedClient` con nombres de métodos actualizados, opciones de definición de esquemas mejoradas y seguridad de tipos mejorada. Principales diferencias: + Nuevos nombres de métodos (por ejemplo, `getItem` en lugar de `load`) + Creación de esquemas de tabla explícitos + Compatibilidad integrada con operaciones sincrónicas y asincrónicas + Cambios en la forma en que se administran las cadenas vacías y la configuración En esta sección, se describen los cambios en la API de asignación, las diferencias en las anotaciones, las actualizaciones de configuración y la guía de migración para ayudarte a realizar la transición de `DynamoDBMapper` v1 a `DynamoDbEnhancedClient` v2. **Contents** + [Cambios de alto nivel en las bibliotecas asignación de la versión 1 a la 2 del SDK para Java](dynamodb-mapping-high-level.md) + [Diferencias en dependencia de importación](dynamodb-mapping-high-level.md#dynamodb-mapping-deps) + [Cambios en el APIs mapeo de DynamoDB entre la versión 1 y la versión 2 del SDK for Java](dynamodb-mapping-api-changes.md) + [Crear un cliente](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-client) + [Establecimiento de asignación a tabla/índice de DynamoDB](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-mapping) + [Operaciones de tabla](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-tobleops) + [Asignación de clases y propiedades](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas) + [Anotaciones de bean](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas-annos) + [Anotaciones adicionales de la V2](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas-annos-v2-addnl) + [Configuración](dynamodb-mapping-api-changes.md#dynamodb-mapping-configuration) + [Configuración por operación](dynamodb-mapping-api-changes.md#dynamodb-mapping-configuration-per-op) + [Condicionales](dynamodb-mapping-api-changes.md#dynamodb-mapping-conditionals) + [Conversión de tipos](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv) + [Convertidores predeterminados](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-defaults) + [Establecimiento de un conversor personalizado para un atributo](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-anno) + [Adición de una fábrica o un proveedor de convertidores de tipos](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-factory) + [Diferencias en el tratamiento de cadenas entre la versión 1 y la 2 del SDK para Java](dynamodb-migration-string-handling.md) + [Diferencias de bloqueo positivo entre la versión 1 y la 2 del SDK para Java](dynamodb-migrate-optimstic-locking.md) + [Fluent setters: diferencias entre la versión 1 y la 2 del SDK para Java](dynamodb-migrate-fluent-setters.md) # Cambios de alto nivel en las bibliotecas asignación de la versión 1 a la 2 del SDK para Java Los nombres del cliente de asignación de cada biblioteca difieren en la V1 y en la V2: + V1: Dynamo DBMapper + V2: Cliente mejorado de DynamoDB Se interactúa con las dos bibliotecas prácticamente de la misma manera: se crea una instancia mapper/client y, a continuación, se proporciona un POJO de Java para leer y escribir estos APIs elementos en las tablas de DynamoDB. Ambas bibliotecas también ofrecen anotaciones para la clase del POJO para indicar la forma en que el cliente gestiona el POJO. Diferencias notables al pasar a V2: + V2 y V1 utilizan nombres de métodos diferentes para las operaciones de DynamoDB de bajo nivel. Por ejemplo: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-java/latest/developer-guide/dynamodb-mapping-high-level.html) + La versión 2 ofrece varias formas de definir esquemas de tablas y asignarlos a tablas. POJOs Puede elegir entre el uso de anotaciones o un esquema generado a partir de código mediante un generador. V2 también ofrece versiones mutables e inmutables de los esquemas. + Con V2, se crea específicamente el esquema de tabla como uno de los primeros pasos, mientras que en V1, el esquema de tabla se deduce de la clase anotada según sea necesario. + V2 incluye el [Cliente de la API de documento](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html) en la API de cliente mejorada, mientras que V1 usa una [API aparte](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/DynamoDB.html). + Todas APIs están disponibles en versiones síncronas y asíncronas en la versión 2. Consulte la [sección de asignación de DynamoDB](dynamodb-enhanced-client.md) de esta guía para obtener información más detallada sobre el cliente mejorado de V2. ## Diferencias en dependencia de importación | V1 | V2 | | --- | --- | | 

  
    
      com.amazonaws
      aws-java-sdk-bom
      1.X.X
      pom
      import
    
  
 


  
    com.amazonaws
    aws-java-sdk-dynamodb
| 

  
    
      software.amazon.awssdk
      bom
      2.X.X*
      pom
      import
    
  
 


  
    software.amazon.awssdk
    dynamodb-enhanced
| \$1 [Última versión](https://central.sonatype.com/artifact/software.amazon.awssdk/bom). En la versión 1, una sola dependencia incluye tanto la API de DynamoDB de bajo nivel como mapping/document la API, mientras que en la versión 2, se utiliza `dynamodb-enhanced` la dependencia de artefactos para acceder a la API. mapping/document El módulo `dynamodb-enhanced` contiene una dependencia transitiva del módulo `dynamodb` de bajo nivel. # Cambios en el APIs mapeo de DynamoDB entre la versión 1 y la versión 2 del SDK for Java ## Crear un cliente **** | Caso de uso | V1 | V2 | | --- | --- | --- | | Instanciación normal | 
AmazonDynamoDB standardClient = AmazonDynamoDBClientBuilder.standard()
    .withCredentials(credentialsProvider)
    .withRegion(Regions.US_EAST_1)
    .build();
DynamoDBMapper mapper = new DynamoDBMapper(standardClient);
| 
DynamoDbClient standardClient = DynamoDbClient.builder()
    .credentialsProvider(ProfileCredentialsProvider.create())
    .region(Region.US_EAST_1)
    .build();
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
    .dynamoDbClient(standardClient)
    .build();
| | Instanciación mínima | 
AmazonDynamoDB standardClient = AmazonDynamoDBClientBuilder.standard();
DynamoDBMapper mapper = new DynamoDBMapper(standardClient);
| 
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.create();
| | Con transformador de atributos\$1 | 
DynamoDBMapper mapper = new DynamoDBMapper(standardClient, 
                        attributeTransformerInstance);
| 
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
    .dynamoDbClient(standardClient)
    .extensions(extensionAInstance, extensionBInstance)
    .build();
| \$1Las extensiones de V2 corresponden aproximadamente a los transformadores de atributos de V1. La sección [Uso de extensiones para personalizar operaciones de DynamoDB Enhanced Client](ddb-en-client-extensions.md) contiene más información sobre extensiones de V2. ## Establecimiento de asignación a tabla/índice de DynamoDB En V1, se especifica un nombre de tabla de DynamoDB mediante una anotación de bean. En V2, un método de fábrica, `table()`, produce una instancia de `DynamoDbTable` que representa la tabla remota de DynamoDB. El primer parámetro del método `table()` es el nombre de tabla de DynamoDB. **** | Caso de uso | V1 | V2 | | --- | --- | --- | | Asignar la clase POJO de Java a la tabla de DynamoDB | 
@DynamoDBTable(tableName ="Customer")
public class Customer {
  ...
}
| 
DynamoDbTable customerTable = enhancedClient.table("Customer",
    TableSchema.fromBean(Customer.class));
| | Asignar a un índice secundario de DynamoDB | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) En la sección de la Guía para desarrolladores de DynamoDB que analiza [el método de `query` V1](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html#DynamoDBMapper.Methods.query) se muestra un ejemplo completo. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) En la sección [Usar índices secundarios](ddb-en-client-use-secindex.md) de esta guía se proporciona más información. | ## Operaciones de tabla En esta sección se describen las operaciones APIs que difieren entre la V1 y la V2 en la mayoría de los casos de uso estándar. En la V2, todas las operaciones que implican una sola tabla se llaman en la instancia de `DynamoDbTable`, no en el cliente mejorado. El cliente mejorado contiene métodos que pueden referirse a varias tablas. En la tabla denominada *Operaciones de tabla* que aparece a continuación, se hace referencia a una instancia de POJO como `item` o como tipo específico, por ejemplo `customer1`. En los ejemplos de la V2, la instancia llamada `table` es resultado de una llamada anterior a `enhancedClient.table()` que devuelve una referencia a la instancia `DynamoDbTable`. Tenga en cuenta que la mayoría de las operaciones de la V2 se pueden llamar con un patrón de consumo fluido, incluso cuando no se muestran. Por ejemplo: ``` Customer customer = table.getItem(r → r.key(key)); or Customer customer = table.getItem(r → r.key(k -> k.partitionValue("id").sortValue("email"))) ``` Para las operaciones de la V1, *Operaciones de tabla* (a continuación) contiene algunos de los formularios más utilizados y no todos los formularios sobrecargados. Por ejemplo, el método `load()` presenta las siguientes sobrecargas: ``` mapper.load(Customer.class, hashKey) mapper.load(Customer.class, hashKey, rangeKey) mapper.load(Customer.class, hashKey, config) mapper.load(Customer.class, hashKey, rangeKey, config) mapper.load(item) mapper.load(item, config) ``` *Operaciones de tabla* (a continuación) muestra los formularios más utilizados: ``` mapper.load(item) mapper.load(item, config) ``` **Operaciones de tabla** | Caso de uso | V1 | V2 | | --- | --- | --- | | Escribir un POJO de Java en una tabla de DynamoDB **Operación de DynamoDB**: `PutItem`, `UpdateItem` | 
mapper.save(item)
mapper.save(item, config)
mapper.save(item, saveExpression, config)
En la V1, `DynamoDBMapperConfig.SaveBehavior` y las anotaciones determinan a qué método de DynamoDB de bajo nivel se llamará. En general, se llama a `UpdateItem` excepto cuando se usa `SaveBehavior.CLOBBER` y `SaveBehavior.PUT`. Las claves generadas automáticamente son un caso de uso especial y, en ocasiones, se utilizan `PutItem` y `UpdateItem`. | 
table.putItem(putItemRequest)
table.putItem(item)
table.putItemWithResponse(item) //Returns metadata.

updateItem(updateItemRequest)
table.updateItem(item)
table.updateItemWithResponse(item) //Returns metadata.
| | Leer un elemento de una tabla de DynamoDB a un POJO de Java **Operación de DynamoDB:** `GetItem` | 
mapper.load(item)
mapper.load(item, config)
| 
table.getItem(getItemRequest)
table.getItem(item)
table.getItem(key)
table.getItemWithResponse(key) //Returns POJO with metadata.
| | Eliminar un elemento de una tabla de DynamoDB **Operación de DynamoDB:** `DeleteItem` | 
mapper.delete(item, deleteExpression, config)
| 
table.deleteItem(deleteItemRequest)
table.deleteItem(item)
table.deleteItem(key)
| | Consultar una tabla o un índice secundario de DynamoDB y devolución de una lista paginada **Operación de DynamoDB:** `Query` | 
mapper.query(Customer.class, queryExpression)
mapper.query(Customer.class, queryExpression, 
                             mapperConfig)
| 
table.query(queryRequest)
table.query(queryConditional)
Usar el `PageIterable.stream()` devuelto (carga diferida) para respuestas sincrónicas y `PagePublisher.subscribe()` para respuestas asincrónicas | | Consultar una tabla o un índice secundario de DynamoDB y devolver una lista **Operación de DynamoDB:** `Query` | 
mapper.queryPage(Customer.class, queryExpression)
mapper.queryPage(Customer.class, queryExpression, 
                                 mapperConfig)
| 
table.query(queryRequest)
table.query(queryConditional)
Usar el `PageIterable.items()` devuelto (carga diferida) para respuestas sincrónicas y `PagePublisher.items.subscribe()` para respuestas asincrónicas | | Analizar una tabla o un índice secundario de DynamoDB y devolver una lista paginada **Operación de DynamoDB:** `Scan` | 
mapper.scan(Customer.class, scanExpression)
mapper.scan(Customer.class, scanExpression, 
                            mapperConfig)
| 
table.scan()
table.scan(scanRequest)
Usar el `PageIterable.stream()` devuelto (carga diferida) para respuestas sincrónicas y `PagePublisher.subscribe()` para respuestas asincrónicas | | Analizar una tabla o un índice secundario de DynamoDB y devolver una lista **Operación de DynamoDB:** `Scan` | 
mapper.scanPage(Customer.class, scanExpression)
mapper.scanPage(Customer.class, scanExpression, 
                                mapperConfig)
| 
table.scan()
table.scan(scanRequest)
Usar el `PageIterable.items()` devuelto (carga diferida) para respuestas sincrónicas y `PagePublisher.items.subscribe()` para respuestas asincrónicas | | Leer varios elementos de varias tablas de un lote **Operación de DynamoDB:** `BatchGetItem` | 
mapper.batchLoad(Arrays.asList(customer1, 
                               customer2, 
                               book1))
mapper.batchLoad(itemsToGet) 
           // itemsToGet: Map, List>
| 
enhancedClient.batchGetItem(batchGetItemRequest)

enhancedClient.batchGetItem(r -> r.readBatches(
    ReadBatch.builder(Record1.class)
             .mappedTableResource(mappedTable1)
             .addGetItem(i -> i.key(k -> k.partitionValue(0)))
             .build(),
    ReadBatch.builder(Record2.class)
             .mappedTableResource(mappedTable2)
             .addGetItem(i -> i.key(k -> k.partitionValue(0)))
             .build()))

// Iterate over pages with lazy loading or over all items 
   from the same table.
| | Escribir varios elementos en varias tablas de un lote **Operación de DynamoDB:** `BatchWriteItem` | 
mapper.batchSave(Arrays.asList(customer1, 
                               customer2, 
                               book1))
| 
enhancedClient.batchWriteItem(batchWriteItemRequest)

enhancedClient.batchWriteItem(r -> r.writeBatches(
    WriteBatch.builder(Record1.class)
             .mappedTableResource(mappedTable1)
             .addPutItem(item1)
             .build(),
    WriteBatch.builder(Record2.class)
             .mappedTableResource(mappedTable2)
             .addPutItem(item2)
             .build()))
| | Eliminar varios elementos de varias tablas de un lote **Operación de DynamoDB:** `BatchWriteItem` | 
mapper.batchDelete(Arrays.asList(customer1, 
                                 customer2, 
                                 book1))
| 
enhancedClient.batchWriteItem(r -> r.writeBatches(
    WriteBatch.builder(Record1.class)
             .mappedTableResource(mappedTable1)
             .addDeleteItem(item1key)
             .build(),
    WriteBatch.builder(Record2.class)
             .mappedTableResource(mappedTable2)
             .addDeleteItem(item2key)
             .build()))
| | Escribir/eliminar varios elementos de un lote **Operación de DynamoDB:** `BatchWriteItem` | 
mapper.batchWrite(Arrays.asList(customer1, book1), 
                  Arrays.asList(customer2))
| 
enhancedClient.batchWriteItem(r -> r.writeBatches(
    WriteBatch.builder(Record1.class)
             .mappedTableResource(mappedTable1)
             .addPutItem(item1)
             .build(),
    WriteBatch.builder(Record2.class)
             .mappedTableResource(mappedTable2)
             .addDeleteItem(item2key)
             .build()))
| | Realizar una escritura transaccional **Operación de DynamoDB:** `TransactWriteItems` | 
mapper.transactionWrite(transactionWriteRequest)
| 
enhancedClient.transactWriteItems(transasctWriteItemsRequest)
| | Realizar una lectura transaccional **Operación de DynamoDB:** `TransactGetItems` | 
mapper.transactionLoad(transactionLoadRequest)
| 
enhancedClient.transactGetItems(transactGetItemsRequest)
| | Obtener un recuento de elementos coincidentes de una consulta **Operación de DynamoDB:** `Query` con `Select.COUNT` | 
mapper.count(Customer.class, queryExpression)
| 
// Get the count from query results.
PageIterable pageIterable =
    customerTable.query(QueryEnhancedRequest.builder()
        .queryConditional(queryConditional)
        .select(Select.COUNT)
        .build());
Iterator> iterator = pageIterable.iterator();
Page page = iterator.next();
int count = page.count();

// For a more concise approach, you can chain the method calls:
int count = customerTable.query(QueryEnhancedRequest.builder()
                .queryConditional(queryConditional)
                .select(Select.COUNT)
                .build())
            .iterator().next().count();
| | Obtener un recuento de elementos coincidentes de un análisis **Operación de DynamoDB:** `Scan` con `Select.COUNT` | 
mapper.count(Customer.class, scanExpression)
| 
// Get the count from scan results.
PageIterable pageIterable =
    customerTable.scan(ScanEnhancedRequest.builder()
        .filterExpression(filterExpression)
        .select(Select.COUNT)
        .build());
Iterator> iterator = pageIterable.iterator();
Page page = iterator.next();
int count = page.count();

// For a more concise approach, you can chain the method calls:
int count = customerTable.scan(ScanEnhancedRequest.builder()
                .filterExpression(filterExpression)
                .select(Select.COUNT)
                .build())
            .iterator().next().count();
| | Crear una tabla en DynamoDB correspondiente a la clase POJO **Operación de DynamoDB:** `CreateTable` | 
mapper.generateCreateTableRequest(Customer.class)
La instrucción anterior genera una solicitud de creación de tabla de bajo nivel; los usuarios deben llamar a `createTable` en el cliente de DynamoDB. | 
table.createTable(createTableRequest)

table.createTable(r -> r.provisionedThroughput(defaultThroughput())
    .globalSecondaryIndices(
        EnhancedGlobalSecondaryIndex.builder()
            .indexName("gsi_1")
            .projection(p -> p.projectionType(ProjectionType.ALL))
            .provisionedThroughput(defaultThroughput())
            .build()));
| | Realizar un análisis paralelo en DynamoDB **Operación de DynamoDB**: `Scan` con parámetros`Segment` y `TotalSegments` | 
mapper.parallelScan(Customer.class, 
                    scanExpression, 
                    numTotalSegments)
| Los usuarios deben administrar los subprocesos de trabajo y llamar a `scan` para cada segmento: 
table.scan(r -> r.segment(0).totalSegments(5))
| | Integración de Amazon S3 con DynamoDB para almacenar enlaces de S3 inteligentes | 
mapper.createS3Link(bucket, key)
mapper.getS3ClientCache()
| No se admite porque acopla Amazon S3 y DynamoDB. | ## Asignación de clases y propiedades Tanto en la V1 como en la V2, las clases se asignan a tablas mediante anotaciones de tipo bean. La V2 también ofrece [otras formas de definir esquemas](ddb-en-client-adv-features.md#ddb-en-client-adv-features-schm-overview) para casos de uso específicos, como trabajar con clases inmutables. ### Anotaciones de bean La siguiente tabla muestra las anotaciones de bean equivalentes para un caso de uso específico que se utilizan en V1 y V2. Se utiliza un escenario de clase de `Customer` para ilustrar parámetros. Las anotaciones, así como las clases y las enumeraciones, de la versión 2 siguen la convención camel case y utilizan '', no 'DynamoDB'. DynamoDb | Caso de uso | V1 | V2 | | --- | --- | --- | | Asignar clase a tabla | 
@DynamoDBTable (tableName ="CustomerTable")
| 
@DynamoDbBean
@DynamoDbBean(converterProviders = {...})
El nombre de la tabla se define al llamar al método DynamoDbEnhancedClient\$1table(). | | Designar un miembro de clase como atributo de tabla | 
@DynamoDBAttribute(attributeName = "customerName")
| 
@DynamoDbAttribute("customerName")
| | Designar a un hash/partition miembro de la clase es clave | 
@DynamoDBHashKey
| 
@DynamoDbPartitionKey
| | Designar a un miembro de la clase es range/sort clave | 
@DynamoDBRangeKey
| 
@DynamoDbSortKey
| | Designar un miembro de clase como clave de hash/partición de índice secundario | 
@DynamoDBIndexHashKey
| 
@DynamoDbSecondaryPartitionKey
| | Designar un miembro de clase como clave de rango/clasificación de índice secundario | 
@DynamoDBIndexRangeKey
| 
@DynamoDbSecondarySortKey
| | Ignorar este miembro de clase al asignarlo a una tabla | 
@DynamoDBIgnore
| 
@DynamoDbIgnore
| | Designar un miembro de clase como atributo clave UUID generado automáticamente | 
@DynamoDBAutoGeneratedKey
| 
@DynamoDbAutoGeneratedUuid
La extensión que lo proporciona no se carga de forma predeterminada; debe agregarla al compilador de clientes. | | Designar un miembro de clase como atributo de marca de tiempo generado automáticamente | 
@DynamoDBAutoGeneratedTimestamp
| 
@DynamoDbAutoGeneratedTimestampAttribute
La extensión que lo proporciona no se carga de forma predeterminada; debe agregarla al compilador de clientes. | | Designar un miembro de clase como atributo de versión con incremento automático | 
@DynamoDBVersionAttribute
| 
@DynamoDbVersionAttribute
La extensión que proporciona esto se carga automáticamente. | | Designar que un miembro de clase requiere una conversión personalizada | 
@DynamoDBTypeConverted
| 
@DynamoDbConvertedBy
| | Designar que un miembro de clase se almacene como otro tipo de atributo | 
@DynamoDBTyped()
| Utilice una implementación de `AttributeConverter`. V2 proporciona muchos convertidores integrados para tipos de Java comunes. También puede implementar su propio `AttributeConverter` o `AttributeConverterProvider` personalizado. Consulte [Conversión de atributos de control](ddb-en-client-adv-features-conversion.md) en esta guía. | | Designe una clase que se pueda serializar en un documento (documento de estilo JSON) o subdocumento de DynamoDB | 
@DynamoDBDocument
| Uso de la API de Documento mejorado Consulte los siguientes recursos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) | ### Anotaciones adicionales de la V2 | Caso de uso | V1 | V2 | | --- | --- | --- | | Designar que un miembro de clase no se almacene como atributo NULL si el valor de Java es nulo | N/A | 
@DynamoDbIgnoreNulls
| | Designar un miembro de clase como objeto vacío si todos los atributos son nulos | N/A | 
@DynamoDbPreserveEmptyObject
| | Designar una acción de actualización especial para un miembro de clase | N/A | 
@DynamoDbUpdateBehavior
| | Designar una clase inmutable | N/A | 
@DynamoDbImmutable
| | Designar un miembro de clase como atributo de contador de incremento automático | N/A | 
@DynamoDbAtomicCounter
La extensión que proporciona esto se carga automáticamente. | ## Configuración En la V1, generalmente se controlan comportamientos específicos mediante una instancia de `DynamoDBMapperConfig`. Puede proporcionar el objeto de configuración al crear el asignador o al realizar una solicitud. En la V2, la configuración es específica del objeto de solicitud de la operación. | Caso de uso | V1 | Predeterminado en V1 | V2 | | --- | --- | --- | --- | | | 
DynamoDBMapperConfig.builder()
| | | | Estrategia de load/write reintento por lotes | 
  .withBatchLoadRetryStrategy(loadRetryStrategy)
  .withBatchWriteRetryStrategy(writeRetryStrategy)
| reintento de elementos fallidos | Configure la estrategia de reintento en el DynamoDBClient subyacente. Consulte [Configure el comportamiento de reintento en el AWS SDK for Java 2.x](retry-strategy.md) en esta guía. | | Lecturas consistentes | 
  .withConsistentReads(CONSISTENT)
| EVENTUAL | De forma predeterminada, las lecturas consistentes son falsas para operaciones de lectura. Anule con .consistentRead(true) en el objeto de solicitud. | | Esquema de conversión con conjuntos de serializadores/deserializadores | 
  .withConversionSchema(conversionSchema)
Las implementaciones estáticas proporcionan compatibilidad con versiones anteriores. | V2\$1COMPATIBLE | No se usa. Se trata de una función antigua que hace referencia a la forma en que las primeras versiones de DynamoDB (V1) almacenaban los tipos de datos, y este comportamiento no se conservará en el cliente mejorado. Un ejemplo de comportamiento en DynamoDB V1 es almacenar los valores booleanos como número en lugar de como booleanos. | | Nombres de tablas | 
  .withObjectTableNameResolver()
  .withTableNameOverride() 
  .withTableNameResolver()
Las implementaciones estáticas proporcionan compatibilidad con versiones anteriores | usa anotación o estimación a partir de la clase | El nombre de la tabla se define al llamar al método `DynamoDbEnhancedClient#table()`. | | Estrategia de carga de paginación | 
  .withPaginationLoadingStrategy(strategy)
Las opciones son: LAZY\$1, `LOADING`, `EAGER_LOADING` o `ITERATION_ONLY` | LAZY\$1LOADING | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) | | Solicitud de recopilación de métricas | 
  .withRequestMetricCollector(collector)
| null | Use metricPublisher() en ClientOverrideConfiguration al crear el cliente estándar de DynamoDB. | | Comportamiento de guardado | 
  .withSaveBehavior(SaveBehavior.CLOBBER)
Las opciones son `UPDATE`, `CLOBBER`, `PUT`, `APPEND_SET` o `UPDATE_SKIP_NULL_ATTRIBUTES`. | UPDATE | En la V2, se llama a `putItem()` o `updateItem()` de forma explícita. `CLOBBER or PUT`: la acción correspondiente en la v2 es llamar a `putItem()`. No hay una configuración específica de `CLOBBER`. `UPDATE`: Corresponde a `updateItem()` `UPDATE_SKIP_NULL_ATTRIBUTES`: Corresponde a`updateItem()`. Controle el comportamiento de actualización con la configuración de solicitud `ignoreNulls` y la anotación/etiqueta `DynamoDbUpdateBehavior`. `APPEND_SET`: no se admite | | Fábrica de convertidores de tipos | 
  .withTypeConverterFactory(typeConverterFactory)
| convertidores de tipos estándar | Establezca el bean utilizando 
@DynamoDbBean(converterProviders = {ConverterProvider.class, 
        DefaultAttributeConverterProvider.class})
| ### Configuración por operación En la V1, algunas operaciones, por ejemplo, `query()`, son altamente configurables mediante un objeto de “expresión” enviado a la operación. Por ejemplo: ``` DynamoDBQueryExpression emailBwQueryExpr = new DynamoDBQueryExpression() .withRangeKeyCondition("Email", new Condition() .withComparisonOperator(ComparisonOperator.BEGINS_WITH) .withAttributeValueList( new AttributeValue().withS("my"))); mapper.query(Customer.class, emailBwQueryExpr); ``` En la V2, en lugar de utilizar un objeto de configuración, se establecen parámetros en el objeto de solicitud mediante un generador. Por ejemplo: ``` QueryEnhancedRequest emailBw = QueryEnhancedRequest.builder() .queryConditional(QueryConditional .sortBeginsWith(kb -> kb .sortValue("my"))).build(); customerTable.query(emailBw); ``` ## Condicionales En la V2, las expresiones condicionales y de filtrado se expresan mediante un objeto `Expression`, que encapsula la condición y la asignación de nombres y filtros. | Caso de uso | Operaciones | V1 | V2 | | --- | --- | --- | --- | | Condiciones de atributo esperadas | save(), delete(), query(), scan() | 
new DynamoDBSaveExpression()
  .withExpected(Collections.singletonMap(
      "otherAttribute", new ExpectedAttributeValue(false)))
  .withConditionalOperator(ConditionalOperator.AND);
| Obsoleto; utilice ConditionExpression en su lugar. | | Expresión de condición | delete() | 
deleteExpression.setConditionExpression("zipcode = :zipcode")
deleteExpression.setExpressionAttributeValues(...)
| 
Expression conditionExpression =
    Expression.builder()
        .expression("#key = :value OR #key1 = :value1")
        .putExpressionName("#key", "attribute")
        .putExpressionName("#key1", "attribute3")
        .putExpressionValue(":value", AttributeValues.stringValue("wrong"))
        .putExpressionValue(":value1", AttributeValues.stringValue("three"))
        .build();

DeleteItemEnhancedRequest request = DeleteItemEnhancedRequest.builder()
         .conditionExpression(conditionExpression).build();
| | Expresión de filtro | query(), scan() | 
scanExpression
  .withFilterExpression("#statename = :state")
  .withExpressionAttributeValues(attributeValueMapBuilder.build())
  .withExpressionAttributeNames(attributeNameMapBuilder.build())
| 
Map values = singletonMap(":key", stringValue("value"));
Expression filterExpression =
    Expression.builder()
        .expression("name = :key")
        .expressionValues(values)
        .build();
QueryEnhancedRequest request = QueryEnhancedRequest.builder()
    .filterExpression(filterExpression).build();
| | Expresión de condición para consulta | query() | 
queryExpression.withKeyConditionExpression()
| 
QueryConditional keyEqual = QueryConditional.keyEqualTo(b -> b
                .partitionValue("movie01"));

QueryEnhancedRequest tableQuery = QueryEnhancedRequest.builder()
                .queryConditional(keyEqual)
                .build();
| ## Conversión de tipos ### Convertidores predeterminados En la V2, el SDK proporciona un conjunto de convertidores predeterminados para todos los tipos comunes. Puede cambiar los convertidores de tipos tanto en el nivel de proveedor general como para un único atributo. Puedes encontrar una lista de los convertidores disponibles en la referencia de la [AttributeConverter](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverter.html)API. ### Establecimiento de un conversor personalizado para un atributo En la V1, puede anotar un método getter con `@DynamoDBTypeConverted` para especificar la clase que convierte entre el tipo de atributo de Java y un tipo de atributo de DynamoDB. Por ejemplo, se puede aplicar un `CurrencyFormatConverter` que convierta entre un tipo `Currency` de Java y una cadena de DynamoDB, como se muestra en el siguiente fragmento de código. ``` @DynamoDBTypeConverted(converter = CurrencyFormatConverter.class) public Currency getCurrency() { return currency; } ``` A continuación se muestra el equivalente en V2 del fragmento anterior. ``` @DynamoDbConvertedBy(CurrencyFormatConverter.class) public Currency getCurrency() { return currency; } ``` **nota** En la V1 puede aplicar la anotación al atributo en sí, a un tipo o a una anotación definida por el usuario, mientras que en la V2 solo se puede aplicar la anotación al getter. ### Adición de una fábrica o un proveedor de convertidores de tipos En la V1 puede proporcionar su propio conjunto de convertidores de tipos o anular los tipos que le interesen añadiendo una fábrica de convertidores de tipos a la configuración. La fábrica de convertidores de tipos amplía `DynamoDBTypeConverterFactory` y las anulaciones se realizan tomando una referencia al conjunto predeterminado y ampliándola. En el siguiente fragmento de código se muestra cómo hacerlo. ``` DynamoDBTypeConverterFactory typeConverterFactory = DynamoDBTypeConverterFactory.standard().override() .with(String.class, CustomBoolean.class, new DynamoDBTypeConverter() { @Override public String convert(CustomBoolean bool) { return String.valueOf(bool.getValue()); } @Override public CustomBoolean unconvert(String string) { return new CustomBoolean(Boolean.valueOf(string)); }}).build(); DynamoDBMapperConfig config = DynamoDBMapperConfig.builder() .withTypeConverterFactory(typeConverterFactory) .build(); DynamoDBMapper mapperWithTypeConverterFactory = new DynamoDBMapper(dynamo, config); ``` La V2 proporciona una funcionalidad similar a través de la anotación `@DynamoDbBean`. Puede proporcionar un `AttributeConverterProvider` único o una cadena de `AttributeConverterProvider` en orden. Tenga en cuenta que si suministra su propia cadena de proveedores de convertidores de atributos, anulará el proveedor de convertidores predeterminado y deberá incluirlo en la cadena para utilizar sus convertidores de atributos. ``` @DynamoDbBean(converterProviders = { ConverterProvider1.class, ConverterProvider2.class, DefaultAttributeConverterProvider.class}) public class Customer { ... } ``` La sección sobre [conversión de atributos](ddb-en-client-adv-features-conversion.md#ddb-en-client-adv-features-conversion-example) de esta guía contiene un ejemplo completo para la V2. # Diferencias en el tratamiento de cadenas entre la versión 1 y la 2 del SDK para Java La V1 y la V2 tratan las cadenas vacías de forma diferente al enviar datos a DynamoDB: + **V1**: convierte las cadenas vacías en valores nulos antes de enviarlas a DynamoDB (lo que no produce ningún atributo) + **V2**: envía cadenas vacías como valores reales de cadenas vacías a DynamoDB **importante** Tras migrar a la V2, si no desea almacenar cadenas vacías en DynamoDB, debe implementar convertidores personalizados. Sin convertidores personalizados, la V2 almacena cadenas vacías como atributos de cadenas vacías reales en los elementos de DynamoDB, lo que difiere del comportamiento de la V1, que omite estos atributos por completo. **Example conversor personalizado para la V2 que convierte un atributo de cadena vacía en nulo** ``` /** * Custom converter that maintains V1 behavior by converting empty strings to null values * when writing to DynamoDB, ensuring compatibility with existing data. No attribute will be saved to DynamoDB. */ public class NullifyEmptyStringConverter implements AttributeConverter { @Override public AttributeValue transformFrom(String value) { if (value == null || value.isEmpty()) { return AttributeValue.builder().nul(true).build(); } return AttributeValue.builder().s(value).build(); } @Override public String transformTo(AttributeValue attributeValue) { if (attributeValue.nul()) { return null; } return attributeValue.s(); } @Override public EnhancedType type() { return EnhancedType.of(String.class); } @Override public AttributeValueType attributeValueType() { return AttributeValueType.S; } } // V2 usage: @DynamoDbBean public class Customer { private String name; @DynamoDbConvertedBy(NullifyEmptyStringConverter.class) public String getName() { return name; } } ``` # Diferencias de bloqueo positivo entre la versión 1 y la 2 del SDK para Java Tanto la V1 como la V2 implementan bloqueo positivo con una anotación de atributo que marca una propiedad en la clase bean para almacenar el número de versión. **Diferencias en el comportamiento de bloqueo positivo** | | V1 | V2 | | --- | --- | --- | | Anotación de clase bean | @DynamoDBVersionAttribute | @DynamoDbVersionAttribute (tenga en cuenta que la V2 usa una “b” minúscula) | | Guardado inicial | Atributo de número de versión establecido en 1. | Valor inicial del atributo de versión establecido en `@DynamoDbVersionAttribute(startAt = X)`. El valor predeterminado es 0. | | Actualización | El atributo de número de versión se incrementa en 1 si la comprobación condicional verifica que el número de versión del objeto que se está actualizando coincide con el número de la base de datos. | El atributo de número de versión se incrementa si la comprobación condicional verifica que el número de versión del objeto que se está actualizando coincide con el número de la base de datos. El atributo de número de versión se incrementa mediante la opción `incrementBy` establecida en `@DynamoDbVersionAttribute(incrementBy = X)`. El valor predeterminado es 1. | | Eliminar | DynamoDBMapper añade una comprobación condicional de que el número de versión del objeto que se está eliminando coincide con el número de versión de la base de datos. | La V2 no añade automáticamente condiciones para las operaciones de eliminación. Debe añadir expresiones de condición manualmente si desea controlar el comportamiento de eliminación. En el siguiente ejemplo, `recordVersion` es el atributo de versión del bean. 
// 1. Read the item and get its current version.
Customer item = customerTable.getItem(Key.builder().partitionValue("someId").build());
AttributeValue currentVersion = item.getRecordVersion();

// 2. Create conditional delete with the `currentVersion` value.
DeleteItemEnhancedRequest deleteItemRequest =
    DeleteItemEnhancedRequest.builder()
       .key(KEY)
       .conditionExpression(Expression.builder()
           .expression("recordVersion = :current_version_value")
           .putExpressionValue(":current_version_value", currentVersion)
           .build()).build();

customerTable.deleteItem(deleteItemRequest);
| | Escritura transaccional con comprobación de condición | No se puede utilizar una clase de bean que esté anotada con @DynamoDBVersionAttribute en un método addConditionCheck. | Puede utilizar una clase de bean con la anotación @DynamoDbVersionAttribute en un método de compilador addConditionCheck para una solicitud transactWriteItems. | | Deshabilitado | Para deshabilitar el bloqueo positivo, cambie el valor de enumeración DynamoDBMapperConfig.SaveBehavior de UPDATE a CLOBBER. | No utilice la anotación `@DynamoDbVersionAttribute`. | # Fluent setters: diferencias entre la versión 1 y la 2 del SDK para Java Se puede usar POJOs con configuradores fluidos en la API de mapeo de DynamoDB para la versión 1 y con la V2 desde la versión 2.30.29. Por ejemplo, el siguiente POJO devuelve una instancia `Customer` del método `setName`: ``` // V1 @DynamoDBTable(tableName ="Customer") public class Customer{ private String name; // Other attributes and methods not shown. public Customer setName(String name){ this.name = name; return this; } } ``` Sin embargo, si utiliza una versión de V2 anterior a la 2.30.29, `setName` devuelve una instancia `Customer` con un valor `name` de `null`. ``` // V2 prior to version 2.30.29. @DynamoDbBean public class Customer{ private String name; // Other attributes and methods not shown. public Customer setName(String name){ this.name = name; return this; // Bug: returns this instance with a `name` value of `null`. } } ``` ``` // Available in V2 since version 2.30.29. @DynamoDbBean public class Customer{ private String name; // Other attributes and methods not shown. public Customer setName(String name){ this.name = name; return this; // Returns this instance for method chaining with the `name` value set. } } ``` # Documente las diferencias de API entre la versión 1 y la versión 2 de AWS SDK para Java La API de documentos permite trabajar con documentos de estilo JSON como elementos individuales en una tabla de DynamoDB. La API de documentos de la V1 tiene una API correspondiente en la V2, pero en lugar de utilizar un cliente independiente para la API de documentos como en la V1, la V2 incorpora características de la API de documentos en el cliente mejorado de DynamoDB. En la V1, la clase [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Item.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Item.html) representa un registro no estructurado de una tabla de DynamoDB. En la V2, un registro no estructurado se representa mediante una instancia de la clase [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html). Tenga en cuenta que las claves principales se definen en el esquema de tabla en la V2 y en el propio elemento en la V1. En la siguiente tabla se comparan las diferencias entre el documento APIs en la V1 y la V2. | Caso de uso | V1 | V2 | | --- |--- |--- | | Cree un cliente de documentos | 
AmazonDynamoDB client = ... //Create a client.
DynamoDB documentClient = new DynamoDB(client);
| 
// The V2 Document API uses the same DynamoDbEnhancedClient
// that is used for mapping POJOs.
DynamoDbClient standardClient = ... //Create a standard client.
DynamoDbEnhancedClient enhancedClient = ... // Create an enhanced client.
| | Haga referencia a una tabla | 
Table documentTable = docClient.documentClient("Person");
| 
DynamoDbTable documentTable = enhancedClient.table("Person",  
        TableSchema.documentSchemaBuilder()
              .addIndexPartitionKey(TableMetadata.primaryIndexName(),"id", AttributeValueType.S)
              .attributeConverterProviders(AttributeConverterProvider.defaultProvider())
              .build());
| | **Work with semi-structured data** | | --- | | Poner elemento | 
Item item = new Item()
      .withPrimaryKey("id", 50)
      .withString("firstName", "Shirley");
PutItemOutcome outcome = documentTable.putItem(item);
| 
EnhancedDocument personDocument = EnhancedDocument.builder()
        .putNumber("id", 50)
        .putString("firstName", "Shirley")
        .build();
documentTable.putItem(personDocument);
| | Obtener elemento | 
GetItemOutcome outcome = documentTable.getItemOutcome( "id", 50);
Item personDocFromDb = outcome.getItem();
String firstName = personDocFromDb.getString("firstName");
| 
EnhancedDocument personDocFromDb = documentTable
        .getItem(Key.builder()
            .partitionValue(50)
            .build()); 
String firstName = personDocFromDb.getString("firstName");
| | **Work with JSON items** | | --- | | Convierte una estructura JSON para usarla con la API de documentos | 
// The 'jsonPerson' identifier is a JSON string. 
Item item = new Item().fromJSON(jsonPerson);
| 
// The 'jsonPerson' identifier is a JSON string.
EnhancedDocument document = EnhancedDocument.builder()
        .json(jsonPerson).build());
| | Pon JSON | 
documentTable.putItem(item)
| 
documentTable.putItem(document);
| | Lee JSON | 
GetItemOutcome outcome = //Get item.
String jsonPerson = outcome.getItem().toJSON();
| 
String jsonPerson = documentTable.getItem(Key.builder()
        .partitionValue(50).build())
        .fromJson();
| ## Referencia de API y guías para el documento APIs | | V1 | V2 | | --- | --- | --- | | Referencia de la API | [Referencia de la API](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/package-summary.html) | [Referencia de la API](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/package-summary.html) | | Guía de documentación | [Guía para desarrolladores de Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/JavaDocumentAPIItemCRUD.html) | [API de documentos mejorada](ddb-en-client-doc-api.md) (esta guía) | # De la API Xpec de la V1 a la API Expresiones de la V2 La API de especificación de expresiones (Xspec) disponible en la V1, que ayuda a crear expresiones para trabajar con datos orientados a documentos, no está disponible en la V2. La versión 2 usa la API Expression, que funciona tanto con datos orientados a documentos como con datos object-to-item mapeados. **** | | V1 | V2 | | --- | --- | --- | | Nombre de API | API de especificación de expresiones (Xspec) | API de expresiones | | Funciona con | Métodos de la clase [Tabla](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Table.html) de la API Documentos, como [updateItem](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Table.html#updateItem-java.lang.String-java.lang.Object-com.amazonaws.services.dynamodbv2.xspec.UpdateItemExpressionSpec-) y [scan](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/Table.html#scan-com.amazonaws.services.dynamodbv2.xspec.ScanExpressionSpec-) | Ambos APIs de DynamoDB Enhanced Client: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-java/latest/developer-guide/ddb-v1-xspec-migrate.html) Para ambos tipos de APIs, después de haber adquirido una [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbTable.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/DynamoDbTable.html)instancia: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-java/latest/developer-guide/ddb-v1-xspec-migrate.html) utilice expresiones en métodos `DynamoDbTable` cuando cree objetos de solicitud. Por ejemplo, en el método `filterExpression` del [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/QueryEnhancedRequest.Builder.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/model/QueryEnhancedRequest.Builder.html) | | Recursos | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sdk-for-java/latest/developer-guide/ddb-v1-xspec-migrate.html) | [Información sobre expresiones](ddb-en-client-expressions.md) en esta Guía para desarrolladores de Java | # Migración de la biblioteca de cifrado Para obtener información sobre la migración de la biblioteca de cifrado para que DynamoDB funcione con la versión 2 del SDK de Java, consulte la [Guía para desarrolladores de Cliente de encriptación de Amazon DynamoDB](https://docs.aws.amazon.com/database-encryption-sdk/latest/devguide/ddb-java-migrate.html).