Homepage email me grab rss 2.0 feed

JSF 2.0 mit NetBeans 6.8 und Google App Engine

Google App EngineNachdem 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.

NetBeansDabei 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:

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.

Installation des Google App Engine Plugins für NetBeans
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.

Javadoc Verzeichnis zur Google App Engine Server Konfiguration hinzufügen
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).

Erstellen einer Library für Google App Engine in NetBeans
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.

Server Einstellungen beim Erstellen des Projektes
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.

Überschreiben der JSF 2.0 WebConfiguration Klasse um den Zugriff auf InitialContext zu unterbinden

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.

Ausführen der JSF 2.0 Webanwendung auf dem lokalen Google App Engine Server
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”.

Erstellen der Anwendung über die Google App Engine Weboberfläche
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.

2 Kommentare

  1. #1 Matthias Wessendorf - http://matthiaswessendorf.wordpress.com

    Nice introduction. Every tried MyFaces 2.0 ?

  2. #2 Peter

    Hallo Mathias!

    Ich beginne auch gerade mit einer Master-Arbeit an der Fernuni Hagen. Allerdings kommt bei mir der GlassFish-Server zum Einsatz und meine Anwendung muss den Rest-Prinzipien genügen.

    Weißt du ob Google eine Api für Java anbietet, welche innerhalb des GalssFish’s läuft? Alle Beispiele zielen auf die Google-App-Engine ab und ich befürchte, dass ich die entsprechenden Bibliotheken nicht neutzen kann.

    Ich muss für veschiedene Anwender URI’s anlegen welche mit Google-Docs bearbeitet werden können, teils aleine teils arbeiten die zusammen und können “Lesend” zugreifen.

    Ich danke DIr für die Info, ach übrigens wohne ich in Speyer.
    Viele Grüße Peter

Schreib' mir was nettes... ;-)