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 \$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.