Java 1.x: DynamoDBMapper

AWS SDK per Java fornisce una classe DynamoDBMapper 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.

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.

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.