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à. # Differenze delle API di mappatura DynamoDB tra la versione 1 e la versione 2 di AWS SDK per Java La APIs mappatura di DynamoDB è cambiata in modo significativo tra la versione 1 e la versione 2 di. AWS SDK per Java Nella versione 1, si utilizza `DynamoDBMapper` per lavorare con Java. POJOs Nella versione 2, si utilizza `DynamoDbEnhancedClient` con nomi dei metodi aggiornati, opzioni di definizione dello schema avanzate e una maggiore sicurezza dei tipi. Le differenze principali includono: + Nuovi nomi dei metodi (ad esempio, `getItem` invece di`load`) + Creazione esplicita dello schema di tabella + Supporto integrato per operazioni sincrone e asincrone + Modifiche nella modalità di gestione delle stringhe e della configurazione vuote Questa sezione descrive le modifiche all'API di mappatura, le differenze nelle annotazioni, gli aggiornamenti di configurazione e le linee guida alla migrazione per aiutarti nella transizione dalla v1 alla `DynamoDBMapper` v2. `DynamoDbEnhancedClient` **Contents** + [Modifiche di alto livello nelle librerie di mappatura dalla versione 1 alla versione 2 dell'SDK for Java](dynamodb-mapping-high-level.md) + [Importa le differenze di dipendenza](dynamodb-mapping-high-level.md#dynamodb-mapping-deps) + [Modifiche nella APIs mappatura di DynamoDB tra la versione 1 e la versione 2 dell'SDK for Java](dynamodb-mapping-api-changes.md) + [Crea un cliente](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-client) + [Stabilire la mappatura alla tabella/indice DynamoDB](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-mapping) + [Operazioni sulle tabelle](dynamodb-mapping-api-changes.md#dynamodb-mapping-api-changes-tobleops) + [Classi e proprietà della mappa](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas) + [Annotazioni Bean](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas-annos) + [Annotazioni aggiuntive V2](dynamodb-mapping-api-changes.md#dynamodb-mapping-schemas-annos-v2-addnl) + [Configurazione](dynamodb-mapping-api-changes.md#dynamodb-mapping-configuration) + [Configurazione per operazione](dynamodb-mapping-api-changes.md#dynamodb-mapping-configuration-per-op) + [Condizionali](dynamodb-mapping-api-changes.md#dynamodb-mapping-conditionals) + [Conversione del tipo](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv) + [Convertitori predefiniti](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-defaults) + [Imposta un convertitore personalizzato per un attributo](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-anno) + [Aggiungi una fabbrica o un fornitore di convertitori di tipi](dynamodb-mapping-api-changes.md#dynamodb-mapping-type-conv-factory) + [Differenze nella gestione delle stringhe tra la versione 1 e la versione 2 dell'SDK for Java](dynamodb-migration-string-handling.md) + [Differenze di blocco ottimistiche tra la versione 1 e la versione 2 dell'SDK for Java](dynamodb-migrate-optimstic-locking.md) + [Fluent setter: differenze tra la versione 1 e la versione 2 dell'SDK for Java](dynamodb-migrate-fluent-setters.md) # Modifiche di alto livello nelle librerie di mappatura dalla versione 1 alla versione 2 dell'SDK for Java I nomi del client di mappatura in ciascuna libreria differiscono in V1 e V2: + V1 - Dinamo DBMapper + V2 - Client avanzato per DynamoDB Interagisci con le due librerie più o meno allo stesso modo: crei un'istanza mapper/client e poi fornisci un POJO Java a APIs chi legge e scrive questi elementi nelle tabelle DynamoDB. Entrambe le librerie offrono anche annotazioni per la classe del POJO per indicare il modo in cui il client gestisce il 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. Esempio: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sdk-for-java/latest/developer-guide/dynamodb-mapping-high-level.html) + V2 offre diversi modi per definire schemi di tabelle e POJOs mapparli su tabelle. 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 in V1, lo schema della tabella viene dedotto dalla classe annotata secondo necessità. + [La V2 include il client [Document API nell'API client](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html) avanzata, mentre la V1 utilizza un'API separata.](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/document/DynamoDB.html) + Tutti APIs sono disponibili nelle versioni sincrone e asincrone in V2. Consulta la sezione sulla [mappatura di DynamoDB](dynamodb-enhanced-client.md) in questa guida per informazioni più dettagliate sul client avanzato V2. ## Importa le differenze di dipendenza | V1 | V2 | | --- | --- | | 

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


  
    com.amazonaws
    aws-java-sdk-dynamodb
| 

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


  
    software.amazon.awssdk
    dynamodb-enhanced
| \$1 [Ultima versione](https://central.sonatype.com/artifact/software.amazon.awssdk/bom). Nella V1, una singola dipendenza include sia l'API DynamoDB di basso livello che l'API, mentre nella V2, si utilizza mapping/document `dynamodb-enhanced` la dipendenza degli artefatti per accedere all'API. mapping/document Il `dynamodb-enhanced` modulo contiene una dipendenza transitiva dal modulo di basso livello. `dynamodb` # 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 \$1 | 
DynamoDBMapper mapper = new DynamoDBMapper(standardClient, 
                        attributeTransformerInstance);
| 
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
    .dynamoDbClient(standardClient)
    .extensions(extensionAInstance, extensionBInstance)
    .build();
| \$1 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](ddb-en-client-extensions.md) 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 factory`table()`, 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 customerTable = enhancedClient.table("Customer",
    TableSchema.fromBean(Customer.class));
| | Mappare su un indice secondario DynamoDB | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) La sezione della DynamoDB Developer Guide che [illustra il metodo `query` V1](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html#DynamoDBMapper.Methods.query) mostra un esempio completo. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) La [Usa indici secondari](ddb-en-client-use-secindex.md) 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'`DynamoDbTable`istanza, 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 come`customer1`. 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 entrambe`PutItem`. | 
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, List>
| 
enhancedClient.batchGetItem(batchGetItemRequest)

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

// Iterate over pages with lazy loading or over all items 
   from the same table.
| | Scrivi 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 pageIterable =
    customerTable.query(QueryEnhancedRequest.builder()
        .queryConditional(queryConditional)
        .select(Select.COUNT)
        .build());
Iterator> iterator = pageIterable.iterator();
Page page = iterator.next();
int count = page.count();

// For a more concise approach, you can chain the method calls:
int count = customerTable.query(QueryEnhancedRequest.builder()
                .queryConditional(queryConditional)
                .select(Select.COUNT)
                .build())
            .iterator().next().count();
| | 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 pageIterable =
    customerTable.scan(ScanEnhancedRequest.builder()
        .filterExpression(filterExpression)
        .select(Select.COUNT)
        .build());
Iterator> iterator = pageIterable.iterator();
Page page = iterator.next();
int count = page.count();

// For a more concise approach, you can chain the method calls:
int count = customerTable.scan(ScanEnhancedRequest.builder()
                .filterExpression(filterExpression)
                .select(Select.COUNT)
                .build())
            .iterator().next().count();
| | 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 **`Scan`Funzionamento 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](ddb-en-client-adv-features.md#ddb-en-client-adv-features-schm-overview) 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\$1table() 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()
| Usa un'`AttributeConverter`implementazione. 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](ddb-en-client-adv-features-conversion.md) 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:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) | ### 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](retry-strategy.md) 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\$1COMPATIBLE | 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 della paginazione | 
  .withPaginationLoadingStrategy(strategy)
Le opzioni sono: LAZY\$1`LOADING`, o `EAGER_LOADING` `ITERATION_ONLY` | LAZY\$1LOADING | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sdk-for-java/latest/developer-guide/dynamodb-mapping-api-changes.html) | | 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 `UPDATE``CLOBBER`,`PUT`,`APPEND_SET`, o`UPDATE_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 a`updateItem()`. Controlla il comportamento di aggiornamento con l'impostazione della richiesta `ignoreNulls` e l'annotazione/tag`DynamoDbUpdateBehavior`. `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 esempio`query()`, sono altamente configurabili tramite un oggetto «espressione» inviato all'operazione. Esempio: ``` DynamoDBQueryExpression emailBwQueryExpr = new DynamoDBQueryExpression() .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. 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 condizionale | 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 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 [AttributeConverter](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverter.html)API. ### 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() { @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 ordinati`AttributeConverterProvider`. 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](ddb-en-client-adv-features-conversion.md#ddb-en-client-adv-features-conversion-example) questa guida contiene un esempio completo per V2. # Differenze nella gestione delle stringhe tra la versione 1 e la versione 2 dell'SDK for Java V1 e V2 gestiscono le stringhe vuote in modo diverso quando inviano dati a DynamoDB: + **V1**: converte le stringhe vuote in valori nulli prima di inviarle a DynamoDB (con conseguente assenza di attributo) + **V2**: invia stringhe vuote come valori effettivi di stringhe vuote a DynamoDB **Importante** Dopo la migrazione alla V2, se non desideri che stringhe vuote vengano archiviate in DynamoDB, devi implementare convertitori personalizzati. Senza convertitori personalizzati, V2 memorizza le stringhe vuote come attributi di stringa vuota effettivi negli elementi DynamoDB, il che differisce dal comportamento della V1 di omettere completamente questi attributi. **Example convertitore personalizzato per V2 che converte un attributo di stringa vuoto in null** ``` /** * Custom converter that maintains V1 behavior by converting empty strings to null values * when writing to DynamoDB, ensuring compatibility with existing data. No attribute will be saved to DynamoDB. */ public class NullifyEmptyStringConverter implements AttributeConverter { @Override public AttributeValue transformFrom(String value) { if (value == null || value.isEmpty()) { return AttributeValue.builder().nul(true).build(); } return AttributeValue.builder().s(value).build(); } @Override public String transformTo(AttributeValue attributeValue) { if (attributeValue.nul()) { return null; } return attributeValue.s(); } @Override public EnhancedType type() { return EnhancedType.of(String.class); } @Override public AttributeValueType attributeValueType() { return AttributeValueType.S; } } // V2 usage: @DynamoDbBean public class Customer { private String name; @DynamoDbConvertedBy(NullifyEmptyStringConverter.class) public String getName() { return name; } } ``` # Differenze di blocco ottimistiche tra la versione 1 e la versione 2 dell'SDK for Java Sia la V1 che la V2 implementano il blocco ottimistico con un'annotazione di attributo che contrassegna una proprietà sulla classe bean per memorizzare il numero di versione. **Differenze nel comportamento di blocco ottimistico** | | V1 | V2 | | --- | --- | --- | | Annotazione della classe Bean | @DynamoDBVersionAttribute | @DynamoDbVersionAttribute(nota che V2 usa una «b» minuscola) | | Salvataggio iniziale | Attributo del numero di versione impostato su 1. | Il valore iniziale per l'attributo di versione impostato con`@DynamoDbVersionAttribute(startAt = X)`. Il valore predefinito è 0. | | Aggiorna | L'attributo del numero di versione viene incrementato di 1 se il controllo condizionale verifica che il numero di versione dell'oggetto da aggiornare corrisponda al numero nel database. | L'attributo del numero di versione viene incrementato se il controllo condizionale verifica che il numero di versione dell'oggetto da aggiornare corrisponda al numero nel database. L'attributo del numero di versione incrementato dall'opzione impostata con. `incrementBy` `@DynamoDbVersionAttribute(incrementBy = X)` Il valore predefinito è 1. | | Elimina | DynamoDBMapperaggiunge un controllo condizionale che il numero di versione dell'oggetto da eliminare corrisponda al numero di versione nel database. | V2 non aggiunge automaticamente condizioni per le operazioni di eliminazione. È necessario aggiungere manualmente le espressioni di condizione se si desidera controllare il comportamento di eliminazione. Nell'esempio seguente `recordVersion` è riportato l'attributo version del bean. 
// 1. Read the item and get its current version.
Customer item = customerTable.getItem(Key.builder().partitionValue("someId").build());
AttributeValue currentVersion = item.getRecordVersion();

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

customerTable.deleteItem(deleteItemRequest);
| | Scrittura transazionale con controllo delle condizioni | Non è possibile utilizzare una classe bean con annotazioni @DynamoDBVersionAttribute in un metodo. addConditionCheck | È possibile utilizzare una classe bean con l'@DynamoDbVersionAttributeannotazione in un metodo addConditionCheck builder per una richiesta. transactWriteItems | | Disabilita | Disabilita il blocco ottimistico modificando il valore di DynamoDBMapperConfig.SaveBehavior enumerazione da a. UPDATE CLOBBER | Non utilizzare l'annotazione. `@DynamoDbVersionAttribute` | # Fluent setter: differenze tra la versione 1 e la versione 2 dell'SDK for Java È possibile utilizzarlo POJOs con i setter fluenti nell'API di mappatura DynamoDB per V1 e con V2 a partire dalla versione 2.30.29. Ad esempio, il seguente POJO restituisce un'istanza del metodo: `Customer` `setName` ``` // V1 @DynamoDBTable(tableName ="Customer") public class Customer{ private String name; // Other attributes and methods not shown. public Customer setName(String name){ this.name = name; return this; } } ``` Tuttavia, se si utilizza una versione della V2 precedente alla 2.30.29, `setName` restituisce un'`Customer`istanza con un valore di. `name` `null` ``` // V2 prior to version 2.30.29. @DynamoDbBean public class Customer{ private String name; // Other attributes and methods not shown. public Customer setName(String name){ this.name = name; return this; // Bug: returns this instance with a `name` value of `null`. } } ``` ``` // Available in V2 since version 2.30.29. @DynamoDbBean public class Customer{ private String name; // Other attributes and methods not shown. public Customer setName(String name){ this.name = name; return this; // Returns this instance for method chaining with the `name` value set. } } ```