© stephan kerkhofs, Fotolia.com

Die finale Release der Java Enterprise Edition 6 nähert sich mit schnellen Zügen. Mit einer Preview auf Glassfish 3 stellt Sun eine kostenlose Referenzimplementierung für den kommenden Standard bereit, mit der sich eine Java-EE-6-Entwicklungsumgebung unter Linux einrichten lässt.

Die Entwicklergemeinde von Java legt Wert auf gemeinsame Standards. Die Enterprise Edition 6 (EE 6) befindet sich zurzeit noch im Java Community Process und wartet auf ihre Verabschiedung. Dennoch gab Sun zur diesjährigen Java One bereits mit der Preview auf Glassfish 3 einen Vorgeschmack auf die neue Plattform. Mit dieser Version erhalten Entwickler Suns Variante eines Java-Applikationsservers, um die Neuerungen auszuprobieren. Als Anbieter der Entwicklungsumgebung Netbeans verbindet Sun sie mit dem Applikationsserver Glassfish, der als Laufzeit-Umgebung für die meist Web-basierten Java-Anwendungen dient. Ein Beispiel zeigt Installation und Zusammenspiel der Komponenten.

Glassfish-Installation

Der Java-Entwickler benötigt zunächst das kostenlos unter CDDL und GPLv2 lizenzierte Glassfish-Installationspaket aus dem Sun Developer Network [1]. Er hat die Wahl zwischen der Java EE 6 SDK Preview und der Java EE 6 SDK Web Profile Preview Edition zu jeweils etwa 40 MByte im Download. Die Web Profile Edition nutzt das neue Profiles-Feature der Java-EE-6-Plattform, das es erlaubt, zusätzliche Komponenten zu einem späteren Zeitpunkt in den Applikationsserver nachzuladen.

Dazu setzt Glassfish auf das Apache-Projekt Felix, eine freie Implementierung der so genannten OSGi-Spezifikation [2]. Sie beschreibt dabei eine Softwareplattform, die die Implementierung einer Modul- und Komponenten-basierten Applikation erleichtert.

Da der Glassfish-Server nach der Installation alle Funktionsbereiche der Java-EE-6-Plattform unterstützen soll, fällt die Entscheidung beim Download auf das vollständige Paket Java EE 6 SDK Preview. Sun liefert das Archiv als ausführbare Datei aus. Es setzt das JDK in der Version 1.6.0_14 oder höher voraus. Das überprüft der Entwickler mit Hilfe von »java -version«. Anschließend macht er das Archiv ausführbar und startet es aus einem beliebigen Verzeichnis heraus. Ein grafischer Wizard leitet durch die Schritte der Installation.

Nach der Begrüßung und der erforderlichen Bestätigung der Lizenz gelangt der Anwender zur Auswahl des Installationsverzeichnisses. Java EE schlägt hier ein Verzeichnis im Home Directory des Anwenders vor. Im Dialog »Administration Settings« fragt der Wizard nach je einem Port für Anwendungen und Administration sowie optional nach einem Passwort für die administrative Konsole (siehe Abbildung 1).

Abbildung 1: Während der Installation erhält der Anwender die Gelegenheit, die Porteinstellungen zu beeinflussen.

Findet der Wizard im nächsten Dialog nicht selbstständig ein passendes JDK, so gibt der Anwender manuell den Pfad an. Wichtig ist, dass es mindestens die Version 1.6.0_14 hat. Unter Ubuntu liegt es beispielsweise unter »/usr/lib/jvm/java-6-sun-1.6.0.14/«.

Server-Administration

Um den Server anschließend zu starten, wechselt der Administrator ins Unterverzeichnis »bin/« der Installation und ruft dort »./asadmin start-domain Domain« auf. Eine Domain meint hier eine logische Anwendungsumgebung. Lässt der Admin den Namen der Domain weg, startet Glassfish »domain1«, die das Framework bei der Installation bereits angelegt hat. Alle aktiven Domains zeigt das Unterkommando »list-domains« an, »stop-domain« beendet die Domain (siehe Abbildung 2).

Abbildung 2: Das Starten und Stoppen des Servers lässt sich auf der Konsole schnell und einfach erledigen.

Die Administrationskonsole erreicht der Admin mit einem Webbrowser auf dem konfigurierten Port, 4848 ist die Voreinstellung (siehe Abbildung 3). Sie liefert ihm direkten Zugriff auf die wichtigsten Programmbestandteile und Abläufe. So befinden sich an dieser Stelle Links zur Online-Dokumententation und zum Update Center. Im Menüpunkt »Deployment« ruft er eine Liste der momentan installierten Webanwendungen ab und fügt eigene hinzu, wenn er entsprechende War-Pakete besitzt.

Abbildung 3: Wichtige Aufgaben wie das Deployment darf der Admin über ein Webfrontend erledigen.

Java-EE-Applikationen greifen im Backend häufig auf eine Datenbankinstanz zurück. Der Glassfish-Server liefert bereits eine Datenbank mit, den Java DB Server. Er startet sie jedoch nicht automatisch mit der Glassfish-Domain, sondern verlangt, dass der Anwender dies per »./asadmin start-database –dbhome Verzeichnis« selbst erledigt. Mindestens eine Domain muss dazu laufen.

Eine der häufigsten Aufgaben bei der Administration eines Java-Application-Servers ist das Einrichten von Applikationen, Deployment genannt. Anwendungen für die Plattform fassen Entwickler in Form eines Archivs mit der Endung »war« zusammen. Der Java-Betreuer kann aus drei Möglichkeiten, solche Pakete in den Server einzuspielen, wählen: per Kommandozeile, über das Webfrontend oder durch Kopieren in ein spezielles Verzeichnis. Ausprobieren lässt sich das mit einer herunterladbaren Beispielapplikation »Hello.war« [3].

Webanwendungen deployen

Auf der Kommandozeile spielt sie der Systemverwalter mit »./asadmin deploy Hello.war« ein. Gibt das Tool keine Fehlermeldungen aus, ist die Webapplikation anschließend unter [http://localhost:8080/hello] aufrufbar. Das Kommando »undeploy« entfernt sie wieder. Entsprechend funktioniert der Vorgang im Browser unter »Deploy an Application« auf der Startseite der Administrationskonsole.

Unter »Deploy Applications or Modules« darf der Systemverwalter detaillierte Einstellungen für den Deployment-Vorgang konfigurieren. Mit Hilfe eines Datei-Auswahldialogs wählt er die War-Datei für das Feld »Packaged file to be uploaded to the server« aus. Glassfish füllt »Application Name« anschließend automatisch aus, der Programmierer darf die Vorgabe ändern. Die weiteren Empfehlungen behält er bei und bestätigt sie durch »OK«. Die Anwendung erscheint nun in der Liste der installierten Applikationen (siehe Abbildung 4).

Abbildung 4: Die Administrationskonsole zeigt dem Admin die im Server installierten Applikationen.

Die dritte Option ist ein automatisches Deployment, das vor allem andere Anwendungen der Entwicklungsumgebung nutzen. Dazu erwartet Glassfish die War-Datei in »glassfish/domains/domain1/autodeploy« unterhalb des Installationsverzeichnisses. Während der Ausführung überwacht Glassfish die Veränderungen an diesem Verzeichnis und führt bei neuen Dateien oder Aktualisierungen bestehender Dateien entsprechende Deployments aus. Löscht ein Anwender eine War-Datei aus dem »autodeply«-Verzeichnis, entfernt Glassfish auch die Applikation aus dem Server.

Glassfish und Netbeans

Die wenigsten Java-Entwickler wollen sich zum Programmieren und Verwalten auf die Kommandozeile beschränken. Mit Netbeans hat Sun ein Entwicklungsumgebung im Programm, die der Java-Erfinder eng mit Glassfish abgestimmt hat. Um sie mit der Preview von Glassfish 3 zu betreiben, ist mindestens Netbeans in der Version 6.7 erforderlich. Besser geeignet ist jedoch eine Entwicklerversion von Netbeans 6.8 als Nightly Build, da hier keine zusätzlichen Konfigurationen notwendig sind, Netbeans 6.7 läuft nämlich nur, wenn der Anwender es mit dem Parameter »-J-Dorg.glassfish.v3.enableExperimentalFeatures=true« startet, der die experimentelle Unterstützung für Glassfish 3 Preview aktiviert.

Der Entwickler lädt hierzu das Netbeans-Programmpaket in der Java-Edition herunter [4] oder entscheidet sich direkt für den Nightly Build [5]. Die Pakete lassen sich zur Installation direkt ausführen. Die Download-Seite bietet auch ein Netbeans-Installationsarchiv an, das direkt den Glassfish-Server enthält. Zum Redaktionsschluss war jedoch noch keine 3-Preview-Version verfügbar. Bis sich das ändert, empfiehlt sich deshalb die getrennte Vorgehensweise.

Nach dem Start der IDE legt der Entwickler ein neues Java-Projekt an und bindet die bereits gestartete Glassfish-Instanz in die IDE ein. Er wechselt dazu auf den Reiter »Services« und wählt über das Kontextmenü den Eintrag »Add Server« aus. In dem darauf folgenden Wizard entscheidet er sich auf der ersten Dialogseite für den Eintrag »Glassfish v3« (siehe Abbildung 5) und nennt das Glassfish-Installationsverzeichnis.

Abbildung 5: Zur Integration in Netbeans wählt der Entwickler den passenden Servertyp aus.

Auf der letzten Dialogseite gibt er eine Domain an. Netbeans zeigt ein Liste aller im Glassfish-Server konfigurierten Domains an. Läuft der Server mit Standardeinstellungen, listet die IDE hier »domain1«. Nach der Bestätigung hängt der Glassfish-Server unterhalb des Serverknotens (siehe Abbildung 6). Diese Baumansicht zeigt darunter die bereits installierten Applikationen. Dank der Integration von Glassfish und Netbeans deployen Entwickler Java-EE-Applikationen direkt in den Applikationsserver.

Abbildung 6: Die Auflistung der konfigurierten Server-Instanzen liefert Netbeans dem Entwickler über die Registerkarte »Services«.

Für Java EE entwickeln

Ein eigenes Projekt legt der Programmierer per Assistent über das Menü »File | New Project« an. Er wählt als Projekttyp »Web Application« aus und vergibt einen Namen. Im nächsten Dialog fordert Netbeans zur Auswahl des Applikationsservers auf. Da die IDE Glassfish bereits kennt, lässt sich der Server direkt auswählen. Die restlichen Einstellungen übernimmt der Entwickler. Netbeans generiert die Projektstruktur und zeigt sie innerhalb des »Project«-Tab an.

Eine Beispielanwendung soll auf der Weboberfläche eine Ausgabe präsentieren, die sie zuvor von einem REST-ful-Webservice bezogen hat. REST-ful-Webservices sind Bestandteil der Java-EE-6-Plattform und rufen einen Service direkt über eine URL auf [6]. Java EE 6 setzt dazu die Spezifikation JAX-RS um.

Für den Webservice selbst legt der Entwickler in Netbeans ein weiteres Projekt an, diesmal von Typ »RESTful Webservices from Pattern«, und wählt die Option »Singelton« für das Entwurfsmuster. Er darf sich im folgenden Dialog einen Namen für das Package im Feld »Resource Package« und für die Klasse ausdenken, etwa »HelloServiceResource«. Als Pfad wählt er »helloService« und bestätigt alle Angaben mit »Finish«.

Netbeans generiert automatisch die Klasse und fügt die für einen REST-Service benötigten Methoden automatisch ein (Listing 1). Darunter sind auch (ab Zeilen 35, 50) zwei Methoden zur Kommunikation mit dem Webservice. Da das Beispiel nur lesenden Zugriff benötigt, entfernt der Entwickler die »putText()«-Methode und implementiert mittels

public String getText() {
  Calendar now = Calendar.getInstance();
  String year = String.valueOf(
                now.get(Calendar.YEAR));
  return "Hallo Welt im Jahr " + year;
}

die Logik in »getText()« des Dienstes, die einen kurzen Text und das aktuelle Jahr zurückliefert.

Nachdem er den Service angepasst hat, deployed der Entwickler die Webanwendung direkt nach Glassfish. Dazu ruft er in Netbeans im Reiter »Projects« des aktuellen Projekts das Kontextmenü auf und wählt »Run« aus. Das Deployment erfolgt automatisch und der Webservice öffnet sich im Browser.

01 /*
02  * To change this template, choose Tools |
03  * Templates and open the template in the
04  * editor. */
05
06 package v3RocksRESTServices.Services;
07
08 import javax.ws.rs.core.Context;
09 import javax.ws.rs.core.UriInfo;
10 import javax.ws.rs.Consumes;
11 import javax.ws.rs.PUT;
12 import javax.ws.rs.Path;
13 import javax.ws.rs.GET;
14 import javax.ws.rs.Produces;
15
16 /**
17  * REST Web Service
18  * @author Sebastian */
19 @Path("helloService")
20 public class HelloServiceResource {
21   @Context
22   private UriInfo context;
23
24   /** Creates a new instance of
25    * HelloServiceResource */
26   public HelloServiceResource() {
27   }
28
29   /**
30    * Retrieves representation of an instance
31    * of v3RocksRESTServices.Services.Hello-
32    * ServiceResource
33    * @return an instance of java.lang.String
34    */
35   @GET
36   @Produces("text/plain")
37   public String getText() {
38     //TODO return proper presentation obj
39     throw new UnsupportedOperationException();
40   }
41
42   /**
43    * PUT method for updating or creating an
44    * instance of HelloServiceResource
45    * @param content representation of resource
46    * @return an HTTP response with content of
47    * the updated or created resource.
48    */
49    
50   @PUT
51   @Consumes("text/plain")
52   public void putText(String content) {
53   }
54 }

Nun fehlt der Webanwendung noch eine Präsentationsschicht. Dazu legt der Entwickler über das Menü »File | New File« eine JSP-Seite an. Listing 2 zeigt das von Netbeans generierte Ergebnis. Um auf den REST-Service zuzugreifen, fügt der Entwickler innerhalb der JSP-Seite an Stelle der Überschrift den Code aus Listing 3 ein. Auch hier aktiviert »Run« im Kontextmenü die Änderungen und macht sie im Browser sichtbar.

01 <%@page contentType="text/html" pageEncoding="UTF-8"%>
02 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
03    "http://www.w3.org/TR/html4/loose.dtd">
04 
05 <html>
06   <head>
07     <meta http-equiv="Content-Type"
07           content="text/html; charset=UTF-8">
08     <title>JSP Page</title>
09   </head>
10   <body>
11     <h1>Hello World!</h1>
12   </body>
13 </html>

01 <h1>Output From RESTful Web Service:</h1>
02 <%
03   out.println("<h4>");
04 
05   // Use the java.net.* APIs to access the
06   // REST-ful web service
07   HttpURLConnection connection = null;
08   BufferedReader rd = null;
09   StringBuilder sb = null;
10   String line = null;
11   URL serverAddress = null;
12 
13   try {

14     servAddr = new URL("http://localhost:8080/v3RocksRESTServices/resources/helloService");
15     connection = (HttpURLConnection)
16             servAddr.openConnection();
17     connection.setRequestMethod("GET");
18     connection.setDoOutput(true);
19     connection.setReadTimeout(10000);
20     // Make the connection
21     connection.connect();
22     // Read in the response
23     rd = new BufferedReader(
24              new InputStreamReader(
25                connection.getInputStream()));
26     sb = new StringBuilder();
27     while ((line = rd.readLine()) != null) {
28       sb.append(line);
29     }
30     out.println(sb.toString());
31   } catch (Exception e) {
32     e.printStackTrace();
33   }
34   out.println("</h4>");
35 %>

Alles unter einem Dach

Die Kombination aus Netbeans und Glassfish bietet Entwicklern eine vollständige und kostenlose Entwicklungs- und Laufzeitumgebung für das kommende Java EE 6. Die umfangreiche Glassfish-Dokumentation vertieft die einzelnen Funktionen [7]. Da der Glassfish-Server als Referenz für den kommenden und eigentlich schon für 2008 angekündigten Standard gilt, liefert die Vorschau auf Version 3 des Applikationsservers zur Zeit das vollständigste Bild der Plattform. (mg)