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
<a name="DynamoDBMapper"></a>

**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<String> 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<String> getBookAuthors() { return bookAuthors; }
    public void setBookAuthors(Set<String> 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<String>(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<CatalogItem> queryExpression = new DynamoDBQueryExpression<CatalogItem>()
    .withHashKeyValues(partitionKey);

List<CatalogItem> 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.