Nachdem ich mich in meiner Master-Thesis mit Cloud Computing und JEE befassen werde, habe ich heute meine ersten Versuche mit der Google App Engine unternommen, die ja seit einigen Monaten auch Java unterstützt und unlängst in Version 1.3.0 veröffentlicht wurde.

Dabei habe ich versucht eine einfache JSF 2.0 Webanwendung für die Google App Engine mit NetBeans 6.8 (wegen dem tollen JSF 2.0 Support) zu implementieren. Da das offzielle Tutorial leider nach der Einrichtung des NetBeans-Plugins abbricht, möchte ich an dieser Stelle ein vollständiges Konfigurations- und Implementierungsbeispiel sowie das abschließende Deployment in die Google App Engine aufzeigen.

1. Einrichten der Entwicklungsumgebung
Um die Google App Engine nutzen zu können, muss man sich natürlich zuerst für einen Account registrieren. Für das JSF 2.0 Beispiel wird außerdem folgende Software benötigt:

• Java SE Development Kit (JDK) 1.6
• Google App Engine SDK 1.3.0 für Java
• Apache Xalan-J 2.9.0
• Unified Expression Language 1.1 API und Implementation
• Netbeans 6.8 (mit “Java Web and EE”)

1.1. Google App Engine Plugin für NetBeans: Nachdem NetBeans installiert wurde, wird zunächst das Google App Engine Plugin über “Tools > Plugins” installiert. Im Tab “Settings” wird dazu ein neues Update Center mit einem passendem Namen (z.B. “Google App Engine Plugin”) und folgender URL angelegt: http://kenai.com/projects/nbappengine/downloads/download/Latest_NetBeans68/updates.xml. Anschließend können im Tab “Available Plugins” alle verfügbaren Google App Engine Plugins ausgewählt und installiert werden. Nach erfolgreicher Installation sollte das Plugin im Tab “Installed” zu sehen sein.

1.2. Google App Engine Server in NetBeans: Nun kann über “Tools > Server” Google App Engine als Server hinzugefügt werden, wobei das Installationsverzeichnis des Google App Engine SDK 1.3.0 angegeben werden muss. Außerdem kann im Tab “Javadoc” auf das Javadoc Verzeichnis ([GoogleAppEngineSDK]/docs/javadoc) verwiesen werden.

1.3. Google App Engine Library in NetBeans: Da der Google App Engine Server die für den Betrieb von JSF 2.0 Webanwendungen notwendigen Libraries nicht mitbringt, muss in NetBeans über “Tools > Libraries” eine neue Library erstellt werden, die dann der Webanwendung (und somit dem WAR-Archiv) hinzugefügt werden kann. Als “Library Name” kann z.B. “GoogleAppEngine_JSF20″ eingegeben werden und bei “Library Type” wird “Class Libraries” ausgewählt. Dieser Library werden dann folgende JARs hinzugefügt: Apache Xalan-J (serializer.jar, xalan.jar, xercesImpl.jar, xml-apis.jar, xsltc.jar) und Unified Expression Language (el-api-1.1.jar, el-impl-1.1.jar).

Damit ist die Konfiguration von NetBeans für die Google App Engine erfolgreich abgeschlossen. ;-)

2. Implementierung der JSF 2.0 Webanwendung
Nun kann die eigentliche Webanwendung mit JSF 2.0 und Google App Engine Support implementiert werden.

2.1 JSF Webanwendung für Google App Engine erstellen: Durch “File > New Project…” und der Kategorie “Java Web” und “Web Application” wird der Wizard zum Erstellen einer JEE Webanwendung aufgerufen und ein passender Projektname (z.B. “GoogleAppEngine_JSF20″) vergeben. Anschließend wird als Server “Google App Engine” ausgewählt und als “ContextPath” nur “/” eingetragen.

Im nächsten Schritt wird als Framework “JavaServer Faces” und “JSF 2.0″ ausgewählt. Nachdem das Projekt erstellt wurde, wird durch einen Rechtsklick auf “Libraries” und “Add Library…” die oben erstellte Google App Engine Library dem Projekt hinzugefügt.

2.2 JSF Webanwendung für Google App Engine konfigurieren: Leider gibt es zwischen der aktuellen JSF 2.0 und Google App Engine 1.3.0 noch einige Kompatibilitätsprobleme, welche aber durch Konfigurationseinstellungen relativ einfach behoben werden können. Die dazu erforderlichen Konfigurationsdateien sind im Projekt in NetBeans unter “Configuration Files” zu finden.

In der Datei “web.xml” müssen dazu folgende Zeilen hinzugefügt werden:
<!-- Google App Engine Bug 1506 JSP 2.1 API but 2.0 Implementation -->
<context-param>
  <param-name>com.sun.faces.expressionFactory</param-name>
  <param-value>com.sun.el.ExpressionFactoryImpl</param-value>
</context-param>
<!-- Google App Engine 1.3.0 appears to handle server-side state saving -->
<context-param>
  <param-name>javax.faces.STATE_SAVING_METHOD</param-name>
  <param-value>server</param-value>
</context-param>
<!-- Accommodate Single-Threaded Requirement of Google App Engine -->
<context-param>
  <param-name>com.sun.faces.enableThreading</param-name>
  <param-value>false</param-value>
</context-param>


Die Datei “appengine-web.xml” wird um folgenden Eintrag erweitert:
<!-- Activate Session Support in Google App Engine -->
<sessions-enabled>true</sessions-enabled>

Etwas problematischer ist die Tatsache, dass Anwendungen innerhalb der Google App Engine nur der Zugriff auf bestimmte Klassen der Java Standard Library erlaubt ist. Eine JSF 2.0 Webanwendung testet allerdings beim Start, ob es einen InitalContext aufbauen kann und ruft dazu diese Klasse auf, was dann zu einer Exception innerhalb der Google App Engine führt. Um dies zu verhindern muss die JSF 2.0 Implementierung gepachted werden. Dazu wird im Projekt in Netbeans über einen Rechtsklick auf das Projekt und “New > Java Package” bzw. “New > Java Class” das Package “com.sun.faces.config” und darin eine Klasse mit den Namen “WebConfiguration” und dem Inhalt dieses Links erstellt. Dadurch wird die Implementierung in der jsf-impl.jar durch die gepachte Version überschrieben.

2.3 JSF Webanwendung implementieren:
JSF 2.0 bietet mit der neuen Annotation @ManagedBean die Möglichkeit, eine Klasse direkt als Managed Bean zu deklarieren. Die (umständliche) Konfiguration in einer faces-config.xml wie bei JSF 1.2 ist damit nicht mehr notwendig. Die folgende Klasse zeigt beispielhaft die Verwendung der Annotation:

package de.alteskind.appengine.jsf;
 
import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
 
@ManagedBean(name = "HelloWorld")
@RequestScoped
public class HelloWorld {
 
 private String message;
 
 public HelloWorld() {
  this.message = "Hello World from JSF 2.0/Facelets"
   + "on Google App Engine!";
 }
 
 public String getMessage() {
  return message;
 }
}

In der Datei index.xhtml kann nun im Body auf die Managed Bean zugegriffen werden. NetBeans bietet dabei Code Completion, d.h. es werden automatisch alle öffentlichen Methoden und Variablen der Managed Bean angeboten. Um die “message” der Managed Bean “HelloWorld” auszugeben, kann z.B. der Tag <h:outputText /> verwendet werden:

<h:outputText value="#{HelloWorld.message}" />

3.0 Deployment in Google App Engine
Sowohl das Lokale Deployment als auch das Remote Deployment erfolgt durch das Google App Engine Plugin komfortabel direkt aus NetBeans heraus.

3.1 Lokales Deployment in Google App Engine
Das lokale Deployment wird in NetBeans durch einen Rechtsklick auf das Projekt und die Auswahl von “Run” gestartet. Nach dem Deployment wird automatisch ein Browser mit der Webanwendung geöffnet.

3.1 Remote Deployment in Google App Engine
Um die Anwendung in der tatsächlichen Google App Engine zu veröffentlichen, muss zunächst über die Weboberfläche der Google App Engine eine Anwendung mit eindeutigem Namen erstellt werden. Dieser Name muss mit dem Namen im “application” Tag das appengine-web.xml übereinstimmen. Das eigentliche Deployment erfolgt dann mit einem rechten Mausklick auf das Projekt und der Auswahl “Deploy To Google App Engine”.

Damit wurde die JSF 2.0 Webanwendung erfolgreich in der Google App Engine veröffentlicht. :-)

Das komplette NetBeans Projekt inkl. WAR-Archiv kann hier heruntergeladen sowie unter http://1.latest.altes-kind.appspot.com/ direkt aufgerufen werden.