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à.
# Panoramica del supporto AWS SDK per DynamoDB
Il diagramma seguente fornisce una panoramica di alto livello della programmazione di applicazioni Amazon DynamoDB utilizzando il. AWS SDKs
![\[Modello di programmazione per l'utilizzo di DynamoDB con. AWS SDKs\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/images/SDKSupport.png)
1. Scrivi un'applicazione utilizzando un AWS SDK per il tuo linguaggio di programmazione.
1. Ogni AWS SDK fornisce una o più interfacce programmatiche per lavorare con DynamoDB. Le interfacce specifiche disponibili dipendono dal linguaggio di programmazione e dall'SDK utilizzati. AWS Le opzioni includono:
+ [Interfacce di basso livello che funzionano con DynamoDB](Programming.SDKs.Interfaces.md#Programming.SDKs.Interfaces.LowLevel)
+ [Interfacce documentali che funzionano con DynamoDB](Programming.SDKs.Interfaces.md#Programming.SDKs.Interfaces.Document)
+ [Interfacce di persistenza degli oggetti che funzionano con DynamoDB](Programming.SDKs.Interfaces.md#Programming.SDKs.Interfaces.Mapper)
+ [Interfacce di alto livello](HigherLevelInterfaces.md)
1. L' AWS SDK crea richieste HTTP (S) da utilizzare con l'API DynamoDB di basso livello.
1. L' AWS SDK invia la richiesta all'endpoint DynamoDB.
1. DynamoDB esegue la richiesta. Se la richiesta ha esito positivo, DynamoDB restituisce un codice di risposta HTTP 200 (OK). Se la richiesta ha esito negativo, DynamoDB restituisce un codice di errore HTTP e un messaggio di errore.
1. L' AWS SDK elabora la risposta e la ripropaga all'applicazione.
Ciascuno di essi AWS SDKs fornisce servizi importanti all'applicazione, tra cui:
+ Formattazione delle richieste HTTP(S) e serializzazione dei parametri di richiesta.
+ Generazione di una firma di crittografia per ogni richiesta.
+ Inoltro delle richieste a un endpoint DynamoDB e ricezione delle risposte da DynamoDB.
+ Estrazione dei risultati da quelle risposte.
+ Implementazione della logica dei nuovi tentativi di base in caso di errori.
Per nessuna di queste attività non occorre scrivere del codice.
**Nota**
Per ulteriori informazioni AWS SDKs, comprese le istruzioni di installazione e la documentazione, consulta [Tools for Amazon Web Services](https://aws.amazon.com/tools).
## Supporto SDK per endpoint basati su AWS account
AWS sta implementando il supporto SDK per gli AWS endpoint basati su account per DynamoDB, a partire dall'SDK for AWS Java V1 il 4 settembre 2024. Questi nuovi endpoint aiutano a garantire prestazioni e scalabilità elevate. AWS L'aggiornamento SDKs utilizzerà automaticamente i nuovi endpoint, che hanno il formato. `https://(account-id).ddb.(region).amazonaws.com`
Se si utilizza una singola istanza di un client SDK per effettuare richieste a più account, l’applicazione avrà meno opportunità di riutilizzare le connessioni. AWS consiglia di modificare le applicazioni per connettersi a un minor numero di account per istanza del client SDK. Un'alternativa consiste nell'impostare il client SDK in modo che continui a utilizzare gli endpoint regionali utilizzando l'`ACCOUNT_ID_ENDPOINT_MODE`impostazione, come documentato nella [https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html](https://docs.aws.amazon.com/sdkref/latest/guide/feature-account-endpoints.html) Tools Reference Guide.
# Interfacce programmatiche che funzionano con DynamoDB
Ciascun [SDK AWS](https://aws.amazon.com/tools) fornisce una o più interfacce programmatiche per lavorare con Amazon DynamoDB. Queste interfacce spaziano da semplici wrapper DynamoDB di basso livello a livelli di persistenza basati sugli oggetti. Le interfacce disponibili variano a seconda dell' AWS SDK e del linguaggio di programmazione utilizzati.
![\[Interfacce programmatiche disponibili in diverse versioni AWS SDKs per lavorare con DynamoDB.\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/images/SDKSupport.SDKInterfaces.png)
Nella sezione seguente sono descritte alcune delle interfacce disponibili con AWS SDK per Java come esempio (Non tutte le interfacce sono disponibili in tutte.) AWS SDKs
**Topics**
+ [Interfacce di basso livello che funzionano con DynamoDB](#Programming.SDKs.Interfaces.LowLevel)
+ [Interfacce documentali che funzionano con DynamoDB](#Programming.SDKs.Interfaces.Document)
+ [Interfacce di persistenza degli oggetti che funzionano con DynamoDB](#Programming.SDKs.Interfaces.Mapper)
## Interfacce di basso livello che funzionano con DynamoDB
Ogni AWS SDK specifico per una lingua fornisce un'interfaccia di basso livello per Amazon DynamoDB, con metodi molto simili alle richieste API DynamoDB di basso livello.
In alcuni casi, sarà necessario identificare i tipi di dati degli attributi utilizzando [Descrittori del tipo di dati](Programming.LowLevelAPI.md#Programming.LowLevelAPI.DataTypeDescriptors), ad esempio `S` per stringa o `N` per numero
**Nota**
Un'interfaccia di basso livello è disponibile in ogni SDK AWS specifico per il linguaggio.
Il seguente programma Java utilizza l'interfaccia di basso livello di AWS SDK per Java.
### Esempio di interfaccia di basso livello
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* To get an item from an Amazon DynamoDB table using the AWS SDK for Java V2,
* its better practice to use the
* Enhanced Client, see the EnhancedGetItem example.
*/
public class GetItem {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
tableName - The Amazon DynamoDB table from which an item is retrieved (for example, Music3).\s
key - The key used in the Amazon DynamoDB table (for example, Artist).\s
keyval - The key value that represents the item to get (for example, Famous Band).
""";
if (args.length != 3) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
String key = args[1];
String keyVal = args[2];
System.out.format("Retrieving item \"%s\" from \"%s\"\n", keyVal, tableName);
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
getDynamoDBItem(ddb, tableName, key, keyVal);
ddb.close();
}
public static void getDynamoDBItem(DynamoDbClient ddb, String tableName, String key, String keyVal) {
HashMap keyToGet = new HashMap<>();
keyToGet.put(key, AttributeValue.builder()
.s(keyVal)
.build());
GetItemRequest request = GetItemRequest.builder()
.key(keyToGet)
.tableName(tableName)
.build();
try {
// If there is no matching item, GetItem does not return any data.
Map returnedItem = ddb.getItem(request).item();
if (returnedItem.isEmpty())
System.out.format("No item found with the key %s!\n", key);
else {
Set keys = returnedItem.keySet();
System.out.println("Amazon DynamoDB table attributes: \n");
for (String key1 : keys) {
System.out.format("%s: %s\n", key1, returnedItem.get(key1).toString());
}
}
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
}
```
## Interfacce documentali che funzionano con DynamoDB
Molti AWS SDKs forniscono un'interfaccia documentale che consente di eseguire operazioni sul piano dei dati (creazione, lettura, aggiornamento, eliminazione) su tabelle e indici. Con un’interfaccia documentale, non è necessario specificare [Descrittori del tipo di dati](Programming.LowLevelAPI.md#Programming.LowLevelAPI.DataTypeDescriptors). I tipi di dati sono impliciti nella semantica dei dati stessi. Questi forniscono AWS SDKs anche metodi per convertire facilmente documenti JSON da e verso tipi di dati Amazon DynamoDB nativi.
**Nota**
[Le interfacce documentali sono disponibili nei formati AWS SDKs per [Java](https://aws.amazon.com/sdk-for-java), [.NET](https://aws.amazon.com/sdk-for-net), [Node.js](https://aws.amazon.com/sdk-for-node-js) e SDK. JavaScript](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/)
Il seguente programma Java utilizza l’interfaccia documentale di AWS SDK per Java. Il programma crea un oggetto `Table` che rappresenta la tabella `Music` e quindi chiede all'oggetto di utilizzare `GetItem` per recuperare una canzone. Il programma restituisce quindi l'anno in cui è uscita la canzone.
La classe `software.amazon.dynamodb.document.DynamoDB` implementa l'interfaccia di documento di DynamoDB. Notare come `DynamoDB` funge da wrapper per il client di basso livello (`AmazonDynamoDB`).
### Esempio di interfaccia documentale
```
package com.amazonaws.codesamples.gsg;
import software.amazon.dynamodb.AmazonDynamoDB;
import software.amazon.dynamodb.AmazonDynamoDBClientBuilder;
import software.amazon.dynamodb.document.DynamoDB;
import software.amazon.dynamodb.document.GetItemOutcome;
import software.amazon.dynamodb.document.Table;
public class MusicDocumentDemo {
public static void main(String[] args) {
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB docClient = new DynamoDB(client);
Table table = docClient.getTable("Music");
GetItemOutcome outcome = table.getItemOutcome(
"Artist", "No One You Know",
"SongTitle", "Call Me Today");
int year = outcome.getItem().getInt("Year");
System.out.println("The song was released in " + year);
}
}
```
## Interfacce di persistenza degli oggetti che funzionano con DynamoDB
Alcune AWS SDKs forniscono un'interfaccia di persistenza degli oggetti in cui non si eseguono direttamente operazioni sul piano dati. Invece, è possibile creare oggetti che rappresentano elementi nelle tabelle e negli indici di Amazon DynamoDB e interagire solo con quegli oggetti. Ciò consente di scrivere codice incentrato sugli oggetti piuttosto che codice incentrato sul database.
**Nota**
Le interfacce di persistenza degli oggetti sono disponibili in Java AWS SDKs e.NET. Per ulteriori informazioni, consulta [Interfacce di programmazione di livello superiore per DynamoDB](HigherLevelInterfaces.md) per Dynamo DB.
### Esempio di interfaccia di persistenza degli oggetti
```
import com.example.dynamodb.Customer;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.Key;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
import software.amazon.awssdk.enhanced.dynamodb.model.GetItemEnhancedRequest;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
```
```
import com.example.dynamodb.Customer;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.Key;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
import software.amazon.awssdk.enhanced.dynamodb.model.GetItemEnhancedRequest;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
/*
* Before running this code example, create an Amazon DynamoDB table named Customer with these columns:
* - id - the id of the record that is the key. Be sure one of the id values is `id101`
* - custName - the customer name
* - email - the email value
* - registrationDate - an instant value when the item was added to the table. These values
* need to be in the form of `YYYY-MM-DDTHH:mm:ssZ`, such as 2022-07-11T00:00:00Z
*
* Also, ensure that you have set up your development environment, including your credentials.
*
* For information, see this documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class EnhancedGetItem {
public static void main(String[] args) {
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
getItem(enhancedClient);
ddb.close();
}
public static String getItem(DynamoDbEnhancedClient enhancedClient) {
Customer result = null;
try {
DynamoDbTable table = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
Key key = Key.builder()
.partitionValue("id101").sortValue("tred@noserver.com")
.build();
// Get the item by using the key.
result = table.getItem(
(GetItemEnhancedRequest.Builder requestBuilder) -> requestBuilder.key(key));
System.out.println("******* The description value is " + result.getCustName());
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
return result.getCustName();
}
}
```
# Interfacce di programmazione di livello superiore per DynamoDB
AWS SDKs Forniscono applicazioni con interfacce di basso livello per lavorare con Amazon DynamoDB. Queste classi e metodi lato client corrispondono direttamente all'API DynamoDB di basso livello. Tuttavia, molti sviluppatori sperimentano un senso di disconnessione, o *mancata corrispondenza dell'impedenza*, quando è necessario mappare tipi di dati complessi agli elementi di una tabella di database. Con un'interfaccia di database di basso livello, gli sviluppatori devono scrivere metodi per leggere o scrivere i dati oggetto nelle tabelle di database e viceversa. La quantità di codice aggiuntivo richiesto per ogni combinazione di tipo di oggetto e tabella di database può sembrare travolgente.
Per semplificare lo sviluppo, le versioni AWS SDKs per Java e.NET forniscono interfacce aggiuntive con livelli di astrazione più elevati. Le interfacce di livello superiore per DynamoDB consentono di definire le relazioni tra gli oggetti del programma e le tabelle di database che memorizzano i dati di tali oggetti. Dopo aver definito questa mappatura, vengono richiamati metodi oggetto semplici come `save`, `load` oppure`delete` e le operazioni di DynamoDB di basso livello sottostanti vengono richiamate automaticamente per conto dell'utente. Ciò consente di scrivere codice incentrato sugli oggetti piuttosto che codice incentrato sul database.
Le interfacce di programmazione di livello superiore per DynamoDB sono disponibili in Java e.NET. AWS SDKs
**Java**
+ [Java 1.x: Dinamo DBMapper](DynamoDBMapper.md)
+ [Java 2.x: Client avanzato DynamoDB](DynamoDBEnhanced.md)
**.NET**
+ [Utilizzo del modello documentale .NET in DynamoDB](DotNetSDKMidLevel.md)
+ [Operazioni con il modello di persistenza degli oggetti di .NET e DynamoDB](DotNetSDKHighLevel.md)
# Java 1.x: Dinamo DBMapper
**Nota**
L’SDK per Java è disponibile in due versioni: 1.x e 2.x. [La versione end-of-support per 1.x è stata annunciata il 12 gennaio 2024.](https://aws.amazon.com/blogs/developer/announcing-end-of-support-for-aws-sdk-for-java-v1-x-on-december-31-2025/) Lo farà e scadrà end-of-support il 31 dicembre 2025. Per sviluppare ex novo, si consiglia vivamente di utilizzare 2.x.
AWS SDK per Java Fornisce una `DynamoDBMapper` classe che consente di mappare le classi lato client alle tabelle Amazon DynamoDB. Per utilizzare `DynamoDBMapper`, definire la relazione tra gli elementi di una tabella DynamoDB e le istanze di oggetto corrispondenti nel codice. La classe `DynamoDBMapper` consente di eseguire diverse operazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD) sugli elementi e di eseguire query e scansioni sulle tabelle.
**Topics**
+ [Classe Dynamo DBMapper](DynamoDBMapper.Methods.md)
+ [Tipi di dati supportati per Dynamo for Java DBMapper](DynamoDBMapper.DataTypes.md)
+ [Annotazioni Java per DynamoDB](DynamoDBMapper.Annotations.md)
+ [Impostazioni di configurazione opzionali per Dynamo DBMapper](DynamoDBMapper.OptionalConfig.md)
+ [DynamoDB e blocco ottimistico con il numero di versione](DynamoDBMapper.OptimisticLocking.md)
+ [Mappatura dei dati arbitrari in DynamoDB](DynamoDBMapper.ArbitraryDataMapping.md)
+ [Esempi della classe DynamoDBMapper](DynamoDBMapper.Examples.md)
**Nota**
La classe `DynamoDBMapper` non ti consente di creare, aggiornare o eliminare tabelle. Per eseguire queste attività, utilizza invece l'interfaccia SDK per Java di basso livello.
SDK per Java fornisce una serie di tipi di annotazione in modo che sia possibile mappare le classi alle tabelle. Ad esempio, considera una tabella `ProductCatalog` la cui chiave di partizione sia l'`Id`.
```
ProductCatalog(Id, ...)
```
Puoi mappare una classe nell'applicazione client alla tabella `ProductCatalog`, come mostrato nel seguente codice Java. Questo codice definisce un Plain Old Java Object (POJO), denominato `CatalogItem`, il quale utilizza annotazioni per mappare campi di oggetto ai nomi di attributo di DynamoDB.
**Example**
```
package com.amazonaws.codesamples;
import java.util.Set;
import software.amazon.dynamodb.datamodeling.DynamoDBAttribute;
import software.amazon.dynamodb.datamodeling.DynamoDBHashKey;
import software.amazon.dynamodb.datamodeling.DynamoDBIgnore;
import software.amazon.dynamodb.datamodeling.DynamoDBTable;
@DynamoDBTable(tableName="ProductCatalog")
public class CatalogItem {
private Integer id;
private String title;
private String ISBN;
private Set bookAuthors;
private String someProp;
@DynamoDBHashKey(attributeName="Id")
public Integer getId() { return id; }
public void setId(Integer id) {this.id = id; }
@DynamoDBAttribute(attributeName="Title")
public String getTitle() {return title; }
public void setTitle(String title) { this.title = title; }
@DynamoDBAttribute(attributeName="ISBN")
public String getISBN() { return ISBN; }
public void setISBN(String ISBN) { this.ISBN = ISBN; }
@DynamoDBAttribute(attributeName="Authors")
public Set getBookAuthors() { return bookAuthors; }
public void setBookAuthors(Set bookAuthors) { this.bookAuthors = bookAuthors; }
@DynamoDBIgnore
public String getSomeProp() { return someProp; }
public void setSomeProp(String someProp) { this.someProp = someProp; }
}
```
Nel codice precedente, l'annotazione `@DynamoDBTable` mappa la classe `CatalogItem` alla tabella `ProductCatalog`. Puoi archiviare istanze di classi individuali come item della tabella. Nella definizione della classe, l'annotazione `@DynamoDBHashKey` mappa la proprietà `Id` alla chiave primaria.
Per impostazione predefinita, le proprietà di classe si mappano agli stessi attributi dei nomi della tabella. Le proprietà `Title` e `ISBN` si mappano agli stessi attributi dei nomi della tabella.
L'annotazione `@DynamoDBAttribute` è facoltativa quando il nome dell'attributo DynamoDB corrisponde al nome della proprietà dichiarata nella classe. Quando questi sono differenti, utilizza questa annotazione con il parametro `attributeName` in modo da specificare a quale attributo DynamoDB corrisponde questa proprietà.
Nell’esempio precedente, l’annotazione `@DynamoDBAttribute` viene aggiunta a ogni proprietà per garantire che i nomi della proprietà corrispondano esattamente alle tabelle create in una fase precedente e che sia coerente con i nomi di attributo utilizzati in altri esempi di codice in questa guida.
La definizione della classe può avere proprietà che non si mappano ad alcun attributo della tabella. Identifica queste proprietà aggiungendo l'annotazione `@DynamoDBIgnore`. Nell'esempio precedente, la proprietà `SomeProp` viene contrassegnata con l'annotazione `@DynamoDBIgnore`. Quando carichi nella tabella l'istanza `CatalogItem`, l'istanza `DynamoDBMapper` non include la proprietà `SomeProp`. Inoltre, il mappatore non restituisce questo attributo quando recuperi un item dalla tabella.
Dopo aver definito la classe di mappatura, puoi utilizzare i metodi `DynamoDBMapper` per scrivere un'istanza di tale classe in un item corrispondente nella tabella `Catalog`. Il seguente esempio di codice dimostra questa tecnica.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDBMapper mapper = new DynamoDBMapper(client);
CatalogItem item = new CatalogItem();
item.setId(102);
item.setTitle("Book 102 Title");
item.setISBN("222-2222222222");
item.setBookAuthors(new HashSet(Arrays.asList("Author 1", "Author 2")));
item.setSomeProp("Test");
mapper.save(item);
```
Il seguente esempio di codice mostra come recuperare l'item e accedere ad alcuni dei suoi attributi:
```
CatalogItem partitionKey = new CatalogItem();
partitionKey.setId(102);
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withHashKeyValues(partitionKey);
List itemList = mapper.query(CatalogItem.class, queryExpression);
for (int i = 0; i < itemList.size(); i++) {
System.out.println(itemList.get(i).getTitle());
System.out.println(itemList.get(i).getBookAuthors());
}
```
`DynamoDBMapper` offre un modo intuitivo e naturale di lavorare con i dati di DynamoDB all'interno di Java. Fornisce inoltre diverse caratteristiche integrate, come il blocco ottimistico, transazioni ACID, valori di chiavi di partizione e di ordinamento generati automaticamente e la funzione Versioni multiple degli oggetti.
# Classe Dynamo DBMapper
La classe `DynamoDBMapper` è il punto di ingresso al database Amazon DynamoDB. Fornisce l'accesso a un endpoint DynamoDB e consente di accedere ai dati in diverse tabelle. Consente anche di eseguire diverse operazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD) sugli elementi e di eseguire query e scansioni sulle tabelle. Questa classe fornisce i metodi seguenti per lavorare con DynamoDB.
[https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapper.html)
**Topics**
+ [save](#DynamoDBMapper.Methods.save)
+ [caricare](#DynamoDBMapper.Methods.load)
+ [Elimina](#DynamoDBMapper.Methods.delete)
+ [query](#DynamoDBMapper.Methods.query)
+ [queryPage](#DynamoDBMapper.Methods.queryPage)
+ [scan](#DynamoDBMapper.Methods.scan)
+ [scanPage](#DynamoDBMapper.Methods.scanPage)
+ [parallelScan](#DynamoDBMapper.Methods.parallelScan)
+ [batchSave](#DynamoDBMapper.Methods.batchSave)
+ [batchLoad](#DynamoDBMapper.Methods.batchLoad)
+ [batchDelete](#DynamoDBMapper.Methods.batchDelete)
+ [BatchWrite](#DynamoDBMapper.Methods.batchWrite)
+ [transactionWrite](#DynamoDBMapper.Methods.transactionWrite)
+ [transactionLoad](#DynamoDBMapper.Methods.transactionLoad)
+ [count](#DynamoDBMapper.Methods.count)
+ [generateCreateTableRichiesta](#DynamoDBMapper.Methods.generateCreateTableRequest)
+ [createS3Link](#DynamoDBMapper.Methods.createS3Link)
+ [ottiene S3 ClientCache](#DynamoDBMapper.Methods.getS3ClientCache)
## save
Salva l'oggetto specificato nella tabella. L'oggetto che intendi salvare è l'unico parametro obbligatorio di questo metodo. Puoi fornire parametri di configurazione opzionali utilizzando l'oggetto `DynamoDBMapperConfig`.
Se non esiste un item avente la stessa chiave primaria, questo metodo crea un nuovo item nella tabella. Se esiste un item avente la stessa chiave primaria, esso aggiorna l'item esistente. Se la chiave di partizione e la chiave di ordinamento sono del tipo String e sono annotate con `@DynamoDBAutoGeneratedKey`, viene loro assegnato un identificatore unico universale casuale (UUID) in caso di mancata inizializzazione. I campi di versione annotati con `@DynamoDBVersionAttribute` vengono incrementati di una unità. Inoltre, se viene aggiornato un campo di versione o viene generata una chiave, l'oggetto passato si aggiornerà a seguito dell'operazione.
Per impostazione predefinita, solo gli attributi corrispondenti alle proprietà della classe mappate vengono aggiornati. Glie eventuali attributi esistenti aggiuntivi su un item non sono interessati. Tuttavia, se specifichi `SaveBehavior.CLOBBER`, puoi forzare la sovrascrittura completa dell'item.
```
DynamoDBMapperConfig config = DynamoDBMapperConfig.builder()
.withSaveBehavior(DynamoDBMapperConfig.SaveBehavior.CLOBBER).build();
mapper.save(item, config);
```
Se la funzione Versioni multiple è abilitata, le versioni dell'item lato client e lato server devono corrispondere. Tuttavia, non è necessario che la versione corrisponda se viene utilizzata l'opzione `SaveBehavior.CLOBBER`. Per ulteriori informazioni sulla funzione Controllo delle versioni, consulta [DynamoDB e blocco ottimistico con il numero di versione](DynamoDBMapper.OptimisticLocking.md).
## caricare
Recupera un item da una tabella. È necessario fornire la chiave primaria dell'item che intendi recuperare. Puoi fornire parametri di configurazione opzionali utilizzando l'oggetto `DynamoDBMapperConfig`. Ad esempio, puoi richiedere facoltativamente letture fortemente consistenti per garantire che questo metodo recuperi solo i valori di item più recenti, come riportato nella seguente dichiarazione Java.
```
DynamoDBMapperConfig config = DynamoDBMapperConfig.builder()
.withConsistentReads(DynamoDBMapperConfig.ConsistentReads.CONSISTENT).build();
CatalogItem item = mapper.load(CatalogItem.class, item.getId(), config);
```
Per impostazione predefinita, DynamoDB restituisce l'elemento che dispone di valori con consistenza finale. Per informazioni sul modello di consistenza finale di DynamoDB, consulta [Coerenza di lettura di DynamoDB](HowItWorks.ReadConsistency.md).
## Elimina
Elimina un item dalla tabella. È necessario passare un'istanza di oggetto della classe mappata.
Se la funzione Versioni multiple è abilitata, le versioni dell'item lato client e lato server devono corrispondere. Tuttavia, non è necessario che la versione corrisponda se viene utilizzata l'opzione `SaveBehavior.CLOBBER`. Per ulteriori informazioni sulla funzione Controllo delle versioni, consulta [DynamoDB e blocco ottimistico con il numero di versione](DynamoDBMapper.OptimisticLocking.md).
## query
Esegue una query su una tabella o un indice secondario.
Supponiamo che tu abbia una tabella, `Reply`, in cui vengono memorizzate le risposte dei thread di un forum. Ogni tema del thread può contenere 0 o più risposte. La chiave primaria della tabella `Reply` è costituita dai campi `Id` e `ReplyDateTime`, in cui l'`Id` è la chiave di partizione, mentre `ReplyDateTime` è la chiave di ordinamento della chiave primaria.
```
Reply ( Id, ReplyDateTime, ... )
```
Si supponga ora di aver creato una mappatura tra la classe `Reply` e la tabella `Reply` corrispondente in DynamoDB. Il seguente codice Java utilizza `DynamoDBMapper` per trovare tutte le risposte delle due settimane precedenti di uno specifico tema di un thread.
**Example**
```
String forumName = "&DDB;";
String forumSubject = "&DDB; Thread 1";
String partitionKey = forumName + "#" + forumSubject;
long twoWeeksAgoMilli = (new Date()).getTime() - (14L*24L*60L*60L*1000L);
Date twoWeeksAgo = new Date();
twoWeeksAgo.setTime(twoWeeksAgoMilli);
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
String twoWeeksAgoStr = df.format(twoWeeksAgo);
Map eav = new HashMap();
eav.put(":v1", new AttributeValue().withS(partitionKey));
eav.put(":v2",new AttributeValue().withS(twoWeeksAgoStr.toString()));
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withKeyConditionExpression("Id = :v1 and ReplyDateTime > :v2")
.withExpressionAttributeValues(eav);
List latestReplies = mapper.query(Reply.class, queryExpression);
```
La query restituisce una raccolta di oggetti `Reply`.
Per impostazione predefinita, il metodo `query` restituisce una raccolta a "caricamento differito". Inizialmente restituisce solo una pagina di risultati e in seguito effettua una chiamata di assistenza per la pagina successiva, se necessario. Per ottenere tutti gli elementi corrispondenti, eseguire iterazioni sulla raccolta `latestReplies`.
Tieni presente che la chiamata del metodo `size()` sulla raccolta carica tutti i risultati al fine di fornire un conteggio accurato. Di conseguenza si potrebbe verificare un consumo eccessivo di throughput assegnato e nel caso di una tabella molto grande potrebbe persino esaurirsi tutta la memoria nella JVM.
Per eseguire query a un indice, è necessario in primo luogo modellarlo come classe di mappatore. *Supponiamo che la `Reply` tabella abbia un indice secondario globale denominato -Message-Index. PostedBy* La chiave di partizione di quest'indice è `PostedBy`, mentre la chiave di ordinamento è `Message`. La definizione di classe di un item dell'indice dovrebbe avere un aspetto simile al seguente:
```
@DynamoDBTable(tableName="Reply")
public class PostedByMessage {
private String postedBy;
private String message;
@DynamoDBIndexHashKey(globalSecondaryIndexName = "PostedBy-Message-Index", attributeName = "PostedBy")
public String getPostedBy() { return postedBy; }
public void setPostedBy(String postedBy) { this.postedBy = postedBy; }
@DynamoDBIndexRangeKey(globalSecondaryIndexName = "PostedBy-Message-Index", attributeName = "Message")
public String getMessage() { return message; }
public void setMessage(String message) { this.message = message; }
// Additional properties go here.
}
```
L'annotazione `@DynamoDBTable` indica che questo indice è associato alla tabella `Reply`. *L'`@DynamoDBIndexHashKey`annotazione indica la chiave di partizione (*PostedBy*) dell'indice e `@DynamoDBIndexRangeKey` indica la chiave di ordinamento (Message) dell'indice.*
Puoi ora utilizzare `DynamoDBMapper` per eseguire query all'indice, recuperando un sottoinsieme di messaggi pubblicati da un determinato utente. Non è necessario specificare il nome dell'indice se non sono presenti mappature in conflitto tra tabelle e indici e le mappature sono già state eseguite nel mappatore. Il mappatore deciderà in base alla chiave primaria e alla chiave di ordinamento. Il codice seguente esegue una query su un indice secondario globale. Poiché gli indici secondari globali supportano letture consistenti finali, ma non letture consistenti, è necessario specificare `withConsistentRead(false)`.
```
HashMap eav = new HashMap();
eav.put(":v1", new AttributeValue().withS("User A"));
eav.put(":v2", new AttributeValue().withS("DynamoDB"));
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false)
.withKeyConditionExpression("PostedBy = :v1 and begins_with(Message, :v2)")
.withExpressionAttributeValues(eav);
List iList = mapper.query(PostedByMessage.class, queryExpression);
```
La query restituisce una raccolta di oggetti `PostedByMessage`.
## queryPage
Esegue query su una tabella o un indice secondario e restituisce una singola pagina di risultati corrispondenti. Come per il metodo `query`, è necessario specificare il valore di una chiave di partizione e un filtro query applicato all'attributo della chiave di ordinamento. Tuttavia, `queryPage` restituisce solo la prima "pagina" di dati, ovvero la quantità di dati che rientra in 1 MB.
## scan
Esegue la scansione di un'intera tabella o di un indice secondario. Puoi specificare facoltativamente `FilterExpression` per filtrare il set di risultati.
Supponiamo che tu abbia una tabella, `Reply`, in cui vengono memorizzate le risposte dei thread di un forum. Ogni tema del thread può contenere 0 o più risposte. La chiave primaria della tabella `Reply` è costituita dai campi `Id` e `ReplyDateTime`, in cui l'`Id` è la chiave di partizione, mentre `ReplyDateTime` è la chiave di ordinamento della chiave primaria.
```
Reply ( Id, ReplyDateTime, ... )
```
Se hai mappato una classe Java alla tabella `Reply`, puoi utilizzare la `DynamoDBMapper` per eseguire la scansione della tabella. Ad esempio, il seguente codice Java esegue la scansione dell'intera tabella `Reply`, restituendo solo le risposte di un determinato anno.
**Example**
```
HashMap eav = new HashMap();
eav.put(":v1", new AttributeValue().withS("2015"));
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withFilterExpression("begins_with(ReplyDateTime,:v1)")
.withExpressionAttributeValues(eav);
List replies = mapper.scan(Reply.class, scanExpression);
```
Per impostazione predefinita, il metodo `scan` restituisce una raccolta a "caricamento differito". Inizialmente restituisce solo una pagina di risultati e in seguito effettua una chiamata di assistenza per la pagina successiva, se necessario. Per ottenere tutti gli elementi corrispondenti, eseguire iterazioni sulla raccolta `replies`.
Tieni presente che la chiamata del metodo `size()` sulla raccolta carica tutti i risultati al fine di fornire un conteggio accurato. Di conseguenza si potrebbe verificare un consumo eccessivo di throughput assegnato e nel caso di una tabella molto grande potrebbe persino esaurirsi tutta la memoria nella JVM.
Per eseguire la scansione di un indice, è necessario in primo luogo modellarlo come classe di mappatore. Supponiamo che la tabella `Reply` abbia un indice secondario globale denominato `PostedBy-Message-Index`. La chiave di partizione di quest'indice è `PostedBy`, mentre la chiave di ordinamento è `Message`. Una classe di mappatore per questo indice viene mostrata nella sezione [query](#DynamoDBMapper.Methods.query). Utilizza le annotazioni `@DynamoDBIndexHashKey` e `@DynamoDBIndexRangeKey` per specificare la chiave di partizione e la chiave di ordinamento dell'indice.
L'esempio di codice seguente esegue la scansione di `PostedBy-Message-Index`. Esso non utilizza un filtro di scansione, così che ti vengano restituiti tutti gli elementi dell'indice.
```
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false);
List iList = mapper.scan(PostedByMessage.class, scanExpression);
Iterator indexItems = iList.iterator();
```
## scanPage
Esegue una scansione su una tabella o un indice secondario e restituisce una singola pagina di risultati corrispondenti. Come per il metodo `scan`, puoi specificare facoltativamente `FilterExpression` per filtrare il set di risultati. Tuttavia, `scanPage` restituisce solo la prima "pagina" di dati, ovvero la quantità di dati che rientra in 1 MB.
## parallelScan
Esegue una scansione parallela di un'intera tabella o di un indice secondario. Puoi specificare una serie di segmenti logici della tabella e un'espressione scan per filtrare i risultati. `parallelScan` divide l'attività di scansione tra più dipendenti, uno per ogni segmento logico; i dipendenti elaborano i dati in parallelo e restituiscono i risultati.
L'esempio di codice Java seguente esegue una scansione parallela sulla tabella `Product`.
```
int numberOfThreads = 4;
Map eav = new HashMap();
eav.put(":n", new AttributeValue().withN("100"));
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withFilterExpression("Price <= :n")
.withExpressionAttributeValues(eav);
List scanResult = mapper.parallelScan(Product.class, scanExpression, numberOfThreads);
```
## batchSave
Salva gli oggetti in una o più tabelle tramite una o più chiamate al metodo `AmazonDynamoDB.batchWriteItem`. Questo metodo non fornisce garanzie sulle transazioni.
Il codice Java seguente salva due item (libri) nella tabella `ProductCatalog`.
```
Book book1 = new Book();
book1.setId(901);
book1.setProductCategory("Book");
book1.setTitle("Book 901 Title");
Book book2 = new Book();
book2.setId(902);
book2.setProductCategory("Book");
book2.setTitle("Book 902 Title");
mapper.batchSave(Arrays.asList(book1, book2));
```
## batchLoad
Recupera più item da una o più tabelle utilizzando la loro chiave primaria.
Il seguente codice Java recupera due item da due tabelle differenti.
```
ArrayList