Java EE

t
el
nd 6
ha EE
Be ava
J
O’Reillys Taschenbibliothek
Java EE
kurz & gut
O’REILLY
Arun Gupta
Übersetzung von Thomas Demmig
Java EE
kurz & gut
Arun Gupta
Deutsche Übersetzung von
Thomas Demmig
Beijing Cambridge Farnham Köln Sebastopol Tokyo
Die Informationen in diesem Buch wurden mit größter Sorgfalt erarbeitet. Dennoch
können Fehler nicht vollständig ausgeschlossen werden. Verlag, Autoren und
Übersetzer übernehmen keine juristische Verantwortung oder irgendeine Haftung
für eventuell verbliebene Fehler und deren Folgen.
Alle Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt und sind möglicherweise eingetragene Warenzeichen. Der Verlag richtet
sich im Wesentlichen nach den Schreibweisen der Hersteller. Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie
Einspeicherung und Verarbeitung in elektronischen Systemen.
Kommentare und Fragen können Sie gerne an uns richten:
O’Reilly Verlag GmbH & Co. KG
Balthasarstr. 81
50670 Köln
E-Mail: [email protected]
Copyright der deutschen Ausgabe:
2012 O’Reilly Verlag GmbH & Co. KG
1. Auflage 2012
Die Originalausgabe erschien 2012 unter dem Titel Java EE 6 Pocket Guide bei
O’Reilly Media, Inc.
Bibliografische Information Der Deutschen Nationalbibliothek
Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen
Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über
http://dnb.d-nb.de abrufbar.
Übersetzung: Thomas Demmig, Mannheim
Lektorat: Alexandra Follenius, Köln
Korrektorat: Eike Nitz, Köln
Produktion: Karin Driesen, Köln
Umschlaggestaltung: Karen Montgomery und Michael Oreal
Satz: Reemers Publishing Services GmbH, Krefeld, www.reemers.de,
Druck: fgb freiburger graphische betriebe; www.fgb.de
ISBN: 978-3-86899-958-7
Dieses Buch ist auf 100% chlorfrei gebleichtem Papier gedruckt.
Für Menka,
meine geliebte Frau und
beste Freundin.
Deine Unterstützung und
deine Ermutigung sorgen
dafür, dass unser Leben
Spaß macht und Sinn hat.
Für
Aditya und Mihir,
meine zwei fröhlichen
Jungs, die mit mir spielen
und mich aktiv halten.
Inhalt
Vorwort ........................................................................
IX
1
Java Platform, Enterprise Edition .....................................
Einführung .................................................................
Deliverables ................................................................
Was ist neu in Java EE 6 ..................................................
1
Managed Beans ..........................................................
Ein Managed Bean definieren und einsetzen ............................
Lifecycle Callback ..........................................................
13
Servlets ....................................................................
Servlets .....................................................................
Servletfilter .................................................................
Event Listener ..............................................................
Asynchrone Unterstützung ................................................
Web Fragments ............................................................
Security .....................................................................
Resource Packaging........................................................
Error Mapping..............................................................
Umgang mit Multipart Requests ..........................................
17
Java Persistence API ....................................................
Entitäten ...................................................................
Persistence Unit, Persistence Context und Entity Manager ..............
Entitäten erstellen, lesen, aktualisieren und löschen ....................
Entitäten validieren ........................................................
Transaktionen und Locking................................................
Caching .....................................................................
41
2
3
4
1
4
8
14
15
17
23
25
29
31
33
36
37
38
41
45
48
52
55
56
| V
5
Enterprise JavaBeans .................................................... 59
Stateful Session Beans ..................................................... 60
Stateless Session Beans .................................................... 62
Singleton Session Beans.................................................... 64
Message-driven Beans ...................................................... 66
Portable Global JNDI Names ............................................... 68
Transaktionen ............................................................... 69
Asynchron ................................................................... 72
Timer ........................................................................ 73
Embeddable API ............................................................ 78
EJB.Lite ...................................................................... 79
6
Contexts and Dependency Injection ................................... 81
Injection Points ............................................................. 82
Qualifier und Alternative ................................................... 83
Producer und Disposer ..................................................... 86
Interceptor und Decorator .................................................. 88
Scopes und Kontexte ....................................................... 92
Stereotype................................................................... 94
Events ....................................................................... 96
Portable Erweiterungen .................................................... 98
7
JavaServer Faces ..........................................................
Facelets......................................................................
Ressourcen-Handling .......................................................
Composite Components ....................................................
Ajax..........................................................................
HTTP GET ....................................................................
Server und Client Extension Points ........................................
Navigationsregeln ..........................................................
101
SOAP-basierte Webservices..............................................
Webservice-Endpoints ......................................................
Provider-basierte Dynamic Endpoints......................................
Endpoint-basierte Endpoints ...............................................
Webservice-Client ...........................................................
Dispatch-basierter dynamischer Client.....................................
Handler ......................................................................
123
8
VI | Inhalt
102
106
107
112
115
117
120
125
128
130
131
134
136
9
RESTful Webservices.....................................................
Einfache RESTful Webservices .............................................
HTTP-Methoden binden ...................................................
Mehrere Ressourcendarstellungen ........................................
Requests an eine Ressource binden ......................................
Exception Mapping ........................................................
139
10 Java Message Service ...................................................
Eine Nachricht verschicken ................................................
Quality of Service ..........................................................
Eine Nachricht synchron empfangen .....................................
Eine Nachricht asynchron empfangen ....................................
Temporäre Ziele............................................................
151
11 Bean Validation ..........................................................
Eingebaute Constraints ....................................................
Einen eigenen Constraint definieren ......................................
Validierungsgruppen .......................................................
Integration mit JPA ........................................................
Integration mit JSF ........................................................
163
140
142
145
146
149
154
156
157
159
161
164
167
171
174
176
Anhang A: Entwicklungsumgebung und Deployment für Java EE 6 .. 179
Anhang B: Weitere Literatur ................................................ 181
Index ............................................................................ 185
Inhalt | VII
Vorwort
Die Java EE 6-Plattform hat die einfache Entwicklung mit Java im
Enterprise-Umfeld auf eine neue Ebene gehoben. Dieses Buch richtet sich an Leute, die einen schnellen Überblick über die Plattform
erhalten wollen, um danach die Grundlagen zu erlernen.
Das Buch bietet einen Überblick über die Schlüsselspezifikationen
der Java EE 6-Plattform (eine Spezifikation pro Kapitel). Die wichtigsten Konzepte der verschiedenen Spezifikationen werden erklärt
und Beispiele dazu vorgestellt. Sie müssen nichts über frühere Versionen der Plattform wissen. Allerdings ist ein grundlegendes Verständnis von Java notwendig, um den Code zu verstehen.
In diesem Buch genutzte Konventionen
Die folgenden typographischen Konventionen werden in diesem
Buch verwendet:
Kursiv
Steht für neue Begriffe, URLs, E-Mail-Adressen, Dateinamen
und Dateierweiterungen.
Nichtproportionalschrift
Wird für Programmcode genutzt – auch innerhalb von Fließtext
–, um auf Programmelemente wie Variablen- oder Funktionsnamen, Datenbanken, Datentypen, Umgebungsvariablen, Anweisungen und Schlüsselwörter hinzuweisen.
Kursive Nichtproportionalschrift
Zeigt Text an, der durch eigene Werte oder kontextabhängige
Werte ersetzt werden sollte.
| IX
Danksagungen
Dieses Buch wäre nicht möglich geworden ohne die Unterstützung
von sehr vielen Leuten.
Zu allererst bedanke ich mich bei O’Reilly für das Vertrauen in mich
und für die Möglichkeit, dieses Buch zu schreiben. Ihr Team hat
mich beim Schreiben, Überarbeiten, Korrekturlesen und Veröffentlichen exzellent unterstützt.
Bei O’Reilly hat mir Michael Loukides geholfen, die Grundlagen für
das Buch zu legen. Meghan Blanchette war in allen Phasen der
Entstehung eine außerordentlich große Hilfe, indem sie den Text
schon zwischendurch begutachtete, Feedback zur Darstellung gab,
Fachlektoren organisierte und mich bei Bedarf mit den richtigen
Ansprechpartnern im Team zusammenbrachte. Jessica Hosman hat
mir beim Einstieg in das Autorenleben geholfen und mich weiter
begleitet.
Emily Quill und Kristen Borg haben beim Lektorieren geholfen und
sichergestellt, dass auch die Kleinigkeiten stimmen. Vielen Dank
auch an die anderen Mitglieder des O’Reilly-Teams, mit denen ich
nicht direkt zu tun hatte, die aber auch zum Gelingen des Buchs
beigetragen haben.
Das Korrekturlesen und das Fachlektorat wurden von Markus Eisele
(@myfear, http://blog.eisele.net), John Yeary (@jyeary, http://javaevangelist.blogspot.com) und Bert Ertman (@BertErtman, http://bertertman.wordpress.com) vorgenommen, so dass sichergestellt ist, dass
die entscheidenden Dinge auch richtig dargestellt sind. Ihre umfangreiche Erfahrung und ihr Wissen haben sich an der Tiefe ihrer Kommentare gezeigt.
Ich bin Entwicklern auf der ganzen Welt für die zahlreichen Diskussionen dankbar, die mein Verständnis der Technologie verbessert haben. Vielen Dank meinen Kollegen bei Oracle und den JSR
Specification Leads, die mir die Anwendungsfälle der verschiedenen
Technologien erklärt haben. Und vielen Dank an jeden anderen in
meinem Leben, der mir die nötigen Pausen von Schreiben verschafft
hat.
X | Vorwort
KAPITEL 1
Java Platform,
Enterprise Edition
Einführung
Die Java Platform, Enterprise Edition (Java EE) bietet eine auf
Standards aufbauende Plattform für das Entwickeln von Web- und
Enterprise-Anwendungen. Diese Applikationen sind im Allgemeinen als Multitier-Anwendungen entworfen – mit einer Frontend-Schicht bestehend aus Web-Frameworks, einer MiddlewareSchicht, die sich um die Sicherheit und Transaktionen kümmert,
und einer Backend-Schicht, die die Verbindung zu einer Datenbank
oder einem Legacy-System umsetzt. Die Java EE Platform definiert
APIs für die verschiedenen Komponenten in jeder Schicht und
bietet dazu weitere Dienste an, zum Beispiel Namensräume, Einbinden und Ressourcenverwaltung, die für die gesamte Plattform
genutzt werden können. Jede Komponente ist in einer eigenen Spezifikation definiert, die auch die API, Javadocs und das erwartete
Verhalten beschreibt.
Die Java Platform, Enterprise Edition 6 (Java EE 6) wurde im Dezember 2009 veröffentlicht. Sie bietet einen einfachen, leicht zu
verwendenden Stack für das Bauen solcher Anwendungen. In der
älteren Version der Plattform (Java EE 5) gab es die ersten Schritte
für eine vereinfachte Entwicklung. Die Java EE 6 Platform sorgt für
eine noch bessere Produktivität und bietet viel mehr Funktionalität.
| 1
Die drei wichtigsten Ziele der Plattform sind folgende:
Einfache Anwendung
Die Java EE 6 Platform vereinfacht die Entwicklung erneut
drastisch, indem sie sehr oft Konvention statt Konfiguration
einsetzt und auf Annotationen für ein Plain Old Java Object
(POJO) zurückgreift. Indem Sie ein POJO um @Stateless,
@Stateful oder @Singleton ergänzen, machen Sie es zu einem
Enterprise JavaBean. Zudem lässt sich dies einfach in einer
WAR-Datei verpacken, statt eine Spezialvariante von JAR oder
EAR zu verwenden. Servlets sind ebenfalls POJOs, versehen mit
der Annotation @WebServlet. Deployment Descriptors wie
web.xml und faces-config.xml sind in den meisten Fällen optional – die Informationen, die im Allgemeinen in ihnen abgelegt sind, finden sich nun in Annotationen. Es gibt Standardregeln, wie man von einer JSF-Seite zu einer anderen navigiert.
Um ein POJO als REST-Webservice zu veröffentlichen, muss
man nur die Annotation @Path ergänzen.
Indem die Deployment Descriptors optional wurden, Konvention der Konfiguration vorgezogen und stark auf Annontationen aufgebaut wurde, lässt sich die Java EE 6 Platform einfacher
verwenden und es muss insgesamt auch weniger geschrieben
werden.
Leichtgewichtigkeit
Es gibt für die Java EE 6 Platform 31 Komponentenspezifikationen, die Sie im Anhang EE.6 der Plattformspezifikation finden.
Zu diesen Komponenten gehören Enterprise JavaBeans (EJB),
Servlets, JavaServer Faces (JSF), Java API for RESTful Web
Services (JAX-RS) und viele weitere. Für den Bau einer typischen Enterprise-Anwendung werden Sie nicht unbedingt alle
benötigen. Zudem waren manche der Technologien wie Java
API for XML Registries (JAXR) oder Java API for XML-based
RPC (JAX-RPC) zwar wichtig, als sie in die Plattform eingebracht wurden. Aber nun wurden sie durch bessere Komponenten ersetzt, zum Beispiel Java API for XML Web Services (JAXWS), oder sind nicht mehr im Einsatz.
2 | Kapitel 1: Java Platform, Enterprise Edition
Die Java SE Expert Group hat einen zweistufigen Prozess
definiert, mit dem Features von der Plattform genommen wurden. In diesem Prozess – als Pruning bezeichnet – wird ein
Feature in einem Release als optional gekennzeichnet (proposed
optional). In einem folgenden Release wird dann entschieden,
das Feature tatsächlich zu entfernen, es als erforderliche Komponente beizubehalten oder es im Status proposed removal zu
belassen. Die Java EE Expert Group hat einige Features mit
diesem Prozess behandelt. Das ist wie das Beschneiden eines
Rosenstrauchs im Frühjahr, damit neue Blüten wachsen können: Durch das Pruning von ungenutzten Features wird sichergestellt, dass trotz Hinzufügen neuer Features die Plattform
einfach und leichtgewichtig bleibt.
Die Java EE Platform führt auch den Begriff des Profils ein. Ein
Profil ist eine Konfiguration auf der Plattform, die an eine
bestimmte Klasse von Anwendungen angepasst ist. Dabei kann
es sich um eine Unter- oder Obermenge der Technologien auf
der Plattform handeln. Das Java EE 6 Web Profile ist als eigenständige Spezifikation für die Plattform definiert, wobei es sich
um eine Untermenge der Technologien der Plattform handelt.
Es ist für die Entwicklung moderner Webanwendungen angepasst. Damit fällt der »One Size Fits All«-Ansatz früherer Releases weg. Und auch wenn es sich »nur« um eine Untermenge
handelt, ist diese doch so umfassend, dass ein Großteil der
Standard-APIs enthalten ist und ohne Anpassungen viele unterschiedliche Web-Anwendungen damit geschrieben werden
können. Das Webprofil ermöglicht es dem Entwickler, WebAnwendungen schnell bauen zu können. Zudem wird verhindert, dass immer mehr eigene Web-Stacks entstehen, welche in
Bezug auf Wartungsfragen nur von Nachteil sein können. Weitere Profile können definiert werden, indem man dem Java
Community Process (JCP) folgt.
Durch Pruning und Web-Profile bleibt die Java EE 6 Platform
also leichtgewichtig und gut wartbar.
Erweiterbarkeit
Die Plattform bietet eine umfangreiche Sammlung an Funktionen an, um Enterprise-Anwendungen zu erstellen. Trotzdem
Einführung | 3
wird häufig auf Third-Party-Frameworks zurückgegriffen, um
Funktionalität zu ersetzen oder zu ergänzen. Diese Frameworks
müssen über einen ServletListener, einen ServletFilter oder
eine ähnliche Komponente registriert werden, damit die Laufzeitumgebung sie erkennen kann. Die Servlet-Spezifikation definiert einen Web Fragment-Mechanismus, über den diese Einstiegspunkte in das Framework in der Framework-Bibliothek
definiert werden. Die Servlet-Container registrieren dann das
Framework, so dass sich der Entwickler nicht darum kümmern
muss. So können die Frameworks wie ein integraler Bestandteil
der Plattform behandelt werden.
Zusätzlich definiert die Contexts and Dependency Injection
(CDI) Specification einen portablen Erweiterungsmechanismus,
mit dem Sie die Plattform in unterschiedlicher Art und Weise
ausbauen können – zum Beispiel durch das Bereitstellen bestimmter, vordefinierter Scopes. Ein neuer Scope kann dadurch
mit einem beliebigen Java EE 6-kompatiblen Anwendungsserver einfach definiert und eingebunden werden.
Spezifikationen wie CDI, JavaServer Faces 2, Java API for RESTful
Services, Java Persistence API 2 und Servlets 3 sorgen dafür, dass die
Java EE 6 Platform noch leistungsfähiger ist. Dieses Buch bietet
einen Überblick über die wichtigsten Technologien, die auf der
Plattform eingesetzt werden, sowie leicht verständliche Codebeispiele, mit denen die Verbesserungen von Java EE 6 erläutert werden.
Deliverables
Die Java EE 6 Platform wurde als Java Specification Request 316
bzw. JSR 316 entwickelt (http://jcp.org/en/jsr/detail?id=316), wobei
dem Java Community Process (JCP) 2.7 gefolgt wurde. Der JCP
definiert drei wichtige Deliverables für jeden JSR:
Spezifikation
Ein formales Dokument, das die vorgeschlagene Komponente
und ihre Features beschreibt.
4 | Kapitel 1: Java Platform, Enterprise Edition
Reference Implementation (RI)
Die binäre Implementierung der vorgeschlagenen Spezifikation.
Die RI hilft dabei, sicherzustellen, dass die vorgeschlagenen Spezifikationen in Binärform implementiert werden können. Zudem
erhält der Spezifikationsprozess so konstant Rückmeldung.
Technology Compliance Kit (TCK)
Eine Sammlung von Tests, die sicherstellen, dass die RI zur
Spezifikation passt. So können mehrere Hersteller konforme
Implementierungen liefern.
Java EE 6 besteht aus der Plattform-Spezifikation, die die Anforderungen definiert. Zudem enthält sie folgende Komponenten-Spezifikationen:
Web-Technologien
– JSR 45: Debugging Support for Other Languages
– JSR 52: Standard Tag Library for JavaServer Pages (JSTL)1.2
– JSR 245: JavaServer Pages (JSP) 2.2 and Expression
Language (EL) 1.2
– JSR 314: JavaServer Faces (JSF) 2.0
– JSR 315: Servlet 3.0
Enterprise-Technologien
– JSR 250: Common Annotations for the Java Platform 1.1
–
JSR 299: Contexts and Dependency Injection (CDI) for
the Java EE Platform 1.0
–
JSR 303: Bean Validation 1.0
–
JSR 316: Managed Beans 1.0
–
JSR 317: Java Persistence API (JPA) 2.0
–
JSR 318: Enterprise JavaBeans (EJB) 3.1
–
JSR 318: Interceptors 1.1
–
JSR 322: Java EE Connector Architecture 1.6
–
JSR 330: Dependency Injection for Java 1.0
–
JSR 907: Java Transaction API ( JTA) 1.1
–
JSR 914: Java Message Server (JMS) 1.1
–
JSR 919: JavaMail 1.4
Deliverables | 5
Webservice-Technologien
– JSR 67: Java APIs for XML Messaging (JAXM) 1.3
– JSR 93: Java API for XML Registries (JAXR) 1.0
– JSR 101: Java API for XML-based RPC (JAX- RPC) 1.1
– JSR 109: Implementing Enterprise Web Services 1.3
– JSR 173: Streaming API for XML (StAX) 1.0
– JSR 181: Web Services Metadata for the Java Platform 2.0
– JSR 222: Java Architecture for XML Binding (JAXB) 2.2
– JSR 224: Java API for XML Web Services (JAX- WS) 2.2
– JSR 311: Java API for RESTful Web Services (JAX-RS) 1.1
Verwaltungs- und Sicherheitstechnologien
– JSR 77: J2EE Management API 1.1
– JSR 88: Java Platform EE Application Deployment API 1.2
– JSR 115: Java Authorization Contract and Containers
(JACC) 1.3
– JSR 196: Java Authentication Service Provider Interface for
Containers (JASPIC) 1.0
Die einzelnen Komponeten arbeiten zusammen, um einen kombinierten Stack bereitzustellen (siehe Abbildung 1-1).
CDI
Extensions
Web
Fragments
JAX-RS
JAX-WS
JSP
EL
JSF
CDI
Interceptors
Common Annotations
Managed Beans
JPA
EJB
JTA
Abbildung 1-1: Java EE 6-Architektur
6 | Kapitel 1: Java Platform, Enterprise Edition
JMS
Bean Validation
Servlets
Was ist in Abbildung 1-1 zu sehen?
• JPA, JTA und JMS stellen die grundlegenden Dienste bereit,
wie zum Beispiel Datenbankzugriff, Transaktionen und Messaging.
• Managed Beans und EJB liefern ein vereinfachtes Programmiermodell, das POJOs nutzt, um auf die grundlegenden
Dienste zugreifen zu können.
• CDI, Interceptors und Common Annotations bieten Konzepte, die sich auf eine Vielzahl von Komponenten anwenden
lassen, wie zum Beispiel typsichere Dependency Injection, das
Ansprechen von Cross-Cutting Concerns über Interceptors
und eine gemeinsame Menge von Annotationen.
• CDI Extensions ermöglicht Ihnen, die Plattform standardisiert
über die vorhandenen Features hinaus zu erweitern.
• Webservices verwenden JAX-RS und JAX-WS. JSF, JSP und
EL definieren das Programmiermodell für Webanwendungen.
Web Fragments erlauben eine sehr natürlich umgesetzte automatische Registrierung von Web-Frameworks von Fremdfirmen.
• Bean Validation ermöglicht ein Standardvorgehen zum Deklarieren von Constraints und zum Validieren in verschiedenen
Technologien.
JAX-RPC (JSR 101), JAXR ( JSR 93), EJB Entity Beans (Teil von JSR
153) und Java EE Application Deployment (JSR 88) sind in dieser
Version der Plattform für das Pruning markiert.
Die RI von Java EE 6 wird in der GlassFish-Community gebaut. Die
GlassFish Server Open Source Edition bietet einen vollständig Java
EE 6-konformen, freien Open Source-Anwendungsserver. Sie ist
auch in einer Web Profile-Distribution verfügbar und kann unter
http://glassfish.org heruntergeladen werden. Der Anwendungsserver
lässt sich einfach einsetzen (ZIP-Installer und NetBeans/Eclipse/
IntelliJ-Integration), ist leichtgewichtig (die Download-Größe beginnt bei 30 MByte und der Platzverbrauch auf der Festplatte und
im Speicher ist gering) und modular (OSGi-basiert, Container starten bei Bedarf). Es gibt auch ein hochverfügbares Clustering mit
Deliverables | 7
zentraler Administration per CLI, einer webbasierten Administrationskonsole und REST-Management/Monitoring-APIs. Der Oracle
GlassFish Server ist Oracles kommerzielle GlassFish-Serverdistribution, die unter http://oracle.com/goto/glassfish heruntergeladen
werden kann. Während diese Zeilen entstehen, gibt es 17 Java
EE 6-konforme Anwendungsserver. Die vollständige Liste finden
Sie unter http://www.oracle.com/technetwork/java/javaee/overview/
compatibility-jsp-136984.html.
Das TCK steht allen Java EE-Lizenznehmern zur Verfügung, um
ihre Implementierungen zu testen.
Was ist neu in Java EE 6
Die Plattform wurde um ein paar neue Spezifikationen erweitert,
um ihre Funktionalität und Reichhaltigkeit zu erhöhen. Eine Reihe
bestehender Komponenten-Spezifikationen wurden überarbeitet,
um sie einfacher einsetzbar zu machen.
Die wichtigsten Features der zentralen Spezifikationen sind hier beschrieben:
Managed Beans
– POJO-basierte verwaltete Komponenten
– Eine gemeinsame Sammlung an Diensten, zum Beispiel eine
Lifecycle Resource Injection, Callbacks und Interceptors.
Enterprise JavaBeans
– Ein EJB kann mit einer einzelnen Quelldatei pro Bean
erzeugt und mit @Stateless, @Stateful oder @Singleton annotiert werden.
– EJBs können für den lokalen Zugriff in einem .war verpackt
werden, wobei @Local und ejb-jar für den lokalen und
Remote Access genutzt werden.
– EJBs lassen sich über einen portablen, globalen JNDINamen ansprechen.
– Eine Methode eines Session-Bean kann so gekennzeichnet
werden, dass es asynchron aufgerufen wird. Diese Metho-
8 | Kapitel 1: Java Platform, Enterprise Edition
den erlauben dem Client, den Rückgabewert später abzurufen oder das Fire-and-Forget-Muster zu nutzen.
– Zeitabhängige Events können mit einer cron-ähnlichen
Syntax eingeplant werden, indem @Schedule für Bean-Methoden definiert wird.
– Die Embeddable EJB API ermöglicht es Client-Code und
seinen zugehörigen Enterprise Beans, innerhalb der gleichen JVM und des gleichen Class Loaders zu laufen.
Servlets
– Annotationsgesteuerte Servlets (@WebServlet), Filter (@WebFilter) und Listener (@WebListener). Der Descriptor
web.xml wird in den meisten Fällen optional.
– Servlets, Filter und Listener können per Programm über
ServletContext registriert werden.
– Asynchrone Servlets ermöglichen es dem Control (oder
Thread), zum Container zurückzukehren, um andere Aufgaben zu erledigen, während darauf gewartet wird, dass ein
lange laufender Prozess endet.
– Framework-Bibliotheken können modular über web-fragment.xml integriert werden.
– Die
Servlet-Sicherheit lässt sich neben <securityconstraint> auch über @Servlet Security, @HttpConstraint
und @HttpMethodConstraint definieren.
Java API for RESTful Web Services
– POJO-basierte und annotationsgesteuerte Möglichkeit,
REST-Webservices zu veröffentlichen
– Ein Standard-Set von HTTP-Methoden wie GET, POST,
PUT und DELETE wird unterstützt.
– Jede Ressource kann in mehreren Formaten ausgegeben
werden; es werden auch eigene Typen unterstützt.
– Clientseitige Content Negotiation wird durch den HTTPHeader Accept: unterstützt.
Was ist neu in Java EE 6 | 9