Im JBoss-Home Verzeichnis /standalone/configuration die standalone.xml Datei zum Bearbeiten öffnen. Darin befindet sich der Abschnitt zum Datasources Subsystem:

<subsystem xmlns="urn:jboss:domain:datasources:1.0">
  ...
</subsystem>

In diesem Subsystem wird zwischen der Beschreibung der Datenbankverbindung (datasource) und dem Treiber (driver) unterschieden. Für die MySQL Datenbank wird neben der bereits per Default konfigurierten Datasource ExampleDS die MySqlDS hinzugefügt. Dazu wird der JNDI-Name, der Pool-Name sowie die Verbindungsdaten konfiguriert.
Der Text im Element <driver>com.mysql</driver> ist dabei ein Verweis auf den konfigurierten MySQL Treiber. Der Treiber wird direkt neben den datasource Elementen im eigenen Element driver beschrieben. Die einfachste und schnellste Art den Treiber zu installieren ist den Dateinamen des Treibers direkt anzugeben. In meinem Fall ist es der aktuellste Treiber mysql-connector-java-5.1.17.jar.

Der folgende Ausschnitt aus dem datasources Element zeigt die Konfiguration für die MySQL Datenbank:

<datasources>

  ...

  <datasource jndi-name="java:jboss/datasources/11TipperSqlDS" pool-name="11TipperSqlDS"
    enabled="true" jta="true" use-java-context="true" use-ccm="true">
    <connection-url>
      jdbc:mysql://localhost:3306/11tipper
    </connection-url>
    <driver>
      mysql-connector-java-5.1.17.jar
    </driver>
    <pool>
      <min-pool-size>
        10
      </min-pool-size>
      <max-pool-size>
        100
      </max-pool-size>
      <prefill>
        true
      </prefill>
      <use-strict-min>
        false
      </use-strict-min>
      <flush-strategy>
        FailingConnectionOnly
      </flush-strategy>
    </pool>
    <security>
      <user-name>
        db-username
      </user-name>
      <password>
        db-password
      </password>
    </security>
  </datasource>

  <driver name="mysql-connector-java-5.1.17.jar" module="com.mysql">
    <xa-datasource-class>
      com.mysql.jdbc.jdbc2.optional.MysqlXADataSource
    </xa-datasource-class>
  </driver>
</datasources>

Der XML-Code kann übrigens einfach unformatiert in die standalone.xml eingefügt werden. Der JBoss formatiert diese Datei nach einem Start selbst noch einmal neu.

Würde der JBoss AS nun im Standalone Modus gestartet werden erscheint folgende Fehlermeldung in der Console:

Die einfachste Art den fehldenden Treiber zu installieren ist diesen direkt in dem deployments Ordner zu kopieren und ihn zu “deployen”. Der JBoss AS versteht jeden normalen JDBC Treiber und kann ihn als Deployment laden:

Startet man jetzt den JBoss erneut erscheint folgende Meldung in der Console:

Die Datasource wurde erfolgreich konfiguriert und ist nun unter dem JNDI Namen java:jboss/datasources/11TipperSqlDS verfügbar.

Datenbanktreiber als Modul

Es gibt noch eine zweite Variante wie man den Treiber installieren kann: und zwar als Modul. In dem driver Element, aus dem obigen datasources Listing wurde als Modulname com.mysql angegeben. Das bedeutet, dass im Verzeichnis modules die Unterordner com/mysql erwartet wird. In diesem Modulverzeichnis wird das Unterverzeichnis main erwartet in dem die Modulbeschreibung sowie die Resource, in unserem Fall der Treiber, liegt. Bei mir sieht das dann wie folgt aus:

Die Datei mysql-connector-java-5.1.17.jar.index wird dabei automatisch vom JBoss generiert.

Die Datei module.xml beschreibt das Modul und die dazugehörige Resource/Jar/Treiber und sieht so aus:

<?xml version="1.0" encoding="UTF-8"?>

<module xmlns="urn:jboss:module:1.0" name="com.mysql">
  <resources>
    <resource-root path="mysql-connector-java-5.1.17.jar"/>
  </resources>
  <dependencies>
    <module name="javax.api"/>
  </dependencies>
</module>

Startet man mit dieser Konfiguration (den Treiber als Modul) den JBoss erneut so findet man im Log keine Info mehr, dass eine Abhängigkeit fehlt, sondern findet das installierte Modul wesentlich früher in der Console wieder. Und zwar wenn das Subsystem datasources gestartet wird:

Verwendet man ein Modul als Treiberkonfiguration kann man in der standalone.xml in der datasource und driver Beschreibung auch irgendein Name wie z.B. “MeinMySqldDB” verwenden. Es muss dann nicht zwingend der Name des Treibe-Jars sein. Somit wäre man im Namen unabhängig von der eigentlich verwendeten Version.

Administration Console

Egal ob man den Datenbanktreiber als Deployment oder als Modul installiert in beiden Fällen muss mann die konfigurierte Datasource in der Administrationskonsole wiederfinden. Auf die gelangt man in der Default Installation mit http://localhost:8080/console. Es müsste dann in etwa so aussehen:

In der persistence.xml kann nun mit dem JNDI Name auf die Datasource zugegriffen werden.

Am Ende dieses Tutorials ist ein deploytes Java EE 6 Projekt mit JSF 2, CDI, EJB 3.1 und JPA 2 auf dem JBoss 6 vorhanden und aufrufbar. Dabei wird die Eclipse WTP Untestützung funktionieren, der JBoss direkt aus Eclipse heraus gestartet und Maven als Build Tool verwendet werden.

Kleine Anmerkung vorab: Nicht von der Länge des Tutorials abschrecken lassen – es sind eigentlich nur sehr viele Bilder. Kennt man die Technologien und Tools dauert das Erstellen dieses Projekts nur wenige Minuten.

Aufbau des Tutorials:

• Herunterladen der notwendigen Software und Tools
  • Eclipse herunterladen
  • JBoss AS herunterladen
  • Maven herunterladen
• Eclipse konfigurieren
  • JBoss Tools
  • JBoss 6 AS Server Runtime
  • Maven
  • Maven Extras – WTP
• Java EE 6 Projekt erstellen
  • Projekt mit Maven generieren
  • JSF Capabilities hinzufügen
  • CDI Support hinzufügen
  • Projekt auf den JBoss deployen
• Wie geht es weiter?

Herunterladen und Installieren aller benötigten Software und Tools

Eclipse Helios für Java EE Entwicklung herunterladen

Als erstes wird Eclipse in der Java EE Entwickler Version von eclipse.org heruntergeladen.

Das heruntergeladene Archiv am Ort deiner Wahl entpacken – z.B. einfach im Laufwerk C.

JBoss AS 6

In diesem Tutorial wird der JBoss 6 Final als Application Server verwendet denn dieser implementiert die Java EE Web Profile Spezifikation. Der JBoss AS kann unter jboss.org heruntergeladen werden.

Nach dem Herunterladen das Archiv auch wieder am Ort deiner Wahl entpacken – kann z.B. auch wieder das Laufwerk C: sein.

Maven 3

Um den Projektstart zu vereinfachen und alle Abhängigkeiten automatisch zu beziehen wird Maven 3 verwendet. Später wird auch das Grundgerüst unseres ersten Java EE Hello World Projekts mit Maven generiert. Somit muss Maven 3 “installiert” werden. Maven kann von http://maven.apache.org heruntergeladen werden:

Maven muss auch wieder an einem Ort deiner Wahl entpackt und anschließend das maven/bin Verzeichnis im Pfad (Umgebungsvariable PATH) angegeben werden damit der Befehl mvn in der Kommandozeile gefunden wird.

Installationsanleitung für Linux (Ubunutu 11.04) anzeigen.

Eclipse konfigurieren

Zuvor wurde bereits die die aktuelle Eclipse Helios (3.6) Java EE IDE heruntergeladen sowie entpackt und diese sollte spätestens jetzt gestartet werden. Beim ersten Start von Eclipse wir gefragt wo man seinen Workspace hinlegen möchte. Wieder einfach einen Ort deiner Wahl angeben und das Häckchen bei “nicht noch einmal fragen” setzen.

Für das Java EE Projekt mit Maven Unterstützung werden zum einen die JBoss Tools und zum anderen das Maven2Eclipse Plugin benötigt. Dabei spielen die JBoss Tools bei der Entwicklung von Java EE Projekten unter Eclipse generell eine sehr wichtige Rollen denn sie decken die meisten Themen wie z.B. JSF 2.0, CDI oder JPA sehr gut ab.

JBoss Tools Eclipse Plugin

Die aktuelle Version 3.2 der JBoss Tools gibt es dabei noch gar nicht so lange denn sie wurde erst Mitte Februar Final. Die JBoss Tools werden am einfachsten über die offizielle Update Seite installiert: http://download.jboss.org/jbosstools/updates/stable/helios/
Dazu in Eclipse im “Hauptmenü->Help->Install New Software…” klicken. Im aufkommenden Dialog den Button “Add” klicken um die Update Seite hinzuzufügen:

Diesen Dialog mit dem Button “Add” beenden und anschließend wird man erst einmal durch den Schriftzug “Pending…” sehen, dass das Repository geladen wird. Das kann unter Umständen eine ganze Weile dauern:

Sobald das Repository geladen wurde ist eine Liste mit allen möglichen Gruppen zu sehen. Die bisher bekanntesten Tools wie z.B. die JBoss AS Tools, Seam Tools oder Hibernate Tools befinden sich in der Gruppe “Web und Java EE Development”. Man könnte jetzt alles durchgehen und nur die benötigten Tools selektieren aber der Einfachheit halber selektiere ich “All JBoss Tools 3.2.0″:

Anschließend den Button “Next” klicken. Jetzt werden die Abhängigkeiten geprüft und das dauert auch wieder eine kleine Ewigkeit.
Sobald die Prüfung fertig ist sieht man noch einmal die Liste aller Tools die installiert werden sollen. In der Liste taucht sicherlich das ein oder andere Tool auf welches nicht wirklich benötigt wird aber es schadet auch nicht. Den Dialog mit “Next” beenden.
Auf dem letzten Dialog die Lizensvereinbarungen akzeptieren und den Button “Finish” klicken. Anschließend beginnt die Installation der JBoss Tools:

Die Installation verlangt einen Eclipse Neustart.

JBoss Server Runtime konfigurieren

Das spätere Projekt soll direkt von Eclipse heraus in den JBoss Server deployt werden. Dazu muss der JBoss als Server Runtime Environment in Eclipse konfiguriert werden. Um das zu tun die Eclipse Eigenschaften aufrufen “Hauptmenü->Window->Preferences” und die Optionen mit dem Wort “Server” filtern. Unter dem Punkt “Runtime Environments” wird der JBoss Server als Runtime hinzugefügt:

Den Button “Add” klicken und im nächsten Dialog unter “JBoss Community” den “JBoss 6.0 Runtime” auszuwählen. Der Einfachheit halber direkt die Checkbox “Create a new local server” selektieren – das erspart die anschließende Konfiguration einer Server Instanz:

Mit dem Button “Next” in den letzten Dialog wechseln und dort das Verzeichnis auswählen indem der JBoss entpackt wurde (z.B. C:\jboss-6.0.0). Als JRE muss das in Eclipse konfigurierte JDK ausgewählt werden. Unter Configuration default auswählen. Den Wizzard mit dem Button “Finish” beenden:

Nun ist die konfigurierte Server Runtime aufgelistet und kann verwendet werden:

In dem Server-Panel ist auch die lokale Instanz zu sehen:

Als letzte Konfiguration der eingebetteten JBoss Server Instanz wird jetzt noch das Deployment-Verzeichnis geändert. Per default wird die deployte Anwendung im lokalen Workspace in einen versteckten Ordner deployt. Ich mag es lieber wenn meine Anwendung auch mit direkt in den JBoss deploy Ordner deployt wird und dann auch dort zu finden ist.
Um das Deployment-Verzeichnis zu ändern mit einem Doppelklick auf die JBoss Server Instanz die Konfiguration öffnen. Anschließend am unterem Ende des Fensters auf den Tab “Deployment” klicken. Auf der Deployment Seite nun die Einstellung “Use JBoss deploy folder” selektieren und die Einstellungen speichern:

Nun kann der Server endlich durch klick auf den grünen Pfeil gestartet werden – er sollte ohne Probleme hochfahren. In der Console sollte am Ende die Startdauer zu sehen sein:

Im Browser lässt sich der JBoss auch bereits aufrufen:

Wunderbar – der Server läuft =).

Maven Unterstützung in Eclipse

Um Maven direkt aus Eclipse heraus verwenden zu können benötigt man das m2eclipse Plugin von Sonatype. Die Plugin Installation wird wieder über das “Hauptmenü->Help->Install New Software…” gestartet. In meiner Helios Version war die Update URL für das m2eclipse Plugin bereits konfiguriert. Ansonsten einfach folgende Update URL hinzufügen: http://m2eclipse.sonatype.org/sites/m2e
Ist dieses Update URL selektiert wird das Repository geladen. In diesem Fall ist nur ein Plugin selektierbar und das muss natürlich selektiert werden:

Den Dialog mit “Next” weiterführen.
Anschließend kommen wieder die Installationsdetails und die Lizensbedingungen. Den Wizzard mit “Finish” beenden und abwarten bis man aufgefordert wird Eclipse neu zu starten.
Es kann sein, dass nach dem Neustart das Maven Plugin meldet, dass Eclipse mit einem JDK gestartet werden muss:

In diesem Fall die Datei eclipse.ini öffnen (liegt direkt neben der Datei eclipse.exe) und unter dem Ausdruck openFile und oberhalb von -vmargs den Verweis auf die JDK angeben:

Mehr zu der Datei eclipse.ini findest du auch im Eclipse Wiki.

Nach dem Neustart kann in den Eclipse Preferences (Hauptmenü->Window->Preferences) die Maven Einstellungen konfigurieren. Darunter auch welches Maven verwendet werden soll. Das Plugin bringt eine Embedded-Version mit. In Eclipse reicht diese embedded Version eigentlich aus. Es empfiehlt sich aber die eigene Installation zu verwenden, so dass man auf der Kommandozeile die gleiche Maven Version verwendet wie in Eclipse. Dazu in “Maven->Installations” mit dem Button Add die eigene Installation hinzufügen:

Nachdem das Maven Plugin installiert wurde und man evtl. die Maven Installation angepasst hat dauert es einen Moment bis Maven seinen Index aktualisiert hat. Sofern das Maven Index Update noch läuft sieht man dies in dem Progress Panel:

Maven Extras – m2eclipse-extras

Es fehlt noch das Maven Integration for Eclipse WTP Plugin um mit Maven mit dem Eclipse Web Tools Project zu verbinden. Dazu noch einmal im Hauptmenü “Help->Install New Software..2 klicken und die Update URL auswählen oder hinzufügen: http://m2eclipse.sonatype.org/sites/m2e-extras

Anschließend den Wizzard wieder wie gewohnt durchgehen und das Plugin installieren.

Das erste Java EE 6 Projekt

Nun ist Eclipse konfiguriert und vorbereitet – es ist Zeit für das erste Java EE 6 Projekt mit Eclipse WTP und Maven Unterstützung.

Projekt mit Maven generieren

Um ein neues Projekt anzulegen im Hauptmenü “File->New->Other” klicken und im geöffneten Startfenster des Wizzards “Maven Project” auswählen:

Mit den Button “Next” weiter. Im zweiten Dialog “Select Project Name and Location” die Voreinstellung “Use default Workspace Location” selektiert lassen und Button “Next” klicken.
Im folgenden Dialog “Select an Archetype” nach “knappsack” filtern und ee6-sandbox-archetype auswählen. Falls dieser Archetype nicht verfügbar ist kann es sein, dass der Maven Index Update noch nicht vollständig durchlaufen ist – in diesem Fall sieht man in Eclipse unten rechts im Progress View, dass ein Prozess läuft und es hilft nur warten..
Die “knappsack” Archetypes wurden von Andy Gipson erstellt und ermöglichen einen sehr einfachen Start in das Projekt.
Wer ein Beispielprojekt mit einem vollständigem CRUD Beispiel haben möchte sollte das Archetype jee6-sandbox-demo-archetype verwenden.

Nach dem Selektieren des Archetypes den Dialog mit “Next” verlassen.

Auf der nächsten Seite müssen jetzt die Archetype Parameter gesetzt werden. Das ist zum Einen die Group Id und zum Anderen die Artifact Id. In die Group id kommt der übergeordnete Name der Package Struktur und als Artifact Id wird der Projektname gewählt:

Mit dem Button “Finish” den Wizzard beenden. Das Projekt wird nun generiert und das kann einen Moment dauern:

Nun ist das Projekt erstellt und man kann sich die Java, xhtml und Konfigurationsdateien ansehen die durch den gewählten Maven Archetype generiert wurden:

Diese generierten Java und xhtml Dateien sollen den Einstieg in JSF 2, CDI und JPA 2 vereinfachen.

Konfiguration in web.xml auf Servlet 3.0 umstellen

Der ausgewählte Maven Archetype hat in der web.xml als Servlet Spezifikationsversion 2.5 konfiguriert aber wir wollen 3.0 verwenden. Deswegen die web.xml Datei öffen: ALT-Shift-R -> web.xml oder im Verzeichnis src/main/webapp/WEB-INF. In dieser Datei steht auch schon als Kommentar der Hinweis, dass man für den JBoss Servlet Version 3 verwenden soll. Dazu die Zeile 10 löschen und die oberen Zeilen mit version=”3.0″ verwenden. Mein web-app Element sieht wie folgt aus:

JSF Capabilities dem Projekt hinzufügen

Öffnet man eine .xhtml Seite so öffnet sich der Visuell Editor von den JBoss Tools. Allerdings erscheint eine Fehlermeldung, dass die JSF Capabilities / JSF Unterstützung für dieses Projekt noch nicht konfiguriert ist:

Entweder in dieser Fehlermeldung direkt auf den Button “Add JSF Capabilities” klicken oder mit der rechten Maustaste auf das Projekt und aus dem Kontextmenü “Configure->Add JSF Capabilities” klicken. In beiden Varienten öffnet sich ein Wizzard mit dem ersten Dialog “Project Location”. Der vorgegebene Pfad für die web.xml Datei sollte eigentlich stimmen:

Mit den Button “Next” auf den nächsten Dialog “Project Folders” wechseln. Die vorgegebenen Pfade sollten auch hier stimmen. Die Checkbox “Add Libraries” darf nicht selektiert werden denn sonst kommt es später zu Fehlern.
Als Servlet Version muss 3.0, wie zuvor bereits in der web.xml abgeändert, ausgewählt werden.
Der Haken bei der Checkbox für “Target Server” bewirkt, dass dieses Projekt direkt dem konfigurierten JBoss hinzugefügt und mit deployt wird:

Den Wizzard mit dem Button “Finish” beenden. Man wird anschließend gefragt ob man in die Web Developer Perspektive wechseln möchte. Je nach Geschmack kann man sich die Web Developer Perspektive anschauen und verwenden oder wieder in die Java EE Perspektive wechseln.

Nun sollten sich alle .xhtml Seiten ohne Warnung im Visual Editor öffnen lassen und auch Autocomplete für JSF Tags möglich sein:

CDI (Context and Dependency Injection) Unterstützung dem Projekt hinzufügen

Als letztes müssen noch die CDI Unterstützung konfiguriert werden. Man merkt es daran, dass in der .xhtml Seite noch kein Autocomplete für die EL (Expression Language) zulässt. Wenn man z.B. in der home.xhtml den Cursor in die Expression #{demoCourseList} in Zeile 11 setzt und F3 drückt sollte die entsprechende Producer Methode der CDI Bean springen:

Die CDI Unterstützung wird genauso hinzugefügt wie die JSF Capabilites im Abschnitt zuvor. Im Kontextmenü des Projektes (rechte Maustaste auf den obersten Knoten des Projekts) Configure->Add CDI (Context and Dependency Injection) support.. klicken. Im geöffneten CDI Preferences Dialog die Checkbox selektiert lassen und den Button “Apply” drücken. Anschließend den Preferences Dialog mit dem Button “OK” wieder verlassen:

Nun den gleichen Versuch wie vorher schon in der home.xhtml machen und mit dem Cursor auf die Expression #{demoCourseList} in Zeile 11 setzen und F3 drücken. Nun öffnet sich der Java Editor genau an der richtigen Methode mit dem dazugehörigem CDI Producer:

Außerdem funktioniert nun auch Autocomplete direkt in der .xhtml Seite in einer Expression:

Projekt auf den JBoss deployen

Jetzt kommt der erste Test ob das generierte Projekt sich auch deployen und im Browser anzeigen lässt. Dazu im Server Panel überprüfen ob das Projekt dem Server hinzugefügt wurde – dazu einfach den JBoss aufklappen und vergewissern ob das jee6project zu sehen ist. Falls nicht muss das Projekt noch hinzugefügt werden: “rechte Maustaste auf JBoss 6.0 Runtime Server->Add and Remove…”. Anschließend den Server starten:

In der Console erscheinen dann irgendwann die folgenden Zeilen:

Nun die deployte Anwendung im Browser unter http://localhost:8080/jee6project aufrufen:

Die Seite die dargestellt wird stammt aus dem gewählten Knappsack Maven Archetype und soll die ersten Schritte in Java EE 6 bzw. in CDI vereinfachen.
Um zu prüfen ob die WTP Unterstützung funktioniert kann man das Hot Deployment ausprobieren. Hot Deployment funktioniert auf alle Web Resourcen wie z.B. .xhmtl, .css oder Bilddateien.
Um das zu testen einfach die home.xhtml öffnen und einen Text eingeben:

Nach dem speichern die Seite im Browser aktualisieren und der Text sollte direkt angezeigt werden.

Prinzipiell ist das Tutorial an dieser Stelle zu Ende – der JBoss läuft und das Java EE 6 Projekt ist deployt. Es lohnt sich als nächstes den Code durchzusehen und zu verändern. Im folgenden Abschnitt wird noch kurz auf ein paar Dinge im Source Code rund um CDI eingegangen.

Wie geht es weiter?

An diesem Punkt angekommen solltest du ein laufendes Java EE 6 Projekt im Web Profile auf dem JBoss Application Server haben. Nun kannst du dich mit Eclipse, Maven oder Java EE 6 weiter beschäftigen.
Hast du mit Java EE 6 noch überhaupt keine Erfahrungen solltest du dir dieses Projekt genauer ansehen und dich mit den bereits verwendeten Annotationen und Aufbau vertraut machen.

Viel Spaß beim ausprobieren =).

Bubble-sort with Hungarian (“Csángó”) folk dance

Und die Macher ruhen sich nicht auf dem Erfolg aus sondern haben bereits drei weitere Sortieralgorithmen tänzerisch umgesetzt.

Insert-sort with Romanian folk dance:

Shell-sort with Hungarian (Székely) folk dance

Select-sort with Gypsy folk dance

Um ehrlich zu sein: ich habe sie mir nicht alle in voller Länge angetan.. ;)

• Das iPhone bzw iOS ist nach wie vor der Platzhirsch unter den verschiedenen mobilen Geräten/Plattformen und möchte man erfolgreich eine mobile Präsenz oder App auf dem Markt bringen darf man das iPhone nicht vernachlässigen. Allerdings ist der App Markt sehr umkämpft, was sich auch an den “wie komme ich an die Top Platzierung in den Charts” oder “wie vermarkte ich die App am besten” Themen zeigt.
• Android hat stark aufgeholt und ist der zweite Big Player im Markt. Apps für Android Geräte sollte man somit auch noch immer neben der iPhone App entwickeln um den Großteil des Marktes abzudecken. Viele Sessions zu Android gingen direkt um die Entwicklung und waren sehr technisch. Die Entwicklung mit Java rund um Android kam somit bei der Konferenz nicht zu kurz.
• Andere Anbieter, wie Samsung oder Microsoft, wollen auch noch ein Stück von dem Kuchen abhaben und kommen mit neuen Geräten, neuer Software und komplett neuen Konzepten auf den Markt. Man darf gespannt sein wie sich der Markt in Zukunft aufteilen wird. Vor allem Microsoft hat gut die Werbetrommel gerührt. So wurde z.B. das im Herbst auf den Markt kommende Windows Phone 7 von einem sehr angetriebenen Microsoft Mitarbeiter vorgestellt:
  

  Microsoft selbst glaubt, dass der Mobile Markt erst am Anfang steht und jetzt erst beginnt – sie sind voller Tatendrang und sind mit der Vorstellung auf der MobileTech Conf zufrieden.

• Web vs. App oder HTML vs. Native – das war eine viel diskutierte Frage. Muss man in Zukunft für jedes Gerät und auf jeder Plattform eine eigene native App entwickeln oder reicht es mit HTML 5 und CSS 3 mobile Webanwendungen zu erstellen die dann auf jeder Plattform laufen (das Windows Phone 7 würde wohl an dieser Stelle schon wieder ausscheiden). Abschließend konnte diese Frage nicht geklärt werden – trotz Podiums Diskussion und mehren Sessions dazu. Ich denke, dass es auf den Anwendungsfall ankommt. Ein Stichwort dazu war die Entscheidung zwischen “reach” und “rich”.
• Augmented Reality ist ein großes Thema, immer mehr am kommen und ich bin total begeistert davon. Ich glaube wir werden in Zukunft noch sehr viel von der Verschmelzung zwischen Realität und virtuelle Welt mit Informationen und Hilfen sehen. Ein schönes Beispiel dazu, um eine Vorstellung davon zu bekommen, liefert folgendes Video, was auch auf der Konferenz gezeigt wurde:
  

Am Abend des ersten Konferenztages gab es die Mobile Night, die mit einer “Unterhaltung am virtuellen Kamin” zwischen Ossi Urchs (Internet Philosoph/Guru) und Tim Bray (Google Android Advocate), was ziemlich interessant war:

Ossi Urchs hat auch die erste Keynote der Konferenz mit einer wirklich guten Rede gehalten. Die Slides der Präsentation können hier heruntergeladen werden und wer einen kleinen Eindruck erhalten möchte sollte sich das kleine Interview anschauen:

Das musikalische Highlight des Abends war das iPhone Orchester der Zaboura Eichstaedt Experience (ZEE). Das kam ganz am Ende nach einem sehr langen Tag und wurde groß angekündigt. Dabei konnten wir als Teilnehmer das Geschehen per Twitter beeinflussen. Die Performance war durchaus unterhaltsam und sah von meinem Platz wie folgt aus:

Wer einen wirklichen Eindruck von dem musikalischen Ergebnis haben möchte kann sich das Event auch noch anschauen und reinhöhren:

Amüsant war, dass der anfangs gut gefüllte Saal am Ende der Performance doch sehr gelichtet war ;).
Wer mehr von der ZEE Gruppe wissen möchte sollte sich auf deren Webseite mit vielen Videos umsehen.

Als letztes kommt mein persönliches Highlight: die AR Drone. Markus Bokowsky hat mit seiner unterhaltsamen Session “Augmented Reality” eine AR Drone mitgebracht die dann spät am Abend noch zum Einsatz kam:

Das besondere an der Drohne ist, dass es über eine App auf dem iPhone gesteuert wird. Die Drohne hat zwei Kameras eingebaut deren Bild auf das iPhone übertragen wird. Theoretisch braucht man dazu das Flugobjekt selbst nicht mehr zu sehen. Wie das Ganze dann live auf der MobileTech Conf aussah kann man schön in diesem Mitschnitt des Fluges, auf dem auch das iPhone zu sehen ist, ansehen:

Leider gibt es bis jetzt nur das iPhone als Controller. Sobald es für Android auch möglich ist werde ich mir definitiv so ein Teil zulegen! =)

Insgesamt war die MobileTech Conference wirklich interessant (bis auf manche Werbesessions, die stark an Kaffeefahrten erinnert haben) und es hat ein wenig nach Zukunft gerochen. Nächstes Jahr werde ich wohl wieder hinpilgern, zumal es für mich in Mainz ja ein Heimspiel ist – vielleicht habe ich da auch schon meine erste Android App im Market oder fliege eine AR Drone =).

Mehr dazu auch auf der JUG DA Google Groups Seite.

Ein wirklich sehr gut gemachtes Stück Film.

(vielen Dank an Christian Nicoll für den Hinweis!)

Wer also ein Tippspiel zur WM oder zur Bundesliga mit Freunden oder Arbeitskollegen veranstalten möchte kann sich auf 11tipper.de eines einrichten.
Wer mehr über das Tippspiel an sich wissen möchte sollte den Artikel auf webthreads.de lesen oder sich die Features auf 11 Tipper direkt ansehen. Es bestehen auch zwei Demo Tipprunden in denen man als Spielleiter oder Tipper herumklicken kann.

Verwendete Frameworks

Jetzt noch ein paar Worte zur Technik. Das Tippspiel wird mit JSF 1.2 und JBoss Seam 2.2.0 entwickelt. Viele kennen JBoss Seam nur auf einem Application Server wie eben den JBoss AS. Ich habe Seam auf einem Tomcat 6 ohne Embedded JBoss verwendet. Es wird somit anstatt auf EJBs voll auf POJOs gesetzt und auch nicht so getan als wäre mann auf einem Application Server. Die Persistenz ist mit JPA (Hibernate) umgesetzt. Seam verwendet zur Validierung der Eingaben an der Oberfläche die JPA Annotationen an den Entities. Für Timer und zeitliche Verzögerungen wird Quarz verwendet. Das Frontend ist mit Facelets und JBoss RichFaces 3.3 umgesetzt. Verfeinert wird das Ganze mit viel Ajax und jQuery 1.4 als JavaScript Bibliothek.

In der Vergangenheit sind schon ein paar Artikel aus den Erkenntnissen dieses Projekts hier auf javathreads.de veröffentlicht worden. Und ich werde wohl noch das ein oder andere Tutorial dazu hier in naher Zukunft veröffentlichen. Falls jemand eine bestimmte Frage zur Umsetzung hat dann nur raus damit ich antworte garantiert =).

Zuerst die eingescannten Bilder für die Endlosschleife “infinite loop”:

Und hier noch der Ausschnitt für die Rekursion:

Wer es jetzt noch nicht verstanden hat..

In meinem Anwendungsfall habe ich eine Online Schnittstelle die mir die Ergebnisse zu Spieltagen der Bundesliga als XML liefert. Ziel ist es diese Informationen so einfach wie möglich in meine Java Anwendung zu bekommen. Mit Hilfe von JAXB sollen diese XML Informationen zu Java Objekten umgewandelt werden, so dass man damit einfach weiterarbeiten kann. Dieser Vorgang wird unmarshal genannt und erzeugt eine Objekt Struktur die den Inhalt und den Aufbau der XML Datei repräsentiert.

Die erzeugte Objektstruktur ist aber kein DOM basierter Baum, wie manchmal angenommen wird, sondern ein normale Java Objekte, die wieder Referenzen auf weitere Java Objekte haben.

Die XML die ich geliefert bekomme und zu Java Objekten mit JAXB unmarshallen möchte sieht wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<spieltag>
    <game>
        <spieltag>28</spieltag>
        <nummer>1</nummer>
        <beginn>2010-03-26 20:30:00</beginn>
        <mannschaft_heim><![CDATA[VfL Bochum]]></mannschaft_heim>
        <mannschaft_gast><![CDATA[Eintracht Frankfurt]]></mannschaft_gast>
        <tore_heim_halbzeit>1</tore_heim_halbzeit>
        <tore_gast_halbzeit>1</tore_gast_halbzeit>
        <tore_heim_ergebnis>1</tore_heim_ergebnis>
        <tore_gast_ergebnis>2</tore_gast_ergebnis>
    </game>
    <game>
        <spieltag>28</spieltag>
        <nummer>2</nummer>
        <beginn>2010-03-27 15:30:00</beginn>
        <mannschaft_heim><![CDATA[Bayern München]]></mannschaft_heim>
        <mannschaft_gast><![CDATA[VfB Stuttgart]]></mannschaft_gast>
        <tore_heim_halbzeit></tore_heim_halbzeit>
        <tore_gast_halbzeit></tore_gast_halbzeit>
        <tore_heim_ergebnis></tore_heim_ergebnis>
        <tore_gast_ergebnis></tore_gast_ergebnis>
    </game>
    ...
</spieltag>

Um mit JAXB von der XML Datei zu Java Objekten zu gelangen benötigt man die Beschreibung des Mappings mit JAXB Annotationen in Java Klassen. Da in diesem Fall die XML Datei vorliegt ist der einfachste Weg sich die Klassen mit den Annotationen generieren zu lassen. Dazu benötigt man das XML Schema zu zu der XML Datei.

In meinem Fall habe noch kein Schema für diese XML Struktur. Eines jetzt von Hand zu erstellen wäre möglich aber sehr aufwendig. An dieser Stelle kommt das kleine Java Tool Namens Trang ins Spiel.

Dazu die letzte Version aus 2008 herunterladen (Direktlink) und an einem Ort der Wahl entpacken. Anschließend die XML Datei der Einfachheit halber auch mit in diese Ordner kopieren und darauf achten, dass sie mit UTF-8 enkodiert ist. Um das Schema zu erzeugen einfach das trang.jar mit zwei Parametern aufrufen:

Das von Trang generierte Schema sieht bei mir wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:element name="spieltag">
    <xs:complexType mixed="true">
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="game"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:element name="game">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="spieltag"/>
        <xs:element ref="nummer"/>
        <xs:element ref="beginn"/>
        <xs:element ref="mannschaft_heim"/>
        <xs:element ref="mannschaft_gast"/>
        <xs:element ref="tore_heim_halbzeit"/>
        <xs:element ref="tore_gast_halbzeit"/>
        <xs:element ref="tore_heim_ergebnis"/>
        <xs:element ref="tore_gast_ergebnis"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:element name="nummer" type="xs:integer"/>
  <xs:element name="beginn" type="xs:string"/>
  <xs:element name="mannschaft_heim" type="xs:string"/>
  <xs:element name="mannschaft_gast" type="xs:string"/>
  <xs:element name="tore_heim_halbzeit" type="xs:string"/>
  <xs:element name="tore_gast_halbzeit" type="xs:string"/>
  <xs:element name="tore_heim_ergebnis" type="xs:string"/>
  <xs:element name="tore_gast_ergebnis" type="xs:string"/>
</xs:schema>

Das JDK liefert einen Binding Compiler für JAXB mit dem Namen XJC mit aus der im /bin Verzeichnis unterhalb der Java Runtime zu finden ist. Damit kann man aus einem XML Schema die entsprechenden Java Klassen generieren lassen, aus denen dann beim späteren unmarshal Prozess die Java Objekte erstellt werden.

Der Aufruf des Binding Compiler verwendet in diesem Beispiel zwei Parameter. Der Paramter d definiert das Verzeichnis in dem die Klassen gespeichert werden sollen, bei mir das Verzeichnis src relativ zum aktuellen Verzeichnis, und der Paramter p definiert das Java Package in dem die Klassen liegen sollen. Als letztes wird das XML Schema angegeben aus dem die Java Klassen generiert werden sollen:

Für die obige XML Datei wurden drei Klassen generiert:

Im folgenden der interessante Teil aus der klasse Game mit JAXB Annotationen:

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "spieltag",
    "nummer",
    "beginn",
    "mannschaftHeim",
    "mannschaftGast",
    "toreHeimHalbzeit",
    "toreGastHalbzeit",
    "toreHeimErgebnis",
    "toreGastErgebnis"
})
@XmlRootElement(name = "game")
public class Game {

    @XmlElement(required = true)
    protected Spieltag spieltag;
    @XmlElement(required = true)
    protected BigInteger nummer;
    @XmlElement(required = true)
    protected String beginn;
    @XmlElement(name = "mannschaft_heim", required = true)
    protected String mannschaftHeim;
    @XmlElement(name = "mannschaft_gast", required = true)
    protected String mannschaftGast;
    @XmlElement(name = "tore_heim_halbzeit", required = true)
    protected String toreHeimHalbzeit;
    @XmlElement(name = "tore_gast_halbzeit", required = true)
    protected String toreGastHalbzeit;
    @XmlElement(name = "tore_heim_ergebnis", required = true)
    protected String toreHeimErgebnis;
    @XmlElement(name = "tore_gast_ergebnis", required = true)
    protected String toreGastErgebnis;

    // Getter und Setter
}

Man kann an diesem Beispiel sehr schön das Mapping zwischen XML Element und Attribut mit der Annotation @XmlElement sehen:

Es gibt noch weitaus komplizierte JAXB Konfigurationen von daher empfiehlt es sich eigentlich immer sich die fehlende Gegenseite, wie in diesem Beispiel die Java Klassen, generieren zu lassen. Auch der andere Weg, das marshalling von Java Objektbäumen zu einer XML Datei, lässt sich sehr einfach generieren.

Nun kommt der wichtigste Teil des Tutorials, nämlich die eigentliche Anwendung von JAXB. Die XML Datei soll als Java Objektstruktur zur Verfügung stehen, so dass die Daten einfach weiterverarbeitet werden können. Dieser Weg wird, wie am Anfang beschrieben, unmarshal genannt. Bis zum Java Objekt sind es an dieser Stelle nur noch drei Zeilen:

• JAXBContext Objekt erstellen, welches einem Zugriff auf die JAXB API ermöglicht. Dabei wird als Parameter ein oder mehrere Packages zu den generierten Klassen mit den JAXB Annotationen benötigt: JAXBContext jc = JAXBContext.newInstance("de.javathreads.jaxb");
• Unmarshaller Objekt vom JAXBContext erstellen: Unmarshaller unmarshaller = jc.createUnmarshaller();
• Die unmarshal() Methode aus dem Unmarshaller Objekt aufrufem um den unmarshalling Prozess zu starten. Als Parameter wird dabei die zu parsende XML Datei erwartet und als Rückgabewert erhält man das entsprechende Objekt für das Root Element der XML Datei. In meinem Beispiel ist das die Klasse Spieltag, welche vom Unmarshaller zurückgegeben wird: Spieltag sp = (Spieltag) unmarshaller.unmarshal(new File("D:\\projects\\TipResultParser\\xml\\spieltag.xml"));

Jetzt kann man direkt mit der Objektrepräsentation der XML Datei auf Java Ebene arbeiten. Noch einmal der Hinweis, dass es sich bei diesen Objekten nicht um ein DOM basierten Baum handelt sondern um reine Content-Objekte, welche den Inhalt und die Struktur der XML Datei wiedergeben.

Als letztes noch mal der komplette Code an einem Stück für die bessere Übersicht:

package de.javathreads.jaxb;

import java.io.File;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Unmarshaller;

public class Main {

  public static void main(String[] args) throws Exception {
    // Package
    JAXBContext jc = JAXBContext.newInstance("de.javathreads.jaxb");
    Unmarshaller unmarshaller = jc.createUnmarshaller();

    Spieltag sp = (Spieltag) unmarshaller.unmarshal(new File("D:\\projects\\TipResultParser\\xml\\spieltag.xml"));

    for (int i = 0; i < sp.getContent().size(); i++) {
      if (sp.getContent().get(i) instanceof Game) {
        Game g = (Game) sp.getContent().get(i);
        System.out.println("Spiel: " + g.getNummer());
      }
    }
  }
}

Ausgabe auf der Konsole:

Hinweis zu dem Code bezüglich der Prüfung mit instanceof Game. Die XML Schnittstelle liefert den Inhalt formatiert und somit mit Sonderzeichen wie “\t” und “\n” zurück, so dass diese Zeichen als Content direkt hinter dem XML Tag beim unmarshal Prozess erkannt wurden. Die Liste, die mir sp.getContent() zurückliefert, enthält abwechselnd den String “\t\t\n” und ein Game Objekt. Das ist aber nicht die Regel und ich muss mal schauen ob ich dieses Verhalten nicht noch irgendwie abstellen kann.

Die Grafiken wurden aus dem offiziellen Sun Artikel “Java Architecture for XML Binding (JAXB)” entnommen. Dort findet man auch eine ausführliche Anleitung für den marhall Vorgang, wenn man Java Objekte zu einer XML Datei marshallen möchte.