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à. # 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 itemsToGet = new ArrayList(); ForumItem forumItem = new ForumItem(); forumItem.setForumName("Amazon DynamoDB"); itemsToGet.add(forumItem); ThreadItem threadItem = new ThreadItem(); threadItem.setForumName("Amazon DynamoDB"); threadItem.setSubject("Amazon DynamoDB thread 1 message text"); itemsToGet.add(threadItem); Map> items = mapper.batchLoad(itemsToGet); ``` ## batchDelete Elimina gli oggetti da una o più tabelle tramite una o più chiamate al metodo `AmazonDynamoDB.batchWriteItem`. Questo metodo non fornisce garanzie sulle transazioni. Il seguente codice Java elimina due item (libri) dalla tabella `ProductCatalog`. ``` Book book1 = mapper.load(Book.class, 901); Book book2 = mapper.load(Book.class, 902); mapper.batchDelete(Arrays.asList(book1, book2)); ``` ## BatchWrite Salva gli oggetti o li elimina da una o più tabelle tramite una o più chiamate al metodo `AmazonDynamoDB.batchWriteItem`. Questo metodo non fornisce garanzie sulle transazioni né supporta la funzione Versioni multiple (inserimenti o eliminazioni condizionali). Il seguente frammento di codice Java scrive un nuovo item nella tabella `Forum`, scrive un nuovo item nella tabella `Thread` ed elimina un item dalla tabella `ProductCatalog`. ``` // Create a Forum item to save Forum forumItem = new Forum(); forumItem.setName("Test BatchWrite Forum"); // Create a Thread item to save Thread threadItem = new Thread(); threadItem.setForumName("AmazonDynamoDB"); threadItem.setSubject("My sample question"); // Load a ProductCatalog item to delete Book book3 = mapper.load(Book.class, 903); List objectsToWrite = Arrays.asList(forumItem, threadItem); List objectsToDelete = Arrays.asList(book3); mapper.batchWrite(objectsToWrite, objectsToDelete); ``` ## transactionWrite Salva gli oggetti o li elimina da una o più tabelle tramite una o più chiamate al metodo `AmazonDynamoDB.transactWriteItems`. [Per un elenco delle eccezioni specifiche delle transazioni, consulta errori. TransactWriteItems ](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html#API_TransactWriteItems_Errors) Per ulteriori informazioni sulle transazioni DynamoDB e le garanzie ACID (Atomicity, Consistency, Isolation and Durability) fornite, consulta [Amazon DynamoDB Transactions](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html). **Nota** Questo metodo non supporta i seguenti metodi: [Dynamo ConfigDBMapper. SaveBehavior](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.OptionalConfig.html). Il seguente codice Java scrive un nuovo item in ogni tabella `Forum` e `Thread`, a livello di transazione. ``` Thread s3ForumThread = new Thread(); s3ForumThread.setForumName("S3 Forum"); s3ForumThread.setSubject("Sample Subject 1"); s3ForumThread.setMessage("Sample Question 1"); Forum s3Forum = new Forum(); s3Forum.setName("S3 Forum"); s3Forum.setCategory("Amazon Web Services"); s3Forum.setThreads(1); TransactionWriteRequest transactionWriteRequest = new TransactionWriteRequest(); transactionWriteRequest.addPut(s3Forum); transactionWriteRequest.addPut(s3ForumThread); mapper.transactionWrite(transactionWriteRequest); ``` ## transactionLoad Carica gli oggetti da una o più tabelle tramite una chiamata al metodo `AmazonDynamoDB.transactGetItems`. [Per un elenco delle eccezioni specifiche delle transazioni, consulta errori. TransactGetItems ](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html#API_TransactGetItems_Errors) Per ulteriori informazioni sulle transazioni DynamoDB e le garanzie ACID (Atomicity, Consistency, Isolation and Durability) fornite, consulta [Amazon DynamoDB Transactions](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html). Il seguente codice Java carica un elemento da ciascuna delle tabelle `Forum` e `Thread`, a livello di transazione. ``` Forum dynamodbForum = new Forum(); dynamodbForum.setName("DynamoDB Forum"); Thread dynamodbForumThread = new Thread(); dynamodbForumThread.setForumName("DynamoDB Forum"); TransactionLoadRequest transactionLoadRequest = new TransactionLoadRequest(); transactionLoadRequest.addLoad(dynamodbForum); transactionLoadRequest.addLoad(dynamodbForumThread); mapper.transactionLoad(transactionLoadRequest); ``` ## count Valuta l'espressione scan specificata e restituisce il numero di item corrispondenti. Non viene restituito alcun dato di item. ## generateCreateTableRichiesta Analizza una classe POJO che rappresenta una tabella DynamoDB e restituisce un `CreateTableRequest` per tale tabella. ## createS3Link Crea un collegamento a un oggetto in Amazon S3. È necessario specificare un nome del bucket e un nome della chiave, il quale identifica l'oggetto nel bucket in modo univoco. Per utilizzare `createS3Link`, la classe di mappatore deve definire metodi getter e setter. Il seguente esempio di codice lo illustra aggiungendo un nuovo attributo e nuovi getter/setter metodi alla `CatalogItem` classe. ``` @DynamoDBTable(tableName="ProductCatalog") public class CatalogItem { ... public S3Link productImage; .... @DynamoDBAttribute(attributeName = "ProductImage") public S3Link getProductImage() { return productImage; } public void setProductImage(S3Link productImage) { this.productImage = productImage; } ... } ``` Il seguente frammento di codice Java definisce un nuovo item da scrivere nella tabella `Product`. Questo elemento include un collegamento all'immagine del prodotto; i dati relativi all'immagine vengono caricati in Amazon S3. ``` CatalogItem item = new CatalogItem(); item.setId(150); item.setTitle("Book 150 Title"); String amzn-s3-demo-bucket = "amzn-s3-demo-bucket"; String myS3Key = "productImages/book_150_cover.jpg"; item.setProductImage(mapper.createS3Link(amzn-s3-demo-bucket, myS3Key)); item.getProductImage().uploadFrom(new File("/file/path/book_150_cover.jpg")); mapper.save(item); ``` La classe `S3Link` fornisce molti altri metodi per manipolare gli oggetti in Amazon S3. Per ulteriori informazioni, vedi la sezione relativa a [Javadocs per `S3Link`](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/S3Link.html). ## ottiene S3 ClientCache Restituisce `S3ClientCache` sottostante per accedere ad Amazon S3. Una `S3ClientCache` è una mappa intelligente per gli oggetti `AmazonS3Client`. Se hai più clienti, An `S3ClientCache` può aiutarti a mantenere i clienti organizzati per AWS regione e può creare nuovi client Amazon S3 su richiesta. # Tipi di dati supportati per Dynamo for Java DBMapper In questa sezione vengono descritti i tipi di dati Java primitivi, le raccolte e i tipi di dati arbitrari supportati in Amazon DynamoDB. Amazon DynamoDB supporta i seguenti tipi di dati Java primitivi e classi wrapper primitive. + `String` + `Boolean`, `boolean` + `Byte`, `byte` + `Date` (come stringa con precisione pari al millisecondo [ISO\$18601](http://en.wikipedia.org/wiki/ISO_8601), convertita in UTC) + `Calendar` (come stringa con precisione pari al millisecondo [ISO\$18601](http://en.wikipedia.org/wiki/ISO_8601), convertita in UTC) + `Long`, `long` + `Integer`, `int` + `Double`, `double` + `Float`, `float` + `BigDecimal` + `BigInteger` **Nota** Per ulteriori informazioni sulle regole di denominazione di DynamoDB e i vari tipi di dati supportati, consulta [Tipi di dati e regole di denominazione supportati in Amazon DynamoDB](HowItWorks.NamingRulesDataTypes.md). I valori binari vuoti sono supportati da Dynamo. DBMapper I valori String vuoti sono supportati da AWS SDK for Java 2.x. In AWS SDK for Java 1.x, DBMapper Dynamo supporta la lettura di valori di attributi String vuoti, tuttavia non scriverà valori di attributi String vuoti perché questi attributi vengono eliminati dalla richiesta. DynamoDB supporta i tipi di raccolta Java [Set](http://docs.oracle.com/javase/6/docs/api/java/util/Set.html), [List](http://docs.oracle.com/javase/6/docs/api/java/util/List.html) e [Map](http://docs.oracle.com/javase/6/docs/api/java/util/Map.html). La tabella seguente riassume il modo in cui questi tipi Java vengono mappati ai tipi DynamoDB. **** | Tipo di Java | Tipo DynamoDB | | --- | --- | | Tutti i tipi di numeri | `N` (tipo numero) | | Stringhe | `S` (tipo stringa) | | Booleano | `BOOL` (Tipo booleano), 0 o 1. | | ByteBuffer | `B` (tipo binario) | | Data | `S` (tipo stringa). I valori Date vengono archiviati come stringhe in formato ISO-8601. | | Tipi di raccolta [Set](http://docs.oracle.com/javase/6/docs/api/java/util/Set.html) | `SS` tipo (set di stringhe), `NS` tipo (set di numeri) o `BS` tipo (set binario). | L'interfaccia `DynamoDBTypeConverter` consente di mappare i propri tipi di dati arbitrari a un tipo di dati supportato in nativo da DynamoDB. Per ulteriori informazioni, consulta [Mappatura dei dati arbitrari in DynamoDB](DynamoDBMapper.ArbitraryDataMapping.md). # Annotazioni Java per DynamoDB In questa sezione vengono descritte le annotazioni disponibili per la mappatura delle classi e delle proprietà alle tabelle e agli attributi in Amazon DynamoDB. Per la documentazione Javadoc corrispondente, consulta [Riepilogo dei tipi di annotazioni](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/package-summary.html) nella [Documentazione di riferimento delle API di AWS SDK per Java](https://docs.aws.amazon.com/sdk-for-java/latest/reference/). **Nota** Nelle seguenti annotazioni, sono obbligatori solo `DynamoDBTable` e `DynamoDBHashKey`. **Topics** + [Dinamo DBAttribute](#DynamoDBMapper.Annotations.DynamoDBAttribute) + [Dinamo DBAuto GeneratedKey](#DynamoDBMapper.Annotations.DynamoDBAutoGeneratedKey) + [Dinamo DBAuto GeneratedTimestamp](#DynamoDBMapper.Annotations.DynamoDBAutoGeneratedTimestamp) + [Dinamo DBDocument](#DynamoDBMapper.Annotations.DynamoDBDocument) + [Chiave Dynamo DBHash](#DynamoDBMapper.Annotations.DynamoDBHashKey) + [Dinamo DBIgnore](#DynamoDBMapper.Annotations.DynamoDBIgnore) + [Dinamo DBIndex HashKey](#DynamoDBMapper.Annotations.DynamoDBIndexHashKey) + [Dinamo DBIndex RangeKey](#DynamoDBMapper.Annotations.DynamoDBIndexRangeKey) + [Chiave Dynamo DBRange](#DynamoDBMapper.Annotations.DynamoDBRangeKey) + [Dinamo DBTable](#DynamoDBMapper.Annotations.DynamoDBTable) + [Dinamo convertita DBType](#DynamoDBMapper.Annotations.DynamoDBTypeConverted) + [Dinamo DBTyped](#DynamoDBMapper.Annotations.DynamoDBTyped) + [Attributo Dynamo DBVersion](#DynamoDBMapper.Annotations.DynamoDBVersionAttribute) ## Dinamo DBAttribute Mappa una proprietà all'attributo della tabella. Per impostazione predefinita, ogni proprietà di classe si mappa a un attributo item con lo stesso nome. Tuttavia, se i nomi non sono gli stessi, puoi utilizzare questa annotazione per mappare una proprietà all'attributo. Nel frammento Java seguente, `DynamoDBAttribute` mappa la proprietà `BookAuthors` al nome di attributo `Authors` della tabella. ``` @DynamoDBAttribute(attributeName = "Authors") public List getBookAuthors() { return BookAuthors; } public void setBookAuthors(List BookAuthors) { this.BookAuthors = BookAuthors; } ``` `DynamoDBMapper` utilizza `Authors` come nome di attributo quando salva l'oggetto nella tabella. ## Dinamo DBAuto GeneratedKey Contrassegna una proprietà di chiave di partizione o di ordinamento come generata automaticamente. `DynamoDBMapper` genera un [UUID](http://docs.oracle.com/javase/6/docs/api/java/util/UUID.html) casuale durante il salvataggio di questi attributi. Solo le proprietà String possono essere contrassegnate come chiavi generate automaticamente. L'esempio seguente illustra l'utilizzo delle chiavi generate automaticamente. ``` @DynamoDBTable(tableName="AutoGeneratedKeysExample") public class AutoGeneratedKeys { private String id; private String payload; @DynamoDBHashKey(attributeName = "Id") @DynamoDBAutoGeneratedKey public String getId() { return id; } public void setId(String id) { this.id = id; } @DynamoDBAttribute(attributeName="payload") public String getPayload() { return this.payload; } public void setPayload(String payload) { this.payload = payload; } public static void saveItem() { AutoGeneratedKeys obj = new AutoGeneratedKeys(); obj.setPayload("abc123"); // id field is null at this point DynamoDBMapper mapper = new DynamoDBMapper(dynamoDBClient); mapper.save(obj); System.out.println("Object was saved with id " + obj.getId()); } } ``` ## Dinamo DBAuto GeneratedTimestamp Genera automaticamente un timestamp. ``` @DynamoDBAutoGeneratedTimestamp(strategy=DynamoDBAutoGenerateStrategy.ALWAYS) public Date getLastUpdatedDate() { return lastUpdatedDate; } public void setLastUpdatedDate(Date lastUpdatedDate) { this.lastUpdatedDate = lastUpdatedDate; } ``` Facoltativamente, la strategia di generazione automatica può essere definita fornendo un attributo di strategia. Il valore predefinito è `ALWAYS`. ## Dinamo DBDocument Indica che una classe può essere serializzata come un documento di Amazon DynamoDB. Ad esempio, si supponga di voler mappare un documento JSON a un attributo DynamoDB di tipo Map (`M`). Il seguente esempio di codice definisce un item contenente un attributo nidificato (Pictures) di tipo Map. ``` public class ProductCatalogItem { private Integer id; //partition key private Pictures pictures; /* ...other attributes omitted... */ @DynamoDBHashKey(attributeName="Id") public Integer getId() { return id;} public void setId(Integer id) {this.id = id;} @DynamoDBAttribute(attributeName="Pictures") public Pictures getPictures() { return pictures;} public void setPictures(Pictures pictures) {this.pictures = pictures;} // Additional properties go here. @DynamoDBDocument public static class Pictures { private String frontView; private String rearView; private String sideView; @DynamoDBAttribute(attributeName = "FrontView") public String getFrontView() { return frontView; } public void setFrontView(String frontView) { this.frontView = frontView; } @DynamoDBAttribute(attributeName = "RearView") public String getRearView() { return rearView; } public void setRearView(String rearView) { this.rearView = rearView; } @DynamoDBAttribute(attributeName = "SideView") public String getSideView() { return sideView; } public void setSideView(String sideView) { this.sideView = sideView; } } } ``` Puoi quindi salvare un nuovo item `ProductCatalog`, con `Pictures`, come mostrato nell'esempio seguente. ``` ProductCatalogItem item = new ProductCatalogItem(); Pictures pix = new Pictures(); pix.setFrontView("http://example.com/products/123_front.jpg"); pix.setRearView("http://example.com/products/123_rear.jpg"); pix.setSideView("http://example.com/products/123_left_side.jpg"); item.setPictures(pix); item.setId(123); mapper.save(item); ``` L'aspetto dell'item `ProductCatalog` risultante dovrebbe essere simile al seguente (in formato JSON). ``` { "Id" : 123 "Pictures" : { "SideView" : "http://example.com/products/123_left_side.jpg", "RearView" : "http://example.com/products/123_rear.jpg", "FrontView" : "http://example.com/products/123_front.jpg" } } ``` ## Chiave Dynamo DBHash Mappa una proprietà di classe alla chiave di partizione della tabella. La proprietà deve essere uno dei tipi di stringa, numero o binario scalari. La proprietà non può essere un tipo di raccolta. Supponi di avere una tabella, `ProductCatalog`, che abbia come chiave primaria l'`Id`. Il seguente codice Java definisce una classe `CatalogItem` e mappa la sua proprietà `Id` alla chiave primaria della tabella `ProductCatalog` utilizzando il tag `@DynamoDBHashKey`. ``` @DynamoDBTable(tableName="ProductCatalog") public class CatalogItem { private Integer Id; @DynamoDBHashKey(attributeName="Id") public Integer getId() { return Id; } public void setId(Integer Id) { this.Id = Id; } // Additional properties go here. } ``` ## Dinamo DBIgnore Indica all'istanza `DynamoDBMapper` che la proprietà associata deve essere ignorata. Quando salvi i dati nella tabella, `DynamoDBMapper` non salva questa proprietà nella tabella. Applicato al metodo getter o al campo della classe per una proprietà non modellata. Se l'annotazione viene applicata direttamente al campo della classe, il getter e il setter corrispondenti devono essere dichiarati nella stessa classe. ## Dinamo DBIndex HashKey Mappa una proprietà di classe alla chiave di partizione di un indice secondario globale. La proprietà deve essere uno dei tipi di stringa, numero o binario scalari. La proprietà non può essere un tipo di raccolta. Utilizza questa annotazione se è necessario eseguire una `Query` su un indice secondario globale. È necessario specificare il nome dell'indice (`globalSecondaryIndexName`). Se il nome della proprietà di classe è diverso dalla chiave di partizione dell'indice, è necessario inoltre specificare il nome di tale attributo dell'indice (`attributeName`). ## Dinamo DBIndex RangeKey Associa una proprietà di classe alla chiave di ordinamento di un indice secondario globale o di un indice secondario locale. La proprietà deve essere uno dei tipi di stringa, numero o binario scalari. La proprietà non può essere un tipo di raccolta. Utilizza questa annotazione se è necessario eseguire una `Query` su un indice secondario locale o globale e si desidera rifinire i risultati utilizzando la chiave di ordinamento dell'indice. È necessario specificare il nome dell'indice (`globalSecondaryIndexName`, oppure `localSecondaryIndexName`). Se il nome della proprietà di classe è diverso dalla chiave di ordinamento dell'indice, è necessario inoltre specificare il nome di tale attributo dell'indice (`attributeName`). ## Chiave Dynamo DBRange Mappa una proprietà di classe alla chiave di ordinamento della tabella. La proprietà deve essere uno dei tipi di stringa, numero o binario scalari. Non può essere un tipo di raccolta. Se la chiave primaria è composita (chiave di partizione e chiave di ordinamento), puoi utilizzare questo tag per mappare il campo della classe alla chiave di ordinamento. Ad esempio, supponiamo che tu abbia una tabella `Reply` in cui vengono memorizzate le risposte dei thread di un forum. Ogni thread può contenere molte risposte. Pertanto, la chiave primaria di questa tabella è sia `ThreadId` sia `ReplyDateTime`. La chiave di partizione è `ThreadId` e la chiave di ordinamento è `ReplyDateTime`. Il seguente codice Java definisce una classe `Reply` e la mappa alla tabella `Reply`. Esso utilizza sia il tag `@DynamoDBHashKey` che `@DynamoDBRangeKey` per identificare le proprietà di classe che si mappano alla chiave primaria. ``` @DynamoDBTable(tableName="Reply") public class Reply { private Integer id; private String replyDateTime; @DynamoDBHashKey(attributeName="Id") public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } @DynamoDBRangeKey(attributeName="ReplyDateTime") public String getReplyDateTime() { return replyDateTime; } public void setReplyDateTime(String replyDateTime) { this.replyDateTime = replyDateTime; } // Additional properties go here. } ``` ## Dinamo DBTable Identifica la tabella di destinazione di DynamoDB. Ad esempio, il seguente codice Java definisce una classe `Developer` e la mappa alla tabella `People` in DynamoDB. ``` @DynamoDBTable(tableName="People") public class Developer { ...} ``` L'annotazione `@DynamoDBTable` può essere ereditata. Tutte le nuove classi che ereditano dalla classe `Developer` vengono pure mappate alla tabella `People`. Ad esempio, supponiamo che tu abbia creato una classe `Lead` che erediti dalla classe `Developer`. Poiché hai mappato la classe `Developer` alla tabella `People`, anche gli oggetti della classe `Lead` vengono memorizzati nella stessa tabella. `@DynamoDBTable` può anche essere sovrascritto. Tutte le nuove classi che ereditano dalla classe `Developer` vengono mappate alla stessa tabella `People` per impostazione predefinita. Tuttavia, puoi sovrascrivere questa mappatura predefinita. Ad esempio, se crei una classe che eredita dalla classe `Developer`, puoi mapparla esplicitamente a un'altra tabella aggiungendo l'annotazione `@DynamoDBTable`, come riportato nel seguente esempio di codice Java. ``` @DynamoDBTable(tableName="Managers") public class Manager extends Developer { ...} ``` ## Dinamo convertita DBType Annotazione per contrassegnare che una proprietà utilizza un convertitore di tipi personalizzato. Può essere annotata su un'annotazione definita dall'utente per passare proprietà aggiuntive a `DynamoDBTypeConverter`. L'interfaccia `DynamoDBTypeConverter` consente di mappare i propri tipi di dati arbitrari a un tipo di dati supportato in nativo da DynamoDB. Per ulteriori informazioni, consulta [Mappatura dei dati arbitrari in DynamoDB](DynamoDBMapper.ArbitraryDataMapping.md). ## Dinamo DBTyped Annotazione per sovrascrivere il vincolo del tipo di attributo standard. I tipi standard non richiedono l'annotazione se viene loro applicato il vincolo di attributo predefinito per quel tipo. ## Attributo Dynamo DBVersion Identifica una proprietà di classe per archiviare un numero di versione di blocco ottimistico. `DynamoDBMapper` assegna un numero di versione a detta proprietà quando salva un nuovo item e lo incrementa ogni volta che lo aggiorni. Sono supportati soltanto i tipi scalari di numero. Per ulteriori informazioni sui tipi di dati, consulta [Tipi di dati](HowItWorks.NamingRulesDataTypes.md#HowItWorks.DataTypes). Per ulteriori informazioni sulla funzione Controllo delle versioni, consulta [DynamoDB e blocco ottimistico con il numero di versione](DynamoDBMapper.OptimisticLocking.md). # Impostazioni di configurazione opzionali per Dynamo DBMapper Quando crei un'istanza di `DynamoDBMapper`, esso contiene determinati comportamenti predefiniti; puoi sovrascrivere tali impostazioni predefinite tramite la classe `DynamoDBMapperConfig`. Nel seguente frammento di codice viene creato un `DynamoDBMapper` con impostazioni personalizzate: ``` AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build(); DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder() .withSaveBehavior(DynamoDBMapperConfig.SaveBehavior.CLOBBER) .withConsistentReads(DynamoDBMapperConfig.ConsistentReads.CONSISTENT) .withTableNameOverride(null) .withPaginationLoadingStrategy(DynamoDBMapperConfig.PaginationLoadingStrategy.EAGER_LOADING) .build(); DynamoDBMapper mapper = new DynamoDBMapper(client, mapperConfig); ``` [Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.html) nell'API Reference.AWS SDK per Java](https://docs.aws.amazon.com/sdk-for-java/latest/reference/) Puoi utilizzare i seguenti argomenti per un'istanza di `DynamoDBMapperConfig`: + Un valore di enumerazione `DynamoDBMapperConfig.ConsistentReads`: + `EVENTUAL`: l'istanza del mappatore utilizza una richiesta di lettura a consistenza finale. + `CONSISTENT`: l'istanza del mappatore utilizza una richiesta di lettura fortemente consistente. Puoi utilizzare questa impostazione opzionale con le operazioni `load`, `query` o `scan`. Le letture fortemente consistenti hanno implicazioni per le prestazioni e la fatturazione; consulta la [pagina dei dettagli del prodotto](https://aws.amazon.com/dynamodb) di DynamoDB per ulteriori informazioni. Se non specifichi un'impostazione di consistenza di lettura per l'istanza di mappatore, il valore predefinito sarà `EVENTUAL`. **Nota** Questo valore viene applicato nelle `batch load` operazioni`query`, `querypage``load`, e di Dynamo. DBMapper + Un valore di enumerazione `DynamoDBMapperConfig.PaginationLoadingStrategy`: controlla il modo in cui l'istanza del mappatore elabora un elenco impaginato di dati, ad esempio i risultati di una `query` o una `scan`: + `LAZY_LOADING`: l'istanza del mappatore carica i dati quando possibile e mantiene tutti i risultati caricati in memoria. + `EAGER_LOADING`: l'istanza del mappatore carica i dati non appena l'elenco viene inizializzato. + `ITERATION_ONLY`: è possibile utilizzare soltantoo un Iterator per leggere dall'elenco. Durante l'iterazione, l'elenco cancella tutti i risultati precedenti prima di caricare la pagina successiva, in modo che memorizzi al massimo una pagina di risultati caricati. Ciò significa, inoltre, che l'elenco può essere iterato una sola volta. Si consiglia di utilizzare questa strategia quando si gestiscono item di grandi dimensioni, al fine di ridurre il sovraccarico della memoria. Se non specifichi una strategia di caricamento della paginazione per l'istanza di mappatore, il valore predefinito sarà `LAZY_LOADING`. + Un valore di enumerazione `DynamoDBMapperConfig.SaveBehavior`. Specifica il modo in cui l'istanza di mappatore deve gestire gli attributi durante le operazioni di salvataggio. + `UPDATE`: durante un'operazione di salvataggio, tutti gli attributi modellati vengono aggiornati e gli attributi non modellati non vengono influenzati. Tipi di numeri primitivi (byte, int, long) sono impostati su 0. I tipi di oggetto sono impostati su null. + `CLOBBER`: cancella e sostituisce tutti gli attributi, inclusi quelli non modellati, durante un'operazione di salvataggio. Questa operazione viene eseguita eliminando la voce e creandola nuovamente. Vengono ignorate anche le limitazioni dei campi con versione. Se non specifichi il comportamento di salvataggio per l'istanza di mappatore, il valore predefinito sarà `UPDATE`. **Nota** Le DBMapper operazioni transazionali di Dynamo non supportano l'enumerazione. `DynamoDBMapperConfig.SaveBehavior` + Un oggetto `DynamoDBMapperConfig.TableNameOverride`: indica all'istanza del mappatore di ignorare il nome della tabella specificato dall'annotazione `DynamoDBTable` della classe e utilizza invece un nome di tabella diverso fornito dall'utente. Ciò può essere utile quando esegui il partizionamento dei dati in più tabelle in fase di runtime. Puoi sovrascrivere l'oggetto della configurazione predefinita per `DynamoDBMapper` in ogni operazione, a seconda delle necessità. # DynamoDB e blocco ottimistico con il numero di versione Il *blocco ottimistico* è una strategia che assicura che l'elemento lato client che si sta aggiornando (o eliminando) sia lo stesso elemento in Amazon DynamoDB. Se utilizzi questa strategia le scritture del tuo database sono protette da eventuali sovrascritture da parte di altre scritture di terzi e viceversa. Con il blocco ottimistico, ogni voce dispone di un attributo che funge da numero di versione. Se recuperi un item da una tabella, l'applicazione registra il numero di versione di tale item. Puoi aggiornare l'item, ma solo se il numero di versione lato server non è cambiato. In caso di mancata corrispondenza delle versioni, qualcun altro ha modificato l'item prima dell'utente. Il tentativo di aggiornamento non riesce, perché si dispone di una versione obsoleta dell'item. Se ciò accade, semplicemente riprova a recuperare l’elemento e tenta di aggiornarlo. Il blocco ottimistico evita di sovrascrivere accidentalmente le modifiche che sono state apportate da altri. Impedisce anche ad altri di sovrascrivere accidentalmente le modifiche. Sebbene tu possa implementare la tua strategia di blocco ottimistica, fornisce l'annotazione. AWS SDK per Java `@DynamoDBVersionAttribute` Nella classe di mappatura della tabella, puoi indicare una proprietà nella quale memorizzare il numero di versione e contrassegnarlo utilizzando questa annotazione. Quando si salva un oggetto, l'elemento corrispondente nella tabella DynamoDB conterrà un attributo che memorizza il numero di versione. `DynamoDBMapper` assegna un numero di versione quando salvi l'oggetto per la prima volta e incrementa automaticamente il numero di versione ogni volta che aggiorni l'item. Le richieste di aggiornamento o eliminazione avranno esito positivo solo se la versione dell'oggetto lato client corrisponde al numero di versione dell'elemento corrispondente nella tabella DynamoDB. `ConditionalCheckFailedException` viene generato se: + utilizzi il blocco ottimistico con `@DynamoDBVersionAttribute` e il valore della versione del server è diverso dal valore sul lato client; + specifichi le tue limitazioni condizionali quando salvi i dati utilizzando `DynamoDBMapper` con `DynamoDBSaveExpression` e tali limitazioni non sono riuscite. **Nota** Le tabelle globali DynamoDB utilizzano una riconciliazione di tipo "last writer wins" per aggiornamenti contestuali. Se utilizzi le tabelle globali, vince la policy "last writer". Pertanto in questo caso la strategia di blocco non funziona come previsto. Le operazioni di scrittura transazionali `DynamoDBMapper` non supportano l'annotazione e le espressioni di condizione `@DynamoDBVersionAttribute` all'interno dello stesso oggetto. Se un oggetto all'interno di una scrittura transazionale viene annotato con `@DynamoDBVersionAttribute` e ha anche un'espressione condizionale, verrà generata una. SdkClientException Ad esempio, nel seguente codice Java si definisce una classe `CatalogItem` che possiede diverse proprietà. La proprietà `Version` viene etichettata con l'annotazione `@DynamoDBVersionAttribute`. **Example** ``` @DynamoDBTable(tableName="ProductCatalog") public class CatalogItem { private Integer id; private String title; private String ISBN; private Set bookAuthors; private String someProp; private Long version; @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;} @DynamoDBVersionAttribute public Long getVersion() { return version; } public void setVersion(Long version) { this.version = version;} } ``` Puoi applicare l'annotazione `@DynamoDBVersionAttribute` ai tipi nullable disponibili nelle classi wrapper primitive che forniscono un tipo nullable, come `Long` e `Integer`. Il blocco ottimistico ha il seguente impatto su questi metodi `DynamoDBMapper`: + `save`: per un nuovo elemento, il `DynamoDBMapper` assegna il numero di versione iniziale uguale a 1. Se recuperi un item, aggiorni una o più delle sue proprietà e tenti di salvare le modifiche, l'operazione di salvataggio ha esito positivo solo se il numero di versione sul lato client e sul lato server corrispondono. `DynamoDBMapper` incrementa il numero di versione in modo automatico. + `delete`: il metodo `delete` utilizza un oggetto come parametro e `DynamoDBMapper` esegue un controllo della versione prima di eliminare l'elemento. La verifica della versione può essere disabilitata se nella richiesta viene specificato `DynamoDBMapperConfig.SaveBehavior.CLOBBER`. L'implementazione interna del blocco ottimistico in `DynamoDBMapper` utilizza il supporto degli aggiornamenti e delle eliminazioni condizionali fornite da DynamoDB. + `transactionWrite` — + `Put`: per un nuovo elemento, il `DynamoDBMapper` assegna il numero di versione iniziale uguale a 1. Se recuperi un item, aggiorni una o più delle sue proprietà e tenti di salvare le modifiche, l'operazione put ha esito positivo solo se il numero di versione sul lato client e sul lato server corrispondono. `DynamoDBMapper` incrementa il numero di versione in modo automatico. + `Update`: per un nuovo elemento, il `DynamoDBMapper` assegna il numero di versione iniziale uguale a 1. Se recuperi un item, aggiorni una o più delle sue proprietà e tenti di salvare le modifiche, l'operazione update ha esito positivo solo se il numero di versione sul lato client e sul lato server corrispondono. `DynamoDBMapper` incrementa il numero di versione in modo automatico. + `Delete`: `DynamoDBMapper` esegue un controllo della versione prima di eliminare l'elemento. L'operazione delete riesce solo se il numero di versione sul lato client e sul lato server corrispondono. + `ConditionCheck`: l'annotazione `@DynamoDBVersionAttribute` non è supportata per le operazioni `ConditionCheck`. SdkClientException Verrà generato un elemento quando un `ConditionCheck` elemento viene annotato con. `@DynamoDBVersionAttribute` ## Disabilitazione del blocco ottimistico Per disabilitare il blocco ottimistico, puoi modificare il valore di enumerazione `DynamoDBMapperConfig.SaveBehavior` da `UPDATE` in `CLOBBER`. Puoi farlo creando un'istanza `DynamoDBMapperConfig` che non esegua la verifica della versione e utilizzi tale istanza per tutte le richieste. Per informazioni sui parametri `DynamoDBMapperConfig.SaveBehavior` e altri parametri opzionali `DynamoDBMapper`, consulta [Impostazioni di configurazione opzionali per Dynamo DBMapper](DynamoDBMapper.OptionalConfig.md). Inoltre puoi impostare il comportamento di blocco per una sola operazione specifica. Ad esempio, nel seguente frammento di codice Java si utilizza `DynamoDBMapper` per salvare un item del catalogo. Specifica `DynamoDBMapperConfig.SaveBehavior` aggiungendo il parametro opzionale `DynamoDBMapperConfig` al metodo `save`. **Nota** Il metodo TransactionWrite non supporta Dynamo Config. DBMapper SaveBehaviorconfigurazione. Disabilitazione del blocco ottimistico per transactionWrite non supportata. **Example** ``` DynamoDBMapper mapper = new DynamoDBMapper(client); // Load a catalog item. CatalogItem item = mapper.load(CatalogItem.class, 101); item.setTitle("This is a new title for the item"); ... // Save the item. mapper.save(item, new DynamoDBMapperConfig( DynamoDBMapperConfig.SaveBehavior.CLOBBER)); ``` # Mappatura dei dati arbitrari in DynamoDB Oltre ai tipi Java supportati (vedere [Tipi di dati supportati per Dynamo for Java DBMapper](DynamoDBMapper.DataTypes.md)), è possibile utilizzare i tipi dell'applicazione per i quali non vi è una mappatura diretta ai tipi di Amazon DynamoDB. Per mappare questi tipi, è necessario fornire un'implementazione che converta il tipo complesso in un tipo supportato DynamoDB e viceversa; è inoltre necessario annotare il metodo di accesso del tipo complesso utilizzando l'annotazione `@DynamoDBTypeConverted`. Il codice del convertitore trasforma i dati quando gli oggetti vengono salvati o caricati. Viene utilizzato anche per tutte le operazioni che utilizzano tipi complessi. Quando si confrontano i dati durante le operazioni di query e di scansione, i confronti vengono fatti sui dati archiviati in DynamoDB. Ad esempio, considera la seguente classe `CatalogItem`, che definisce una proprietà, `Dimension`, che è `DimensionType`. Questa proprietà archivia le dimensioni dell'item, quali altezza, larghezza e spessore. Supponiamo che si decida di memorizzare queste dimensioni dell'elemento come una stringa (ad esempio 8,5x11x0,5) in DynamoDB. Nell'esempio seguente viene fornito il codice del convertitore, il quale converte l'oggetto `DimensionType` in una stringa e una stringa in `DimensionType`. **Nota** In questo esempio di codice si presuppone che siano già stati caricati dati in DynamoDB per l'account seguendo le istruzioni riportate nella sezione [Creazione di tabelle e caricamento di dati per esempi di codice in DynamoDB](SampleData.md). Per step-by-step istruzioni su come eseguire il seguente esempio, consulta. [Esempi di codice Java](CodeSamples.Java.md) **Example** ``` public class DynamoDBMapperExample { static AmazonDynamoDB client; public static void main(String[] args) throws IOException { // Set the AWS region you want to access. Regions usWest2 = Regions.US_WEST_2; client = AmazonDynamoDBClientBuilder.standard().withRegion(usWest2).build(); DimensionType dimType = new DimensionType(); dimType.setHeight("8.00"); dimType.setLength("11.0"); dimType.setThickness("1.0"); Book book = new Book(); book.setId(502); book.setTitle("Book 502"); book.setISBN("555-5555555555"); book.setBookAuthors(new HashSet(Arrays.asList("Author1", "Author2"))); book.setDimensions(dimType); DynamoDBMapper mapper = new DynamoDBMapper(client); mapper.save(book); Book bookRetrieved = mapper.load(Book.class, 502); System.out.println("Book info: " + "\n" + bookRetrieved); bookRetrieved.getDimensions().setHeight("9.0"); bookRetrieved.getDimensions().setLength("12.0"); bookRetrieved.getDimensions().setThickness("2.0"); mapper.save(bookRetrieved); bookRetrieved = mapper.load(Book.class, 502); System.out.println("Updated book info: " + "\n" + bookRetrieved); } @DynamoDBTable(tableName = "ProductCatalog") public static class Book { private int id; private String title; private String ISBN; private Set bookAuthors; private DimensionType dimensionType; // Partition key @DynamoDBHashKey(attributeName = "Id") public int getId() { return id; } public void setId(int 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; } @DynamoDBTypeConverted(converter = DimensionTypeConverter.class) @DynamoDBAttribute(attributeName = "Dimensions") public DimensionType getDimensions() { return dimensionType; } @DynamoDBAttribute(attributeName = "Dimensions") public void setDimensions(DimensionType dimensionType) { this.dimensionType = dimensionType; } @Override public String toString() { return "Book [ISBN=" + ISBN + ", bookAuthors=" + bookAuthors + ", dimensionType= " + dimensionType.getHeight() + " X " + dimensionType.getLength() + " X " + dimensionType.getThickness() + ", Id=" + id + ", Title=" + title + "]"; } } static public class DimensionType { private String length; private String height; private String thickness; public String getLength() { return length; } public void setLength(String length) { this.length = length; } public String getHeight() { return height; } public void setHeight(String height) { this.height = height; } public String getThickness() { return thickness; } public void setThickness(String thickness) { this.thickness = thickness; } } // Converts the complex type DimensionType to a string and vice-versa. static public class DimensionTypeConverter implements DynamoDBTypeConverter { @Override public String convert(DimensionType object) { DimensionType itemDimensions = (DimensionType) object; String dimension = null; try { if (itemDimensions != null) { dimension = String.format("%s x %s x %s", itemDimensions.getLength(), itemDimensions.getHeight(), itemDimensions.getThickness()); } } catch (Exception e) { e.printStackTrace(); } return dimension; } @Override public DimensionType unconvert(String s) { DimensionType itemDimension = new DimensionType(); try { if (s != null && s.length() != 0) { String[] data = s.split("x"); itemDimension.setLength(data[0].trim()); itemDimension.setHeight(data[1].trim()); itemDimension.setThickness(data[2].trim()); } } catch (Exception e) { e.printStackTrace(); } return itemDimension; } } } ``` # Esempi della classe DynamoDBMapper L’SDK AWS per Java fornisce una classe `DynamoDBMapper` che consente di mappare le classi lato client alle tabelle 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. Per ulteriori informazioni sull’utilizzo di `DynamoDBMapper`, consulta [DynamoDB Examples Using the AWS SDK for Java ](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/examples-dynamodb.html) nella *Guida per gli sviluppatori di SDK AWS per Java 1.x*.