Java 1.x: D ynamoDBMapper

AWS SDK for 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 DynamoDBMapper classe consente di eseguire varie operazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD) sugli elementi ed eseguire query e scansioni su tabelle.

The SDK for Java fornisce una serie di tipi di annotazioni che consentono di 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 semplice oggetto Java (POJO) denominatoCatalogItem, che utilizza le annotazioni per mappare i campi degli oggetti ai nomi degli attributi di DynamoDB.

package com.amazonaws.codesamples;

import java.util.Set;

import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBAttribute;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBHashKey;
import com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBIgnore;
import com.amazonaws.services.dynamodbv2.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'@DynamoDBAttributeannotazione viene aggiunta a ciascuna proprietà per garantire che i nomi delle proprietà corrispondano esattamente alle tabelle create in un passaggio precedente e per essere coerenti con i nomi degli attributi utilizzati in altri esempi di codice di 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 funzionalità integrate, come il blocco ottimistico, ACID le transazioni, i valori delle chiavi di partizione e di ordinamento generati automaticamente e il controllo delle versioni degli oggetti.