Cloud Computing Anbietervergleich

das Gästebuch
    Da man nun die Entitäten hat, muss auch noch eine Klasse erstellt werden, welche die Interaktion mit den Entitäten erlaubt. Hierfür wird ein PersistenceManager erstellt, der vorzugsweise als Singleton realisiert wird, da Interaktionen mit dem Datenspeicher intensiv sind. Dank des Singletons wird die Verbindung mit dem PersistenceManager nur einmal während des Starts der Anwendung geladen, und zwar, wenn ein Benutzer die Seite öffnet. Der PersistenceManager selbst wird aus der PersistenceManagerFactory erstellt. Wie das funktioniert, ist in Listing 1.18 dargestellt.
    package com.mmh.cloud.gae.data;

import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManagerFactory;

public class GuestbookManager
{
private static final PersistenceManagerFactory pmfInstance =
JDOHelper.getPersistenceManagerFactory("transactions-optional");

private GuestbookManager() {}

public static PersistenceManagerFactory get() {
return pmfInstance;
}
}
    Listing 1.18: Der Persistence Manager für die Entitäten
    In der Anwendung ist nun bereits einiges möglich. Es fehlt jedoch noch an Entitäten, damit ein erster Testlauf beginnen kann. Entitäten können über den PersistenceManager mit der Methode makePersistent persistiert werden. Hierfür muss lediglich eine Entität erstellt und an die Methode makePersistent übergeben werden ( Listing 1.19 ).
    PersistenceManager perm = GuestbookManager.get().getPersistenceManager();
GuestbookEntity entry = new GuestbookEntity();

entry.setAuthor("Mario Meir-Huber");
entry.setDatetime(Calendar.getInstance().getTime());
entry.setEmail("[email protected]");
entry.setMessage("Because Quality Matters");

try
{
perm.makePersistent(entry);
}
catch(Exception ex)
{
}
    Listing 1.19: Erstellen von neuen Entitäten
    Jetzt fehlt nur noch die Möglichkeit, Daten abzufragen. Hierfür bietet JDO eine eigene Abfragesprache, die sich „JDOQL“ (Java Data Objects Query Language) nennt. Als „Tabelle“ wird der Name der Entitätenklasse innerhalb des SQL Statements verwendet. Eine Abfrage wird schlussendlich mit der execute() -Funktion des PersistenceManagers abgesetzt. Hierbei wird eine Liste vom jeweiligen Typen zurückgeliefert, im Beispiel wäre das die Entität für den Gästebucheintrag ( Listing 1.20 ).
    String query = "select from " + GuestbookEntity.class.getName();
List entries = (List)
perm.newQuery(query).execute();
    Listing 1.20: Gästebucheintrag einfügen
    Der Datenspeicher für das Gästebuch ist nun komplett. Damit das auch nachvollziehbar ist, soll in einem vom Assistent erstellten Servlet eine einfache Ausgabe erfolgen ( Listing 1.21 ).
    PrintWriter pw = resp.getWriter();

if(!entries.isEmpty())
{
for(GuestbookEntity e : entries)
{
pw.println(e.getAuthor() + " said: " + e.getMessage() +" on " + e.getDatetime().toString());
}
}
    Listing 1.21: Gästebucheintrag ausgeben
    Die Möglichkeiten, die Java bietet, sind jedoch noch wesentlich umfangreicher. Mithilfe von Java Server Pages kann man die Ausgabe auch wesentlich eleganter gestalten. Das geht jedoch bereits in die Tiefen von Java und dürfte für erfahrene Java-Entwickler kaum ein Problem darstellen.
    Blob Storage
    Will man Daten speichern, die größer als die maximal erlaubte Größe für Daten im Datenspeicher sind, besteht die Möglichkeit, Blobs zu verwenden. Für Blobs gibt es das Blobstore Java API. Google App Engine Blobs können bis zu 50 MB groß sein und werden typischerweise über einen Form POST oder HTTP POST erstellt. Wird ein Form POST oder ein anderer HTTP POST aufgerufen, erstellt der Blobstore Service den Blob. Der Service liefert einen Blob Key zurück, der als Adresse bzw. Identifier des Blobs dient.
    Blobs, die bereits erstellt wurden, können nicht mehr verändert, nur noch gelöscht werden. Somit kann man das Problem der nicht veränderbaren Blobs durch neues Erstellen – wenn auch unelegant – umgehen. Eine Anwendung kann eine Partition eines Blobs pro API-Aufruf lesen, was etwa einem Megabyte entspricht.
    Tasks
    Da einige Anwendungen komplexere Berechnungen benötigen, kann man mit Googles App Engine auf Tasks zugreifen. Diese laufen in anderen Threads und werden asynchron abgearbeitet. Das kann, wenn man der Anwendung eine ordentliche Architektur verpasst, positive Auswirkungen auf die Geschwindigkeit haben.
    Mögliche Anwendungsfälle von Tasks sind etwa das Versenden von E-Mails an viele Teilnehmer. Hat man eine große Anwendung, die pro Sekunde eine große