Artikel

 
Dezember 2009 | Artikel

Java EE 6 auf einen Blick

(Link zum Artikel: http://www.it-republik.de/jaxenter/artikel/2759)

Was lange währt …

Text: Dirk Weil
  • Teilen
  • kommentieren
  • empfehlen
  • Bookmark and Share
Am 10. Dezember 2009 war es endlich soweit: Die lange erwartete finale Version 6 der Java-EE-Spezifikation wurde freigegeben. Mit 3½ Jahren seit dem Release der Vorversion hat man sich diesmal wieder recht lange Zeit gelassen. Hat sich das Warten gelohnt?
Teil 1   Teil 2   

Die Java EE – früher J2EE – ist in den Köpfen vieler Entwickler in Ungnade gefallen. Insbesondere die Geschäftslogikanteile EJB und Persistenz waren in den älteren Versionen tatsächlich viel zu aufwändig zu benutzen. Die Abhilfe in Form von Java EE 5 kam nach fast vier Jahren viel zu spät, was einen guten Nährboden für Alternativframeworks bildete. Die lange Wartezeit hatte allerdings auch ihr Gutes: Viele gute Features bspw. aus Spring sind in die aktuelle Spezifikation eingeflossen. Sie hat nun einen sehr hohen Reifegrad erreicht, so dass der Umfang für die meisten Aufgaben mehr als ausreichend ist. Entwickeln mit den ‚Basics‘ macht wieder Spaß.

Eine Spezifikation von Spezifikationen

Rufen wir uns noch mal kurz ins Gedächtnis, was die Java EE eigentlich ist: Diese ‚Dach-Spezifikation‘ umklammert gut drei Dutzend einzelne Spezifikationen für unterschiedlichste Bereiche der Anwendungsentwicklung mit Java. Im Kern zielt sie auf gemanagte Umgebungen, d. h. Anwendungen, die in einem Applikationsserver laufen. Es sind allerdings auch viele Teilspezifikationen darunter, die außerhalb eines Servers verwendet werden können, was auch ein Ausdruck der zunehmenden Leichtgewichtigkeit der Java EE ist. Dieser Artikel kann nicht die gesamte Plattform umfassen, erst recht nicht auf alle Neuerungen im Detail eingehen. Beschränken wir uns also für’s Erste auf die Highlights im klassischen (Web-)Anwendungs-Stack.

Die Anwendungsaufteilung in diesem Stack ist trivial: Die Geschäftslogik wird in Form von Enterprise JavaBeans (EJBs) programmiert, wobei die nahezu immer notwendigen Datenbankzugriffe mittels Java Persistence API (JPA) erfolgen. Soll die Anwendung eine Web-Oberfläche besitzen, sind dafür JavaServer Faces (JSF) Mittel der Wahl, die technisch im Servlet-Container ablaufen.

Daten an der Basis

Fangen wir mal unten an, an der Datenbank. Die ist in aller Regel relational. Da wir objektorientiert zugreifen wollen, kommen O/R-Mapper wie Hibernate oder EclipseLink ins Spiel. Seit Java EE 5 ist für deren Nutzung das Abstraktionslayer JPA im Standard vorhanden. Wie in fast allen Bereichen der Java EE begegnen uns hier einfache Java-Objekte, die mittels Annotationen (oder alternativem XML) um Persistenz-Metadaten angereichert sind:

  1. @Entity
  2. public class ApplicationProperty
  3. {
  4. @Id
  5. private String id;
  6. private String value;
  7. }

Fehlende Angaben – im Beispiel Tabellen- und Spaltennamen – werden per Convention over Configuration mit sinnvollen Defaults besetzt. Diese einfachen Objekte können dann mit Hilfe des sog. Entitymanagers in die Datenbank gespeichert bzw. von dort gelesen werden:

  1. ApplicationProperty aprop = …;
  2. entityManager.persist(aprop);

Objektstrukturen wie Relationen oder Ableitungshierarchien können mit JPA problemlos abgebildet werden. Für Suchanfragen existiert eine SQL-ähnliche, relationsübergreifende Abfragesprache. Die Integration von JPA 1.0 in die Java EE 5 war zweifellos ein bahnbrechender Fortschritt, was die überwiegend positive Resonanz der Entwicklergemeinde zeigte. JPA 2.0 schließt nun viele verbliebene Lücken und kommt in seinem Umfang mit proprietären O/R-Mappern gleich auf.

Die Neuerungen sind recht zahlreich, so dass hier nur einige angesprochen werden können. Eine wesentliche Ergänzung sind die Criteria Queries, mit denen es möglich ist, dynamische Suchabfragen strukturiert, API-gestützt zu erzeugen. Ein lästiges Problem beseitigt das sog. Orphan Removal. Hiermit wird die Abbildung abhängiger Objekte über 1:n- oder n:m-Relationen möglich, wobei abhängige Einträge automatisch gelöscht werden, wenn sie nicht mehr referenziert werden. Ein weiteres Ärgernis war, dass in einer Entity-ID (d. h. im Primärschlüssel) keine Referenzen zu anderen Entities verwendet werden konnten. Dies ist mit JPA 2.0 nun möglich.

Teil 1   Teil 2   

Anzeige

Kommentare

Gravatar Peter Rossbach 20.12.2009
um 19:27 Uhr
Leider stimmt die Servlet Annotation nicht mit der offiziellen Final Servlet Spezifikation 3.0 (Dezember 2009) überein, sondern enthält den abgelehnten Vorschlag aus dem Jahr 2008.

Korrekt ist folgende Notation:

@WebServlet(name=”MyServlet”, urlPatterns={"/foo", "/bar"})
public class SampleUsingAnnotationAttributes extends HttpServlet{
public void doGet(HttpServletRequest req, HttpServletResponse
res) {
}
}

--
Es macht keinen Sinn die HTTP Verben durch einen Funktionsnamen zu überlagern (s. REST Prinzipien).

Frohes Fest,
Peter Roßbach
#zitieren
Gravatar Trepper 21.12.2009
um 08:50 Uhr
Annotationen sind wirklich eine schlimme Seuche geworden! Das Servlet-API entsprach von Anfang sehr schön dem REST-Modell. Was ist so schlecht daran, Methoden einen bestimmten Namen (nämlich den aus der Oberklasse) zu geben? Wo ist der Vorteil @Get an eine beliebig benannte Methode, die sowieso einer bestimmten Signatur entsprechen muss, zu schreiben? Warum nicht einfach bei doGet bleiben? Nach dem XML-Hype kommt jetzt der Gegenhype und in 5 bis 10 Jahren hat sich dann vielleicht beides auf einem guten Niveau eingependelt. #zitieren
Gravatar Dirk Weil 04.01.2010
um 15:37 Uhr
Annotationen sollten der Vereinfachung dienen und nicht Ersatz für (normale) Programmkonstrukte sein. Das wird mit @Webservlet anstelle eines Deployment-Descriptor-Eintrags durchaus erreicht.

Zur 'Seuche' werden Annotationen erst, wenn sie in Massen auftreten (siehe z.B. providerspezifische Annotationen im JPA-Bereich) oder Methoden unnötigerweise auszeichnen, wie dies @Get in meinem falschen Codebeispiel tut.

Sorry, dass mir das veraltete Beispiel 'durchgerutscht' ist und Danke an Peter Roßbach für die Korrektur.
#zitieren
Gravatar Marc Teufel 04.01.2010
um 20:48 Uhr
Hört, hört! Endlich sagts mal einer! Ganz so krass wie Trepper würde ich es zwar nicht ausdrücken, aber es stimmt schon, Annotationen können auch genau das Gegenteil bewirken und Sourcecode unübersichtlich machen... #zitieren
Gravatar Praktiker 11.02.2010
um 21:19 Uhr
Gut, dass so eine Quatsch-Annotation wie @Get nicht eingebaut wurde. Die macht nämlich so wenig Sinn wie @Test bei JUnit 4. #zitieren

Anzeige

zurück zum Seitenanfang