Cambios en el APIs mapeo o el documento de DynamoDB de la versión 1 a la versión 2

En este tema se detallan los cambios en el nivel superior SDK de Java APIs para Amazon DynamoDB desde la versión 1.x (v1) a AWS SDK for Java 2.x la (v2). En primer lugar, abordaremos el object-to-table mapeo API y, a continuación, analizaremos el documento API para trabajar con JSON documentos de estilo.

Cambios de alto nivel

Los nombres del cliente de mapeo de cada biblioteca difieren en la versión 1 y en la versión 2:

• v1 - D ynamoDBMapper

• v2: cliente mejorado de DynamoDB

Se interactúa con las dos bibliotecas prácticamente de la misma manera: se crea una instancia de un mapeador/cliente y, a continuación, se proporciona un código Java POJO para leer y escribir estos elementos en APIs las tablas de DynamoDB. Ambas bibliotecas también ofrecen anotaciones para la clase de para indicar la forma en que el cliente gestiona laPOJO. POJO

Las diferencias notables al pasar a la versión 2 incluyen:

• V2 y v1 utilizan nombres de métodos diferentes para las operaciones de bajo nivel de DynamoDB. Por ejemplo:

  v1	v2
  carga	getItem
  save	putItem
  batchLoad	batchGetItem

• La versión 2 ofrece varias formas de definir esquemas de tablas y mapearlos en tablas. POJOs Puede elegir entre el uso de anotaciones o un esquema generado a partir del código mediante un generador. V2 también ofrece versiones mutables e inmutables de los esquemas.

• En la versión 2, se crea específicamente el esquema de la tabla como uno de los primeros pasos, mientras que en la versión 1, el esquema de la tabla se deduce de la clase anotada según sea necesario.

• La versión 2 incluye el APIcliente Document en el cliente mejoradoAPI, mientras que la versión 1 utiliza un cliente independiente. API

• Todos APIs están disponibles en versiones síncronas y asíncronas en la versión 2.

Consulte la sección de mapeo de DynamoDB en esta guía para obtener información más detallada sobre el cliente mejorado de la versión 2.

Importación de dependencias

v1	v2
<dependencyManagement> <dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-bom</artifactId> <version>1.X.X</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-dynamodb</artifactId> </dependency> </dependencies>	<dependencyManagement> <dependencies> <dependency> <groupId>software.amazon.awssdk</groupId> <artifactId>bom</artifactId> <version>2.X.X*</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <dependencies> <dependency> <groupId>software.amazon.awssdk</groupId> <artifactId>dynamodb-enhanced</artifactId> </dependency> </dependencies>

^* Última versión.

En la versión 1, una sola dependencia incluye tanto el API DynamoDB de bajo nivel como la asignación API o el documento, mientras que en la versión 2, se usa dynamodb-enhanced la dependencia del artefacto para acceder a la asignación o el documento. API El dynamodb-enhanced módulo contiene una dependencia transitiva del módulo de bajo nivel. dynamodb

APIcambios

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 versión 2 corresponden aproximadamente a los transformadores de atributos de la versión 1. La Usar extensiones sección contiene más información sobre las extensiones de la versión 2.

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 POJO clase 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	Defina una POJO clase 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 Cree una expresión de consulta. Consulta haciendo referencia a la POJO clase que representa el índice. Por ejemplo mapper.query(IdEmailIndex.class, queryExpression) donde IdEmailIndex está la clase de mapeo del índice. En la sección de la Guía para desarrolladores de DynamoDB en la que se analiza el método query v1 se muestra un ejemplo completo.	Anote los atributos de una POJO clase con @DynamoDbSecondaryPartitionKey (para a GSI) y @DynamoDbSecondarySortKey (para y GSI o). LSI Por ejemplo: @DynamoDbSecondarySortKey(indexNames = "IdEmailIndex") public String getEmail() { return this.email; } Recupera una referencia al índice. Por ejemplo: DynamoDbIndex<Customer> customerIndex = customerTable.index("IdEmailIndex"); Consulte el índice. La Usar índices secundarios sección de esta guía proporciona más información.

Operaciones de tabla

En esta sección se describen las operaciones APIs que difieren entre la versión 1 y la versión 2 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 POJO instancia como item o como un tipo específico, por ejemplocustomer1. 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 versión 2 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 versión 1, la tabla contiene 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)

En la tabla se muestran los formularios más utilizados:

mapper.load(item)
mapper.load(item, config)

Operaciones de tabla

Caso de uso	v1	Funcionamiento de DynamoDB	v2
Escribir un archivo Java en una POJO tabla de DynamoDB	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.	PutItem, 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 una tabla Java POJO	mapper.load(item) mapper.load(item, config)	GetItem	table.getItem(getItemRequest) table.getItem(item) table.getItem(key) table.getItemWithResponse(key) //Returns POJO with metadata.
Eliminar un elemento de una tabla de DynamoDB	mapper.delete(item, deleteExpression, config)	DeleteItem	table.deleteItem(deleteItemRequest) table.deleteItem(item) table.deleteItem(key)
Consulte una tabla o índice secundario de DynamoDB y devuelva una lista paginada	mapper.query(Customer.class, queryExpression) mapper.query(Customer.class, queryExpression, mapperConfig)	Query	table.query(queryRequest) table.query(queryConditional) Utilice lo devuelto PageIterable.stream() (carga diferida) para las respuestas sincronizadas y PagePublisher.subscribe() asíncronas
Consulte una tabla o índice secundario de DynamoDB y devuelva una lista	mapper.queryPage(Customer.class, queryExpression) mapper.queryPage(Customer.class, queryExpression, mapperConfig)	Query	table.query(queryRequest) table.query(queryConditional) Utilice lo devuelto PageIterable.items() (carga diferida) para las respuestas sincronizadas y PagePublisher.items.subscribe() asíncronas
Escanea una tabla o índice secundario de DynamoDB y devuelve una lista paginada	mapper.scan(Customer.class, scanExpression) mapper.scan(Customer.class, scanExpression, mapperConfig)	Scan	table.scan() table.scan(scanRequest) Utilice lo devuelto PageIterable.stream() (carga diferida) para las respuestas sincronizadas y PagePublisher.subscribe() asíncronas
Escanea una tabla o índice secundario de DynamoDB y devuelve una lista	mapper.scanPage(Customer.class, scanExpression) mapper.scanPage(Customer.class, scanExpression, mapperConfig)	Scan	table.scan() table.scan(scanRequest) Utilice lo devuelto PageIterable.items() (carga diferida) para las respuestas sincronizadas y PagePublisher.items.subscribe() asíncronas
Lee varios elementos de varias tablas en un lote	mapper.batchLoad(Arrays.asList(customer1, customer2, book1)) mapper.batchLoad(itemsToGet) // itemsToGet: Map<Class<?>, List<KeyPair>>	BatchGetItem	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.
Escribe varios elementos en varias tablas de un lote	mapper.batchSave(Arrays.asList(customer1, customer2, book1))	BatchWriteItem	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()))
Elimine varios elementos de varias tablas en un lote	mapper.batchDelete(Arrays.asList(customer1, customer2, book1))	BatchWriteItem	enhancedClient.batchWriteItem(r -> r.writeBatches( WriteBatch.builder(Record1.class) .mappedTableResource(mappedTable1) .addDeleteItem(item1key) .build(), WriteBatch.builder(Record2.class) .mappedTableResource(mappedTable2) .addDeleteItem(item2key) .build()))
Escribe o elimina varios elementos de un lote	mapper.batchWrite(Arrays.asList(customer1, book1), Arrays.asList(customer2))	BatchWriteItem	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	mapper.transactionWrite(transactionWriteRequest)	TransactWriteItems	enhancedClient.transactWriteItems(transasctWriteItemsRequest)
Realice una lectura transaccional	mapper.transactionLoad(transactionLoadRequest)	TransactGetItems	enhancedClient.transactGetItems(transactGetItemsRequest)
Obtenga el recuento de los elementos coincidentes de un escaneo o consulta	mapper.count(Customer.class, queryExpression) mapper.count(Customer.class, scanExpression)	Query, Scan con Select.COUNT	No compatible
Cree una tabla en DynamoDB correspondiente a la clase POJO	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.	CreateTable	table.createTable(createTableRequest) table.createTable(r -> r.provisionedThroughput(getDefaultProvisionedThroughput()) .globalSecondaryIndices( EnhancedGlobalSecondaryIndex.builder() .indexName("gsi_1") .projection(p -> p.projectionType(ProjectionType.ALL)) .provisionedThroughput(getDefaultProvisionedThroughput()) .build()));
Realice un escaneo paralelo en DynamoDB	mapper.parallelScan(Customer.class, scanExpression, numTotalSegments)	Scancon y parámetros Segment TotalSegments	Los usuarios deben gestionar los hilos de trabajo y llamar scan a cada 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 versión 1 como en la 2, 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 bean equivalentes para un caso de uso específico que se utilizan en las versiones 1 y 2. 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 DynamoDbEDnhancedClient#table() método.
Designe un miembro de la clase como atributo de la tabla	@DynamoDBAttribute(attributeName = "customerName")	@DynamoDbAttribute("customerName")
Designe un miembro de la clase como clave de hash o partición	@DynamoDBHashKey	@DynamoDbPartitionKey
Designar un miembro de la clase es una clave de rango/clasificación	@DynamoDBHashKey	@DynamoDbSortKey
Designe que un miembro de la clase es una clave de partición o hash de índice secundaria	@DynamoDBIndexHashKey	@DynamoDbSecondaryPartitionKey
Designe 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 UUID clave 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>)	Sin equivalente
Designe una clase que se pueda serializar en un documento o subdocumento de DynamoDB JSON (estilo documento)	@DynamoDBDocument	Sin anotación equivalente directa. Utilice el documento API mejorado.

V2: anotaciones adicionales

Caso de uso	v1	v2
Designe un miembro de la clase para que no se almacene como NULL atributo 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 versión 1	v2
	DynamoDBMapperConfig.builder()
Estrategia de reintento de carga por lotes	.withBatchLoadRetryStrategy(batchLoadRetryStrategy)	Reintentar los elementos fallidos
Estrategia de reintento de escritura por lotes	.withBatchWriteRetryStrategy(batchWriteRetryStrategy)	Reintentar los elementos fallidos
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 DynamoDbEDnhancedClient#table() método.
Estrategia de carga de paginación	.withPaginationLoadingStrategy(strategy) Las opciones son: LAZY _ LOADINGEAGER_LOADING, o ITERATION_ONLY	LAZY_LOADING	La iteración solo es la opción predeterminada. No se admiten las demás opciones de la versión 1.
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, SDK proporciona un conjunto de convertidores predeterminados para todos los tipos comunes. Puede cambiar los convertidores de tipos tanto a nivel de proveedor general como para un único atributo. Puede encontrar una lista de los convertidores disponibles en la AttributeConverterAPIreferencia.

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 versión 2 del fragmento anterior.

@DynamoDbConvertedBy(CurrencyFormatConverter.class)
public Currency getCurrency() { return currency; }

nota

En la versión 1, se puede aplicar la anotación al atributo en sí, a un tipo o a una anotación definida por el usuario. La versión 2 permite aplicar la anotación solo 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.

Historial de documentos API

El documento API permite trabajar con documentos de JSON estilo como elementos individuales en una tabla de DynamoDB. El documento v1 API tiene una correspondiente API en la versión 2, pero en lugar de utilizar un cliente independiente para el documento API como en la versión 1, la versión 2 incorpora API funciones del documento en el cliente mejorado de DynamoDB.

En la versión 1, la Itemclase representa un registro no estructurado de una tabla de DynamoDB. En la versión 2, un registro no estructurado se representa mediante una instancia de la clase. EnhancedDocument Tenga en cuenta que las claves principales se definen en el esquema de la tabla para la versión 2 y en el propio elemento en la versión 1.

En la siguiente tabla se comparan las diferencias entre el documento APIs en la versión 1 y la versión 2.

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<EnhancedDocument> 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 JSON estructura para utilizarla con el documento API	// 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);
Leer JSON	GetItemOutcome outcome = //Get item. String jsonPerson = outcome.getItem().toJSON();	String jsonPerson = documentTable.getItem(Key.builder() .partitionValue(50).build()) .fromJson();

APIreferencia y guías para el documento APIs

	v1	v2
APIreferencia	Javadoc	Javadoc
Guía de documentación	Guía para desarrolladores de Amazon DynamoDB	Documento mejorado API (esta guía)

FAQ

P: ¿El bloqueo optimista con un número de versión funciona de la misma manera en la versión 2 que en la versión 1?

R. El comportamiento es similar, pero la versión 2 no añade automáticamente condiciones para las operaciones de eliminación. Debe añadir las expresiones de condición manualmente si quiere controlar el comportamiento de eliminación.