Modifiche nella APIs mappatura di DynamoDB tra la versione 1 e la versione 2 dell'SDK for Java - AWS SDK for Java 2.x
Crea un clienteStabilire la mappatura alla tabella/indice DynamoDBOperazioni sulle tabelleClassi e proprietà della mappaConfigurazioneCondizionaliConversione del tipo

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Modifiche nella APIs mappatura di DynamoDB tra la versione 1 e la versione 2 dell'SDK for Java

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 per personalizzare le operazioni di DynamoDB Enhanced Client 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 classe Java POJO 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

  1. Definire una classe POJO che rappresenti l'indice.

    • Annota la classe @DynamoDBTable fornendo il nome della tabella che contiene l'indice.

    • Annota le proprietà con @DynamoDBIndexHashKey e facoltativamente. @DynamoDBIndexRangeKey

  2. Crea un'espressione di interrogazione.

  3. Interrogazione utilizzando il riferimento alla classe POJO 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.

  1. Annota gli attributi di una classe POJO con @DynamoDbSecondaryPartitionKey (per un GSI) e @DynamoDbSecondarySortKey (per un GSI o LSI). Ad esempio, 

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

  2. Recuperate un riferimento all'indice. Ad esempio, 

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

  3. 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'istanza POJO viene definita come item o come un tipo specifico comecustomer1. Per gli esempi V2, le istanze denominate table sono il risultato di una chiamata precedente enhancedClient.table() che restituisce un riferimento all'istanza. DynamoDbTable

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, Table operations (di seguito) contiene alcuni dei moduli più comunemente usati 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)

Le operazioni della tabella (di seguito) mostrano i moduli più comunemente usati:

mapper.load(item)
mapper.load(item, config)
Operazioni sulle tabelle
Caso d'uso V1 V2

Scrivere un Java POJO su una tabella DynamoDB

Operazione DynamoDB:, PutItem UpdateItem

 
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.

 
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

Funzionamento 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.

Eliminare un elemento da una tabella DynamoDB

Funzionamento DynamoDB: DeleteItem

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

Interroga una tabella o un indice secondario DynamoDB e restituisci un elenco impaginato

Funzionamento DynamoDB: Query

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

Usa il valore restituito PageIterable.stream() (lazy loading) per le risposte di sincronizzazione e PagePublisher.subscribe() per le risposte asincrone

Interroga una tabella o un indice secondario DynamoDB e restituisci un elenco

Funzionamento DynamoDB: Query

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

Usa 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

Funzionamento DynamoDB: Scan

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

Usa il valore restituito PageIterable.stream() (lazy loading) per le risposte di sincronizzazione e PagePublisher.subscribe() per le risposte asincrone

Scansiona una tabella o un indice secondario DynamoDB e restituisci un elenco

Funzionamento DynamoDB: Scan

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

Usa 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

Funzionamento 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.

Scrive più elementi su più tabelle in un batch

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

Eliminare più elementi da più tabelle in un batch

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

Scrittura/elimina più elementi in un batch

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

Eseguire una scrittura transazionale

Funzionamento DynamoDB: TransactWriteItems

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

Effettuare una lettura transazionale

Funzionamento DynamoDB: TransactGetItems

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

Ottieni un conteggio degli elementi corrispondenti di una query

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

Ottieni un conteggio degli elementi corrispondenti di una scansione

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

Crea una tabella in DynamoDB corrispondente alla classe POJO

Funzionamento DynamoDB: CreateTable

 
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.

 
table.createTable(createTableRequest)

table.createTable(r -> r.provisionedThroughput(defaultThroughput())
    .globalSecondaryIndices(
        EnhancedGlobalSecondaryIndex.builder()
            .indexName("gsi_1")
            .projection(p -> p.projectionType(ProjectionType.ALL))
            .provisionedThroughput(defaultThroughput())
            .build()));

Esegui una scansione parallela in DynamoDB

ScanFunzionamento DynamoDB: con e parametri Segment TotalSegments

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

Gli utenti devono gestire i thread di lavoro e le chiamate 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, in V2 seguono la convenzione camel case e utilizzano '', 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 DynamoDbEnhancedClient#table() metodo.
Designate un membro della classe come attributo della tabella 
@DynamoDBAttribute(attributeName = "customerName")
 
@DynamoDbAttribute("customerName")
Designare un membro della classe è una chiave hash/partition 
@DynamoDBHashKey 
@DynamoDbPartitionKey
Designare un membro della classe è fondamentale range/sort 
@DynamoDBRangeKey 
@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 UUID generato automaticamente 
@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>)

Usa un'AttributeConverterimplementazione. V2 offre molti convertitori integrati per i tipi Java più comuni. Puoi anche implementare il tuo file personalizzato AttributeConverter o. AttributeConverterProvider Vedi Controlla la conversione degli attributi in questa guida.
Designare una classe che può essere serializzata in un documento DynamoDB (documento in stile JSON) o in un documento secondario 
@DynamoDBDocument
 Utilizzate l'API Enhanced Document. Consulta le seguenti risorse:

Annotazioni aggiuntive V2

Caso d'uso V1 V2
Designate un membro della classe da non memorizzare come attributo NULL 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. In V2, la configurazione è specifica dell'oggetto di richiesta per l'operazione.

Caso d'uso V1 Impostazione predefinita in V1 V2 
DynamoDBMapperConfig.builder()
Strategia di load/write ripetizione dei tentativi in batch 
  .withBatchLoadRetryStrategy(loadRetryStrategy)
  .withBatchWriteRetryStrategy(writeRetryStrategy)
 Riprova gli elementi non riusciti Configura la strategia di riprova sul dispositivo sottostante. DynamoDBClient Vedi Configurare il comportamento dei tentativi in AWS SDK for Java 2.x in questa guida.
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 DynamoDbEnhancedClient#table() metodo.
Strategia di caricamento dell'impaginazione 
  .withPaginationLoadingStrategy(strategy)

Le opzioni sono: LAZY_LOADING, o EAGER_LOADING ITERATION_ONLY

 LAZY_LOADING

  • L'impostazione predefinita è solo l'iterazione. Le altre opzioni V1 non sono supportate.

  • È possibile implementare l'equivalente dell'eager loading in V2 con quanto segue: 

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

  • Per il caricamento lento, è necessario implementare la propria logica di memorizzazione nella cache per gli elementi a cui si accede.
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

In 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

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

In 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

In 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 versione 2, l'SDK fornisce un set di convertitori predefiniti per tutti i tipi più 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 riferimento AttributeConverterAPI.

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

La versione 2 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 V2.