Java e Windows Azure Table Storage

Nello scorso appuntamento abbiamo realizzato una semplice applicazione che sfrutta lo storage sul cloud offerto da Windows Azure per permettere l'upload di alcune foto in modo da averle sempre disponibili online. Abbiamo analizzato ed utilizzato i servizi del Blob Storage per memorizzare file ed immagini, ora aggiungeremo la possibilità per gli utenti di lasciare un commento sfruttando il Windows Azure Table Storage.

Le Table consentono di memorizzare entità all'interno di tabelle non relazionali, assomigliando quindi più ad un modello NoSQL che ad un database tradizionale. All'interno di una Table, le righe sono identificate univocamente attraverso una coppia di valori, chiamati Partition Key e Row Key.

Tutti i dati sono sempre accessibili tramite chiamate REST al servizio, con URL simili a questo:

http://myaccountname.table.core.windows.net

)

utilizzando qualunque linguaggio e piattaforma di sviluppo che sia in grado di effettuare chiamate HTTP.

AzureComments

Per realizzare questa applicazione sfrutteremo il Cloud Storage Account creato nella lezione precedente. Anche per maggiori informazioni sulla creazione di un Account, si può fare riferimento all'articolo precedente.

Come già accennato, vogliamo realizzare una semplice applicazione che ci permette di testare l'utilizzo dello storage di Windows Azure permettendo all'utente di lasciare dei commenti, che verranno memorizzati sotto forma di entità all'interno del Table Storage.

Per prima cosa apriamo Eclipse e creiamo un nuovo progetto, avendo cura di aggiungere al build path tutte le librerie necessarie (i link da cui scaricarle e le istruzioni aggiuntive sono presenti nello scorso articolo in questa serie).

Aggiungiamo quindi alla cartella "src" una nuova Java Class di nome "AzureStorage", e cominciamo con l'aggiungere gli import necessari al nostro codice:

import java.io.*;
import java.util.UUID;
import com.microsoft.windowsazure.services.core.storage.*;
import com.microsoft.windowsazure.services.table.client.*;

Le prime due librerie ci serviranno per gestire l'input e i file, e per generare RowKey univoci nel Table storage, mentre le ultime due permettono di utilizzare alcune API ad alto livello per interagire con i servizi di storage di Windows Azure.

Subito dopo la riga di inizio della classe mostrata qui di seguito:

public class AzureStorage {

aggiungiamo una riga di codice che definisca una stringa di connessione verso lo storage nel cloud di Windows Azure:

public static final String storageConnectionString =  "DefaultEndpointsProtocol=https; AccountName=my_account_name; AccountKey=my_account_key";

In questa stringa sono presenti due "segnaposti" da sostituire con i propri valori reali, che sono:

• my_account_name: il nome dell'account di Storage nel quale vogliamo andare ad inserire le foto che caricheremo: è il nome che abbiamo scelto al momento della creazione dell'account sul portale di gestione di Windows Azure, nel mio caso è "azurephotos"
• my_account_key: la chiave di accesso per l'utilizzo di questo storage account, che si può trovare sempre nel portale di gestione selezionando l'account e premendo il tasto "Visualizza" in alto a destra come indicato precedentemente

Creare la classe dell'entità da persistere

All'interno del Table Storage di Windows Azure è possibile persistere delle "entità", rappresentate in Java come dei comuni oggetti. Creiamo perciò una classe Comment che rappresenterà il tipo di oggetto che vogliamo persistere sulla nuvola.

Le classi da persistere sul Table Storage devono implementare l'interfaccia TableEntity. La libreria Java per Azure ci mette a disposizione una classe base, chiamata TableServiceEntity, che implementa già questa interfaccia ed è perciò già provvista delle proprietà comuni fondamentali di ogni entity che si voglia persistere sul Cloud, come ad esempio partition key, row key e timestamp.

All'interno della nuova classe inseriamo il seguente codice:

import com.microsoft.windowsazure.services.table.client.TableServiceEntity;
public class Comment extends TableServiceEntity {
	private String name;
	private String text;
	public Comment(String partitionKey, String rowKey) {
		this.partitionKey = partitionKey;
		this.rowKey = rowKey;
	}
	public Comment() {
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getText() {
		return text;
	}
	public void setText(String text) {
		this.text = text;
	}
}

Questa semplice classe ha due proprietà, il nome dell'autore del commento e il suo contenuto, e possiede un costruttore che prende come parametri la coppia di chiavi PartitionKey e RowKey.

Aggiungere entità al Table Storage

Scriviamo innanzitutto qualche riga di codice che ci permetta di aggiungere righe ad una tabella nel Table Storage.

Per effettuare operazioni sulle table è necessario utilizzare un oggetto TableOperation, che definisce quali operazioni effettuare e su quali entità.

Torniamo alla classe AzureStorage e aggiungiamo del codice nel corpo del metodo main():

try
{
    CloudTableClient tableClient = CloudStorageAccount.parse(storageConnectionString).createCloudTableClient();
    tableClient.createTableIfNotExists("commenti");
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    System.out.println("Inserisci il tuo nome:");
    String name = br.readLine();
    System.out.println("Inserisci il tuo commento:");
    String text = br.readLine();
    Comment comment = new Comment("A", UUID.randomUUID().toString());
    comment.setName(name);
    comment.setText(text);
    TableOperation insert = TableOperation.insert(comment);
    tableClient.execute("commenti", insert);
    System.out.println("Grazie e arrivederci!");
}
catch (Exception e)
{
    System.out.println(e.getMessage());
    System.exit(-1);
}

Analizziamolo brevemente:

• il codice è nel blocco try..catch gestire le eccezioni;
• anzitutto otteniamo un oggetto CloudTableClient per l'accesso al Table Storage, attraverso la stringa di connessione definita in cima alla classe;
• col metodo createTableIfNotExists ci assicuriamo di creare la table per memorizzare i commenti;
• chiediamo quindi all'utente di immettere il suo nome e il suo commento, e inizializziamo un nuovo oggetto Comment con questi dati;
• creiamo un nuovo oggetto TableOperation che effettui l'inserimento della nuova riga nella tabella dei commenti, quindi lanciamo l'operazione attraverso il tableClient specificando il nome della tabella interessata.

Leggere righe dal Table Storage

Per effettuare query sulle righe presenti nelle tabelle del Table Storage di Windows Azure è possibile fare uso dell'oggetto TableQuery.

Vogliamo stampare tutti i commenti disponibili prima di terminare l'applicazione ogni volta che viene lanciata. Per farlo, andiamo ad aggiungere del codice subito sopra la riga che stampa i saluti, mostrata qui di seguito:

System.out.println("Grazie e arrivederci!");
inserendo questo frammento:
System.out.println("Ecco tutti i commenti:");

TableQuery<Comment> query = TableQuery.from("commenti ", Comment.class);
for (Comment entity : tableClient.execute(query))
    System.out.println("[" + entity.getRowKey() + "] " + entity.getName() + ": " + entity.getText());

Come sempre commentiamo brevemente il codice:

• creiamo un nuovo oggetto TableQuery specificando come tabella di riferimento quella di nome "commenti" e come entità di riferimento la classe Comment;
• scorriamo l'elenco di entità ottenute dall'esecuzione di questa query e stampiamo per ogni commento la RowKey, il nome dell'autore ed il suo commento;

L'applicazione completa, lanciata nella console integrata di Eclipse, apparirà quindi in modo simile alla figura qui di seguito:

Figura 18. (clic per ingrandire)

Da notare che è possibile in modo molto semplice anche effettuare query più complesse. Per esempio, sarebbe possibile filtrare le righe in base al nome dell'autore con pochissime righe di codice: utilizziamo i metodi dell'oggetto TableQuery per farci aiutare a generare la stringa di filtraggio per la query, quindi "agganciamola" alla query più generica tramite il metodo where().

String filter = TableQuery.generateFilterCondition("Name", QueryComparisons.EQUAL, "Daniele MIDI");
TableQuery<Comment> query = TableQuery.from("commenti", Comment.class).where(filter);

E quindi lanciando la query e scorrendo i risultati in modo del tutto identico a quanto fatto nel precedente spezzone di codice.