Cambios en el APIs mapeo de DynamoDB entre la versión 1 y la versión 2 del SDK for Java - AWS SDK for Java 2.x
Crear un clienteEstablecer el mapeo a la tabla/índice de DynamoDBOperaciones de tablaClases y propiedades del mapaConfiguraciónCondicionalesConversión de tipos

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 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 el transformador de atributos *

 
DynamoDBMapper mapper = new DynamoDBMapper(standardClient, 
                        attributeTransformerInstance);
 
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
    .dynamoDbClient(standardClient)
    .extensions(extensionAInstance, extensionBInstance)
    .build();

* Las extensiones de la V2 corresponden aproximadamente a los transformadores de atributos de la V1. La Use extensiones para personalizar las operaciones de DynamoDB Enhanced Client sección contiene más información sobre las extensiones de la V2.

Establecer el mapeo a la tabla/índice de DynamoDB

En la versión 1, se especifica el nombre de una tabla de DynamoDB mediante una anotación de bean. En la versión 2, un método de fábricatable(), produce una instancia DynamoDbTable que representa la tabla remota de DynamoDB. El primer parámetro del table() método es el nombre de la tabla de DynamoDB.

Caso de uso V1 V2

Asigne la clase POJO de Java a la tabla de DynamoDB

 
@DynamoDBTable(tableName ="Customer")
public class Customer {
  ...
}
 
DynamoDbTable<Customer> customerTable = enhancedClient.table("Customer",
    TableSchema.fromBean(Customer.class));

Asignación a un índice secundario de DynamoDB

  1. Defina una clase POJO que represente el índice.

    • Anote la clase @DynamoDBTable proporcionando el nombre de la tabla que contiene el índice.

    • Anote las propiedades con @DynamoDBIndexHashKey y, de forma opcional. @DynamoDBIndexRangeKey

  2. Cree una expresión de consulta.

  3. Consulta haciendo referencia a la clase POJO que representa el índice. Por ejemplo

    mapper.query(IdEmailIndex.class, queryExpression)

    donde IdEmailIndex está la clase de mapeo del índice.

La sección de la Guía para desarrolladores de DynamoDB que trata del método query V1 muestra un ejemplo completo.

  1. Anote los atributos de una clase POJO con @DynamoDbSecondaryPartitionKey (para un GSI) y @DynamoDbSecondarySortKey (para un GSI o LSI). Por ejemplo: 

    @DynamoDbSecondarySortKey(indexNames = "IdEmailIndex")
public String getEmail() { return this.email; }

  2. Recupera una referencia al índice. Por ejemplo: 

    DynamoDbIndex<Customer> customerIndex = customerTable.index("IdEmailIndex");

  3. Consulte el índice.

En la Usar índices secundarios sección de esta guía se proporciona más información.

Operaciones de tabla

Esta sección describe las operaciones APIs que difieren entre la V1 y la V2 en la mayoría de los casos de uso estándar.

En la versión 2, todas las operaciones que implican una sola tabla se invocan en la DynamoDbTable instancia, no en el cliente mejorado. El cliente mejorado contiene métodos que pueden dirigirse a varias tablas.

En la tabla denominada Operaciones de tabla que aparece a continuación, se hace referencia a una instancia de POJO como un tipo específico, por ejemplo. item customer1 En los ejemplos de la versión 2, la instancia nombrada table es el resultado de una llamada anterior enhancedClient.table() que devuelve una referencia a la DynamoDbTable instancia.

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 V1, las operaciones de tabla (a continuación) contienen algunos de los formularios más utilizados y no todos los formularios sobrecargados. Por ejemplo, el load() método 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)

La tabla de operaciones (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

Funcionamiento de DynamoDB:, PutItem UpdateItem

 
mapper.save(item)
mapper.save(item, config)
mapper.save(item, saveExpression, config)

En la versión 1, DynamoDBMapperConfig.SaveBehavior y las anotaciones determinan a qué método de DynamoDB de bajo nivel se llamará. En general, UpdateItem se llama excepto cuando se usa y. SaveBehavior.CLOBBER SaveBehavior.PUT Las claves generadas automáticamente son un caso de uso especial y, en ocasiones, UpdateItem se utilizan ambasPutItem.

 
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 en un POJO de Java

Funcionamiento 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

Funcionamiento de DynamoDB: DeleteItem

 
mapper.delete(item, deleteExpression, config)
 
table.deleteItem(deleteItemRequest)
table.deleteItem(item)
table.deleteItem(key)

Consulte una tabla o índice secundario de DynamoDB y devuelva una lista paginada

Funcionamiento de DynamoDB: Query

 
mapper.query(Customer.class, queryExpression)
mapper.query(Customer.class, queryExpression, 
                             mapperConfig)
 
table.query(queryRequest)
table.query(queryConditional)

Utilice lo devuelto PageIterable.stream() (carga diferida) para las respuestas de sincronización y PagePublisher.subscribe() para las respuestas asíncronas

Consulte una tabla o índice secundario de DynamoDB y devuelva una lista

Funcionamiento de DynamoDB: Query

 
mapper.queryPage(Customer.class, queryExpression)
mapper.queryPage(Customer.class, queryExpression, 
                                 mapperConfig)
 
table.query(queryRequest)
table.query(queryConditional)

Utilice lo devuelto PageIterable.items() (carga diferida) para las respuestas de sincronización y PagePublisher.items.subscribe() para las respuestas asíncronas

Escanea una tabla o índice secundario de DynamoDB y devuelve una lista paginada

Funcionamiento de DynamoDB: Scan

 
mapper.scan(Customer.class, scanExpression)
mapper.scan(Customer.class, scanExpression, 
                            mapperConfig)
 
table.scan()
table.scan(scanRequest)

Utilice lo devuelto PageIterable.stream() (carga diferida) para las respuestas de sincronización y PagePublisher.subscribe() para las respuestas asíncronas

Escanea una tabla o índice secundario de DynamoDB y devuelve una lista

Funcionamiento de DynamoDB: Scan

 
mapper.scanPage(Customer.class, scanExpression)
mapper.scanPage(Customer.class, scanExpression, 
                                mapperConfig)
 
table.scan()
table.scan(scanRequest)

Utilice lo devuelto PageIterable.items() (carga diferida) para las respuestas de sincronización y PagePublisher.items.subscribe() para las respuestas asíncronas

Lee varios elementos de varias tablas en un lote

Funcionamiento de DynamoDB: BatchGetItem

 
mapper.batchLoad(Arrays.asList(customer1, 
                               customer2, 
                               book1))
mapper.batchLoad(itemsToGet) 
           // itemsToGet: Map<Class<?>, List<KeyPair>>
 
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.

Escriba varios elementos en varias tablas de un lote

Funcionamiento 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 en un lote

Funcionamiento 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

Funcionamiento 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()))

Realice una escritura transaccional

Funcionamiento de DynamoDB: TransactWriteItems

 
mapper.transactionWrite(transactionWriteRequest)
 
enhancedClient.transactWriteItems(transasctWriteItemsRequest)

Realice una lectura transaccional

Funcionamiento de DynamoDB: TransactGetItems

 
mapper.transactionLoad(transactionLoadRequest)
 
enhancedClient.transactGetItems(transactGetItemsRequest)

Obtenga un recuento de los elementos coincidentes de una consulta

Funcionamiento de DynamoDB: con Query Select.COUNT

 
mapper.count(Customer.class, queryExpression)
 
// Get the count from query results.
PageIterable<Customer> pageIterable =
    customerTable.query(QueryEnhancedRequest.builder()
        .queryConditional(queryConditional)
        .select(Select.COUNT)
        .build());
Iterator<Page<Customer>> iterator = pageIterable.iterator();
Page<Customer> 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();

Obtenga un recuento de los elementos coincidentes de un escaneo

Funcionamiento de DynamoDB: con Scan Select.COUNT

 
mapper.count(Customer.class, scanExpression)
 
// Get the count from scan results.
PageIterable<Customer> pageIterable =
    customerTable.scan(ScanEnhancedRequest.builder()
        .filterExpression(filterExpression)
        .select(Select.COUNT)
        .build());
Iterator<Page<Customer>> iterator = pageIterable.iterator();
Page<Customer> 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();

Cree una tabla en DynamoDB correspondiente a la clase POJO

Funcionamiento 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 al cliente createTable 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()));

Realice un escaneo paralelo en DynamoDB

Funcionamiento Scan de DynamoDB: con parámetros y Segment TotalSegments

 
mapper.parallelScan(Customer.class, 
                    scanExpression, 
                    numTotalSegments)

Los usuarios deben gestionar los hilos de trabajo y llamar a cada scan segmento:

table.scan(r -> r.segment(0).totalSegments(5))

Integre Amazon S3 con DynamoDB para almacenar enlaces S3 inteligentes

 
mapper.createS3Link(bucket, key)
mapper.getS3ClientCache()

No es compatible porque combina Amazon S3 y DynamoDB.

Clases y propiedades del mapa

Tanto en la V1 como en la V2, las clases se asignan a las tablas mediante anotaciones tipo frijol. La versión 2 también ofrece otras formas de definir esquemas para casos de uso específicos, como trabajar con clases inmutables.

Anotaciones Bean

La siguiente tabla muestra las anotaciones de bean equivalentes para un caso de uso específico que se utilizan en las versiones V1 y V2. Se utiliza un escenario de Customer clase para ilustrar los 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
Asigne una clase a una tabla 
@DynamoDBTable (tableName ="CustomerTable")
 
@DynamoDbBean
@DynamoDbBean(converterProviders = {...})
El nombre de la tabla se define al llamar al DynamoDbEnhancedClient#table() método.
Designe un miembro de la clase como atributo de la tabla 
@DynamoDBAttribute(attributeName = "customerName")
 
@DynamoDbAttribute("customerName")
Designar a un miembro de la clase es hash/partition clave 
@DynamoDBHashKey 
@DynamoDbPartitionKey
Designar a un miembro de la clase es range/sort clave 
@DynamoDBRangeKey 
@DynamoDbSortKey
Designe a un miembro de la clase como clave de hash o partición del índice secundario 
@DynamoDBIndexHashKey 
@DynamoDbSecondaryPartitionKey
Designe a un miembro de la clase como una clave de clasificación/rango de índice secundario 
@DynamoDBIndexRangeKey 
@DynamoDbSecondarySortKey
Ignore este miembro de la clase al mapearlo a una tabla 
@DynamoDBIgnore 
@DynamoDbIgnore
Designar un miembro de la 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 generador de clientes.
Designe un miembro de la 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 generador de clientes.
Designar un miembro de la clase como atributo de versión con incremento automático 
@DynamoDBVersionAttribute
 
@DynamoDbVersionAttribute

La extensión que proporciona esto se carga automáticamente.
Designe a un miembro de la clase para que requiera una conversión personalizada 
@DynamoDBTypeConverted
 
@DynamoDbConvertedBy
Designe un miembro de la clase para almacenarlo como un tipo de atributo diferente 
@DynamoDBTyped(<DynamoDBAttributeType>)

Utilice una AttributeConverter implementación. La versión 2 proporciona muchos convertidores integrados para los tipos de Java más comunes. También puede implementar su propio AttributeConverter o personalizadoAttributeConverterProvider. Consulte Conversión de atributos de control en esta guía.
Designe una clase que se pueda serializar en un documento o subdocumento de DynamoDB (documento de estilo JSON) 
@DynamoDBDocument
 Utilice la API de documentos mejorada. Consulte los siguientes recursos:

Anotaciones adicionales en la versión 2

Caso de uso V1 V2
Designe un miembro de la clase para que no se almacene como atributo NULL si el valor de Java es nulo N/A 
@DynamoDbIgnoreNulls
Designe un miembro de la clase como objeto vacío si todos los atributos son nulos N/A 
@DynamoDbPreserveEmptyObject
Designe una acción de actualización especial para un miembro de la clase N/A 
@DynamoDbUpdateBehavior
Designe una clase inmutable N/A 
@DynamoDbImmutable
Designe un miembro de la clase como atributo de contador que se incrementa automáticamente N/A 
@DynamoDbAtomicCounter

La extensión que proporciona esta funcionalidad se carga automáticamente.

Configuración

En la versión 1, por lo general, se controlan comportamientos específicos mediante una instancia deDynamoDBMapperConfig. Puede proporcionar el objeto de configuración al crear el mapeador o al realizar una solicitud. En la versión 2, la configuración es específica del objeto de solicitud de la operación.

Caso de uso V1 Predeterminado en la V1 V2 
DynamoDBMapperConfig.builder()
Estrategia de load/write reintento por lotes 
  .withBatchLoadRetryStrategy(loadRetryStrategy)
  .withBatchWriteRetryStrategy(writeRetryStrategy)
 Reintentar los elementos fallidos Configure la estrategia de reintento en la subyacente. DynamoDBClient Consulte Configure el comportamiento de reintento en el AWS SDK for Java 2.x en esta guía.
Lecturas consistentes 
  .withConsistentReads(CONSISTENT)
 EVENTUAL De forma predeterminada, las lecturas consistentes son falsas para las operaciones de lectura. Reemplace con .consistentRead(true) en el objeto de solicitud.
Esquema de conversión con conjuntos de marshallers/unmarshallers 
  .withConversionSchema(conversionSchema)

Las implementaciones estáticas proporcionan compatibilidad con versiones anteriores.

 V2_COMPATIBLE 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 anotaciones o adivina de la clase

El nombre de la tabla se define al llamar al DynamoDbEnhancedClient#table() método.
Estrategia de carga de paginación 
  .withPaginationLoadingStrategy(strategy)

Las opciones son: LAZY_, LOADING o EAGER_LOADING ITERATION_ONLY

 LAZY_LOADING

  • La iteración solo es la opción predeterminada. No se admiten las demás opciones de la V1.

  • Puedes implementar el equivalente a una carga intensiva en la versión 2 con lo siguiente: 

    List<Customer> allItems = 
    customerTable.scan().items().stream().collect(Collectors.toList());

  • Para la carga diferida, debes implementar tu propia lógica de almacenamiento en caché para los elementos a los que accedas.
Solicita la recopilación de métricas 
  .withRequestMetricCollector(collector)
 null Úselo metricPublisher() ClientOverrideConfiguration al crear el cliente estándar de DynamoDB.
Guarde el comportamiento 
  .withSaveBehavior(SaveBehavior.CLOBBER)

Las opciones son UPDATE CLOBBERPUT,APPEND_SET, oUPDATE_SKIP_NULL_ATTRIBUTES.

 UPDATE

En la versión 2, se llama putItem() o de updateItem() forma explícita.

CLOBBER or PUT: La acción correspondiente en la versión 2 es llamarputItem(). No hay una CLOBBER configuración específica.

UPDATE: Corresponde a updateItem()

UPDATE_SKIP_NULL_ATTRIBUTES: Corresponde aupdateItem(). Controle el comportamiento de las actualizaciones con la configuración de la solicitud ignoreNulls y la anotación/etiquetaDynamoDbUpdateBehavior.

APPEND_SET: No se admite
fábrica de convertidores de tipos 
  .withTypeConverterFactory(typeConverterFactory)
convertidores de tipo estándar

Colóquelo en el frijol utilizando

@DynamoDbBean(converterProviders = {ConverterProvider.class, 
        DefaultAttributeConverterProvider.class})

Configuración previa a la operación

En la versión 1, algunas operaciones, por ejemploquery(), son altamente configurables mediante un objeto de «expresión» enviado a la operación. Por ejemplo:

DynamoDBQueryExpression<Customer> emailBwQueryExpr = new DynamoDBQueryExpression<Customer>()
    .withRangeKeyCondition("Email",
        new Condition()
            .withComparisonOperator(ComparisonOperator.BEGINS_WITH)
            .withAttributeValueList(
                new AttributeValue().withS("my")));

mapper.query(Customer.class, emailBwQueryExpr);

En la versión 2, en lugar de utilizar un objeto de configuración, se establecen los parámetros del 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 versión 2, las expresiones condicionales y de filtrado se expresan mediante un Expression objeto, que encapsula la condición y la asignación de nombres y filtros.

Caso de uso Operaciones V1 V2
Condiciones de atributo esperadas guardar (), eliminar (), consultar (), escanear () 
new DynamoDBSaveExpression()
  .withExpected(Collections.singletonMap(
      "otherAttribute", new ExpectedAttributeValue(false)))
  .withConditionalOperator(ConditionalOperator.AND);
 Obsoleto; utilícelo ConditionExpression en su lugar.
Expresión de condición eliminar () 
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 consultar (), escanear () 
scanExpression
  .withFilterExpression("#statename = :state")
  .withExpressionAttributeValues(attributeValueMapBuilder.build())
  .withExpressionAttributeNames(attributeNameMapBuilder.build())

Map<String, AttributeValue> 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 la consulta consulta () 
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 versión 2, el SDK proporciona un conjunto de convertidores predeterminados para todos los tipos habituales. Puede cambiar los convertidores de tipos tanto a nivel de proveedor general como para un único atributo. Puedes encontrar una lista de los convertidores disponibles en la referencia de la AttributeConverterAPI.

Configura un conversor personalizado para un atributo

En la versión 1, puede anotar un método de captación @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 una CurrencyFormatConverter que convierta entre un Currency tipo 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 versión 1, 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 versión 2 solo se puede aplicar la anotación al captador.

Añada un conversor de tipos, fábrica o proveedor

En la versión 1, 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 se amplía DynamoDBTypeConverterFactory y las anulaciones se realizan tomando una referencia al conjunto predeterminado y ampliándolo. En el siguiente fragmento se muestra cómo hacerlo.

DynamoDBTypeConverterFactory typeConverterFactory =
    DynamoDBTypeConverterFactory.standard().override()
        .with(String.class, CustomBoolean.class, new DynamoDBTypeConverter<String, CustomBoolean>() {
            @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 versión 2 proporciona una funcionalidad similar a través de la anotación@DynamoDbBean. Puede proporcionar un único pedido AttributeConverterProvider o una cadena de AttributeConverterProvider s. 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 poder utilizar sus convertidores de atributos. 

@DynamoDbBean(converterProviders = {
   ConverterProvider1.class, 
   ConverterProvider2.class,
   DefaultAttributeConverterProvider.class})
public class Customer {
  ...
}

La sección sobre conversión de atributos de esta guía contiene un ejemplo completo de la versión 2.