Modifiche nella APIs mappatura/documento di DynamoDB dalla versione 1 alla versione 2

Questo argomento descrive in dettaglio le modifiche apportate alla versione SDK di alto livello di Java APIs per Amazon DynamoDB dalla versione 1.x (v1) alla (v2). AWS SDK for Java 2.x Per prima cosa trattiamo la object-to-table mappatura API e poi discutiamo del documento per lavorare con i documenti in stile. API JSON

Modifiche di alto livello

I nomi del client di mappatura in ogni libreria differiscono in v1 e v2:

• v1 - D ynamoDBMapper

• v2 - Client avanzato per DynamoDB

Interagisci con le due librerie più o meno allo stesso modo: crei un'istanza di un mapper/client e poi fornisci un Java POJO a APIs cui leggere e scrivere questi elementi nelle tabelle DynamoDB. Entrambe le librerie offrono anche annotazioni per la classe di per indicare il modo in cui il client gestisce lePOJO. POJO

Le differenze notevoli quando si passa alla v2 includono:

• V2 e v1 utilizzano nomi di metodi diversi per le operazioni DynamoDB di basso livello. Per esempio:

  v1	v2
  caricare	getItem
  save	putItem
  batchLoad	batchGetItem

• La V2 offre diversi modi per definire gli schemi delle tabelle e mapparli alle tabelle. POJOs Puoi scegliere tra l'uso di annotazioni o uno schema generato dal codice utilizzando un builder. V2 offre anche versioni mutabili e immutabili degli schemi.

• Con v2, si crea specificamente lo schema della tabella come uno dei primi passaggi, mentre nella v1, lo schema della tabella viene dedotto dalla classe annotata secondo necessità.

• La V2 include il APIclient Document nel client avanzatoAPI, mentre la v1 utilizza un client separato. API

• Tutti APIs sono disponibili nelle versioni sincrone e asincrone nella v2.

Consulta la sezione sulla mappatura di DynamoDB in questa guida per informazioni più dettagliate sul client avanzato v2.

Importa le dipendenze

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>

^* Ultima versione.

Nella v1, una singola dipendenza include sia il DynamoDB API di basso livello che la API mappatura/documento, mentre nella v2, si utilizza la dipendenza degli artefatti per accedere alla mappatura/documento. dynamodb-enhanced API Il modulo contiene una dipendenza transitiva dal modulo di dynamodb basso livello. dynamodb-enhanced

APImodifiche

Crea un cliente

Caso d'uso	v1	v2
Istanziazione normale	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();
Istanziazione minima	AmazonDynamoDB standardClient = AmazonDynamoDBClientBuilder.standard(); DynamoDBMapper mapper = new DynamoDBMapper(standardClient);	DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.create();
Con trasformatore di attributi *	DynamoDBMapper mapper = new DynamoDBMapper(standardClient, attributeTransformerInstance);	DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder() .dynamoDbClient(standardClient) .extensions(extensionAInstance, extensionBInstance) .build();

^* Le estensioni in v2 corrispondono all'incirca ai trasformatori di attributi in v1. La Usa le estensioni sezione contiene ulteriori informazioni sulle estensioni in v2.

Stabilire la mappatura alla tabella/indice DynamoDB

Nella v1, si specifica il nome di una tabella DynamoDB tramite un'annotazione bean. Nella v2, un metodo factorytable(), produce un'istanza DynamoDbTable che rappresenta la tabella DynamoDB remota. Il primo parametro del table() metodo è il nome della tabella DynamoDB.

Caso d'uso	v1	v2
Mappa la POJO classe Java sulla tabella DynamoDB	@DynamoDBTable(tableName ="Customer") public class Customer { ... }	DynamoDbTable<Customer> customerTable = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
Mappare su un indice secondario DynamoDB	Definire una POJO classe che rappresenta l'indice. Annota la classe @DynamoDBTable fornendo il nome della tabella che contiene l'indice. Annota le proprietà con @DynamoDBIndexHashKey e facoltativamente. @DynamoDBIndexRangeKey Crea un'espressione di interrogazione. Interrogazione utilizzando il riferimento alla POJO classe che rappresenta l'indice. Ad esempio mapper.query(IdEmailIndex.class, queryExpression) dove IdEmailIndex è la classe di mappatura per l'indice. La sezione della DynamoDB Developer Guide che illustra il metodo query v1 mostra un esempio completo.	Annota gli attributi di una POJO classe con @DynamoDbSecondaryPartitionKey (for a GSI) e @DynamoDbSecondarySortKey (for and or). GSI LSI Ad esempio, @DynamoDbSecondarySortKey(indexNames = "IdEmailIndex") public String getEmail() { return this.email; } Recupera un riferimento all'indice. Ad esempio, DynamoDbIndex<Customer> customerIndex = customerTable.index("IdEmailIndex"); Interroga l'indice. La Usa indici secondari sezione di questa guida fornisce ulteriori informazioni.

Operazioni sulle tabelle

Questa sezione descrive le operazioni APIs che differiscono tra v1 e v2 per la maggior parte dei casi d'uso standard.

Nella v2, tutte le operazioni che coinvolgono una singola tabella vengono chiamate sull'DynamoDbTableistanza, non sul client avanzato. Il client avanzato contiene metodi che possono indirizzare più tabelle.

Nella tabella denominata Table operations riportata di seguito, un'POJOistanza viene definita come item o come un tipo specifico, ad esempiocustomer1. Per gli esempi della versione v2, le istanze denominate table sono il risultato di una chiamata precedente enhancedClient.table() che restituisce un riferimento all'DynamoDbTableistanza.

Tieni presente che la maggior parte delle operazioni v2 può essere richiamata con uno schema di consumo fluido anche se non vengono visualizzate. Ad esempio,

Customer customer = table.getItem(r → r.key(key));
  or
Customer customer = table.getItem(r → r.key(k -> k.partitionValue("id").sortValue("email"))) 

Per le operazioni v1, la tabella contiene alcuni dei moduli più utilizzati e non tutti i moduli sovraccaricati. Ad esempio, il load() metodo presenta i seguenti sovraccarichi:

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 tabella mostra i moduli più comunemente usati:

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

Operazioni sulle tabelle
Caso d'uso	v1	Funzionamento DynamoDB	v2
Scrivere un file Java POJO in una tabella DynamoDB	mapper.save(item) mapper.save(item, config) mapper.save(item, saveExpression, config) Nella v1, DynamoDBMapperConfig.SaveBehavior and annotations determina quale metodo DynamoDB di basso livello verrà chiamato. In generale, UpdateItem viene chiamato tranne quando si usa and. SaveBehavior.CLOBBER SaveBehavior.PUT Le chiavi generate automaticamente sono un caso d'uso speciale e occasionalmente UpdateItem vengono utilizzate entrambePutItem.	PutItem, UpdateItem	table.putItem(putItemRequest) table.putItem(item) table.putItemWithResponse(item) //Returns metadata. updateItem(updateItemRequest) table.updateItem(item) table.updateItemWithResponse(item) //Returns metadata.
Leggere un elemento da una tabella DynamoDB a un 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.
Eliminare un elemento da una tabella DynamoDB	mapper.delete(item, deleteExpression, config)	DeleteItem	table.deleteItem(deleteItemRequest) table.deleteItem(item) table.deleteItem(key)
Interroga una tabella o un indice secondario DynamoDB e restituisci un elenco impaginato	mapper.query(Customer.class, queryExpression) mapper.query(Customer.class, queryExpression, mapperConfig)	Query	table.query(queryRequest) table.query(queryConditional) Utilizza il valore restituito PageIterable.stream() (lazy loading) per le risposte di sincronizzazione e per le risposte asincrone PagePublisher.subscribe()
Interroga una tabella o un indice secondario DynamoDB e restituisci un elenco	mapper.queryPage(Customer.class, queryExpression) mapper.queryPage(Customer.class, queryExpression, mapperConfig)	Query	table.query(queryRequest) table.query(queryConditional) Utilizza il valore restituito PageIterable.items() (lazy loading) per le risposte di sincronizzazione e PagePublisher.items.subscribe() per le risposte asincrone
Scansiona una tabella o un indice secondario DynamoDB e restituisci un elenco impaginato	mapper.scan(Customer.class, scanExpression) mapper.scan(Customer.class, scanExpression, mapperConfig)	Scan	table.scan() table.scan(scanRequest) Utilizza il valore restituito PageIterable.stream() (lazy loading) per le risposte di sincronizzazione e per le risposte asincrone PagePublisher.subscribe()
Scansiona una tabella o un indice secondario DynamoDB e restituisci un elenco	mapper.scanPage(Customer.class, scanExpression) mapper.scanPage(Customer.class, scanExpression, mapperConfig)	Scan	table.scan() table.scan(scanRequest) Utilizza il valore restituito PageIterable.items() (lazy loading) per le risposte di sincronizzazione e PagePublisher.items.subscribe() per le risposte asincrone
Leggi più elementi da più tabelle in un batch	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.
Scrivi più elementi su più tabelle in un batch	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()))
Elimina più elementi da più tabelle in un batch	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()))
Scrittura/elimina più elementi in un batch	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()))
Esegui una scrittura transazionale	mapper.transactionWrite(transactionWriteRequest)	TransactWriteItems	enhancedClient.transactWriteItems(transasctWriteItemsRequest)
Effettuare una lettura transazionale	mapper.transactionLoad(transactionLoadRequest)	TransactGetItems	enhancedClient.transactGetItems(transactGetItemsRequest)
Ottieni il numero di elementi corrispondenti di una scansione o di una query	mapper.count(Customer.class, queryExpression) mapper.count(Customer.class, scanExpression)	Query, Scan con Select.COUNT	Non supportato
Crea una tabella in DynamoDB corrispondente alla classe POJO	mapper.generateCreateTableRequest(Customer.class) L'istruzione precedente genera una richiesta di creazione della tabella di basso livello; gli utenti devono chiamare createTable il client 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()));
Esegui una scansione parallela in DynamoDB	mapper.parallelScan(Customer.class, scanExpression, numTotalSegments)	Scancon e parametri Segment TotalSegments	Gli utenti devono gestire i thread di lavoro e chiamare scan per ogni segmento: table.scan(r -> r.segment(0).totalSegments(5))
Integra Amazon S3 con DynamoDB per archiviare collegamenti S3 intelligenti	mapper.createS3Link(bucket, key) mapper.getS3ClientCache()	-	Non è supportato perché abbina Amazon S3 e DynamoDB.

Classi e proprietà della mappa

Sia in v1 che in v2, si mappano le classi alle tabelle utilizzando annotazioni in stile bean. V2 offre anche altri modi per definire schemi per casi d'uso specifici, come lavorare con classi immutabili.

Annotazioni Bean

La tabella seguente mostra le annotazioni bean equivalenti per un caso d'uso specifico utilizzate in v1 e v2. Uno scenario Customer di classe viene utilizzato per illustrare i parametri.

Le annotazioni, così come le classi e le enumerazioni, nella v2 seguono la convenzione camel case e usano '', non 'DynamoDB'. DynamoDb

Caso d'uso	v1	v2
Mappa la classe sulla tabella	@DynamoDBTable (tableName ="CustomerTable")	@DynamoDbBean @DynamoDbBean(converterProviders = {...}) Il nome della tabella viene definito quando si chiama il DynamoDbEDnhancedClient#table() metodo.
Designate un membro della classe come attributo della tabella	@DynamoDBAttribute(attributeName = "customerName")	@DynamoDbAttribute("customerName")
Designare un membro della classe come chiave hash/di partizione	@DynamoDBHashKey	@DynamoDbPartitionKey
Designare un membro della classe è una chiave di intervallo/ordinamento	@DynamoDBHashKey	@DynamoDbSortKey
Designare un membro della classe come chiave di hash/partizione dell'indice secondaria	@DynamoDBIndexHashKey	@DynamoDbSecondaryPartitionKey
Designare un membro della classe come chiave di ordinamento/intervallo di indice secondaria	@DynamoDBIndexRangeKey	@DynamoDbSecondarySortKey
Ignora questo membro della classe durante la mappatura su una tabella	@DynamoDBIgnore	@DynamoDbIgnore
Designare un membro della classe come attributo chiave generato automaticamente UUID	@DynamoDBAutoGeneratedKey	@DynamoDbAutoGeneratedUuid L'estensione che lo fornisce non viene caricata per impostazione predefinita; è necessario aggiungere l'estensione a client builder.
Designare un membro della classe come attributo timestamp generato automaticamente	@DynamoDBAutoGeneratedTimestamp	@DynamoDbAutoGeneratedTimestampAttribute L'estensione che lo fornisce non viene caricata per impostazione predefinita; è necessario aggiungere l'estensione a client builder.
Designare un membro della classe come attributo di versione con incremento automatico	@DynamoDBVersionAttribute	@DynamoDbVersionAttribute L'estensione che lo fornisce viene caricata automaticamente.
Designate un membro della classe come richiedente una conversione personalizzata	@DynamoDBTypeConverted	@DynamoDbConvertedBy
Designate un membro della classe da memorizzare come tipo di attributo diverso	@DynamoDBTyped(<DynamoDBAttributeType>)	Nessun equivalente
Designare una classe che può essere serializzata in un documento DynamoDB (documento in stile -style) o in un documento secondario JSON	@DynamoDBDocument	Nessuna annotazione equivalente diretta. Usa il documento API avanzato.

Annotazioni aggiuntive V2

Caso d'uso	v1	v2
Designate un membro della classe da non memorizzare come NULL attributo se il valore Java è nullo	N/D	@DynamoDbIgnoreNulls
Designate un membro della classe come oggetto vuoto se tutti gli attributi sono nulli	N/D	@DynamoDbPreserveEmptyObject
Designate un'azione speciale di aggiornamento per un membro della classe	N/D	@DynamoDbUpdateBehavior
Designate una classe immutabile	N/D	@DynamoDbImmutable
Designare un membro della classe come attributo del contatore ad incremento automatico	N/D	@DynamoDbAtomicCounter L'estensione che fornisce questa funzionalità viene caricata automaticamente.

Configurazione

Nella v1, in genere si controllano comportamenti specifici utilizzando un'istanza di. DynamoDBMapperConfig È possibile fornire l'oggetto di configurazione quando si crea il mapper o quando si effettua una richiesta. Nella v2, la configurazione è specifica dell'oggetto di richiesta per l'operazione.

Caso d'uso	v1	Impostazione predefinita in v1	v2
	DynamoDBMapperConfig.builder()
Strategia di nuovi tentativi di caricamento in batch	.withBatchLoadRetryStrategy(batchLoadRetryStrategy)	riprova gli elementi non riusciti
Strategia di ripetizione dei tentativi di scrittura in batch	.withBatchWriteRetryStrategy(batchWriteRetryStrategy)	riprova gli elementi non riusciti
Letture coerenti	.withConsistentReads(CONSISTENT)	EVENTUAL	Per impostazione predefinita, le letture coerenti sono false per le operazioni di lettura. Sostituisci con .consistentRead(true) sull'oggetto della richiesta.
Schema di conversione con set di marshallers/unmarshallers	.withConversionSchema(conversionSchema) Le implementazioni statiche forniscono la retrocompatibilità con le versioni precedenti.	V2_COMPATIBLE	Non applicabile. Si tratta di una funzionalità legacy che si riferisce al modo in cui le versioni precedenti di DynamoDB (v1) memorizzavano i tipi di dati e questo comportamento non verrà mantenuto nel client avanzato. Un esempio di comportamento in DynamoDB v1 è l'archiviazione dei valori booleani come numero anziché come booleano.
Nomi delle tabelle	.withObjectTableNameResolver() .withTableNameOverride() .withTableNameResolver() Le implementazioni statiche forniscono la retrocompatibilità con le versioni precedenti	usa annotation o guess from class	Il nome della tabella viene definito quando si chiama il DynamoDbEDnhancedClient#table() metodo.
Strategia di caricamento della paginazione	.withPaginationLoadingStrategy(strategy) Le opzioni sono: LAZY _ LOADINGEAGER_LOADING, o ITERATION_ONLY	LAZY_LOADING	L'impostazione predefinita è solo l'iterazione. Le altre opzioni v1 non sono supportate.
Richiedi la raccolta delle metriche	.withRequestMetricCollector(collector)	null	Da utilizzare metricPublisher() ClientOverrideConfiguration durante la creazione del client DynamoDB standard.
Salva il comportamento	.withSaveBehavior(SaveBehavior.CLOBBER) Le opzioni sono UPDATECLOBBER,PUT,APPEND_SET, oUPDATE_SKIP_NULL_ATTRIBUTES.	UPDATE	Nella v2, si chiama putItem() or in updateItem() modo esplicito. CLOBBER or PUT: L'azione corrispondente nella v 2 è la chiamata. putItem() Non esiste una CLOBBER configurazione specifica. UPDATE: Corrisponde a updateItem() UPDATE_SKIP_NULL_ATTRIBUTES: Corrisponde aupdateItem(). Controlla il comportamento di aggiornamento con l'impostazione della richiesta ignoreNulls e l'annotazione/tagDynamoDbUpdateBehavior. APPEND_SET: non supportato
Tipo: fabbrica di convertitori	.withTypeConverterFactory(typeConverterFactory)	convertitori di tipo standard	Impostare sul fagiolo utilizzando @DynamoDbBean(converterProviders = {ConverterProvider.class, DefaultAttributeConverterProvider.class})

Configurazione per operazione

Nella v1, alcune operazioni, ad esempioquery(), sono altamente configurabili tramite un oggetto «espressione» inviato all'operazione. Per esempio:

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

mapper.query(Customer.class, emailBwQueryExpr);

Nella v2, invece di utilizzare un oggetto di configurazione, si impostano i parametri sull'oggetto di richiesta utilizzando un builder. Per esempio:

QueryEnhancedRequest emailBw = QueryEnhancedRequest.builder()
    .queryConditional(QueryConditional
        .sortBeginsWith(kb -> kb
            .sortValue("my"))).build();

customerTable.query(emailBw);

Condizionali

Nella v2, le espressioni condizionali e di filtraggio vengono espresse utilizzando un Expression oggetto, che incapsula la condizione e la mappatura di nomi e filtri.

Caso d'uso	Operazioni	v1	v2
Condizioni previste per gli attributi	save (), delete (), query (), scan ()	new DynamoDBSaveExpression() .withExpected(Collections.singletonMap( "otherAttribute", new ExpectedAttributeValue(false))) .withConditionalOperator(ConditionalOperator.AND);	Obsoleto; da usare al suo posto. ConditionExpression
Espressione della condizione	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();
Espressione filtro	interrogazione (), scansione ()	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();
Espressione di condizione per la query	interrogazione ()	queryExpression.withKeyConditionExpression()	QueryConditional keyEqual = QueryConditional.keyEqualTo(b -> b .partitionValue("movie01")); QueryEnhancedRequest tableQuery = QueryEnhancedRequest.builder() .queryConditional(keyEqual) .build();

Conversione del tipo

Convertitori predefiniti

Nella v2, SDK fornisce un set di convertitori predefiniti per tutti i tipi comuni. È possibile modificare i convertitori di tipo sia a livello generale del provider che per un singolo attributo. Puoi trovare un elenco dei convertitori disponibili nel AttributeConverterAPIriferimento.

Imposta un convertitore personalizzato per un attributo

Nella v1, è possibile annotare un metodo getter con @DynamoDBTypeConverted per specificare la classe che esegue la conversione tra il tipo di attributo Java e un tipo di attributo DynamoDB. Ad esempio, è possibile applicare una stringa CurrencyFormatConverter che converte tra un Currency tipo Java e una stringa DynamoDB come mostrato nel seguente frammento.

@DynamoDBTypeConverted(converter = CurrencyFormatConverter.class)
public Currency getCurrency() { return currency; }

L'equivalente v2 dello snippet precedente è mostrato di seguito.

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

Nota

In v1, puoi applicare l'annotazione all'attributo stesso, a un tipo o a un'annotazione definita dall'utente, v2 supporta l'applicazione dell'annotazione solo al getter.

Aggiungi una fabbrica o un fornitore di convertitori di tipi

Nella v1, puoi fornire il tuo set di convertitori di tipo o sostituire i tipi che ti interessano aggiungendo una fabbrica di convertitori di tipi alla configurazione. Il type converter factory si estende e DynamoDBTypeConverterFactory le sostituzioni vengono eseguite ottenendo un riferimento al set predefinito ed estendendolo. Il seguente frammento mostra come eseguire questa operazione.

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);

V2 offre funzionalità simili tramite l'annotazione. @DynamoDbBean È possibile fornire una singola AttributeConverterProvider o una catena di messaggi ordinatiAttributeConverterProvider. Tieni presente che se fornisci la tua catena di fornitori di convertitori di attributi, sostituirai il fornitore di convertitori predefinito e dovrai includerlo nella catena per utilizzare i suoi convertitori di attributi.

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

La sezione sulla conversione degli attributi di questa guida contiene un esempio completo per la versione 2.

Cronologia del documento API

Il Documento API supporta l'utilizzo di documenti JSON in stile -style come elementi singoli in una tabella DynamoDB. Il documento v1 API ha un corrispondente API nella v2, ma invece di utilizzare un client separato per il documento API come nella v1, la v2 incorpora le funzionalità del documento API nel client avanzato DynamoDB.

Nella v1, la Itemclasse rappresenta un record non strutturato da una tabella DynamoDB. Nella v2, un record non strutturato è rappresentato da un'istanza della classe. EnhancedDocument Nota che le chiavi primarie sono definite nello schema della tabella per v2 e sull'elemento stesso in v1.

La tabella seguente confronta le differenze tra il Documento APIs in v1 e v2.

Caso d'uso	v1	v2
Crea un client per documenti	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.
Fai riferimento a una tabella	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
Put Item	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);
Get Item	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
Converti una JSON struttura per usarla con il 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());
Metti JSON	documentTable.putItem(item)	documentTable.putItem(document);
Leggi JSON	GetItemOutcome outcome = //Get item. String jsonPerson = outcome.getItem().toJSON();	String jsonPerson = documentTable.getItem(Key.builder() .partitionValue(50).build()) .fromJson();

APIriferimenti e guide per il documento APIs

	v1	v2
Riferimento API	Javadoc	Javadoc
Guida alla documentazione	Guida per gli sviluppatori di Amazon DynamoDB	Documento avanzato API (questa guida)

FAQ

D: Il blocco ottimistico con un numero di versione funziona allo stesso modo nella v2 e nella v1?

R. Il comportamento è simile, ma la v2 no, non aggiunge automaticamente condizioni per le operazioni di eliminazione. È necessario aggiungere manualmente le espressioni di condizione se si desidera controllare il comportamento di eliminazione.