Java EE 7: WebSockets, Batch und JSON-P

Keine Zeit? Hier die Kurzversion in 30 Sekunden.
- Java EE 7 ist seit dem 12. Juni 2013 final, GlassFish 4 ist die Referenzimplementierung.
- Neu: WebSockets (JSR 356), JSON-Verarbeitung (JSON-P), Batch (JSR 352), dazu JAX-RS 2.0 mit Client-API und ein stark vereinfachtes JMS 2.0.
- Ein WebSocket-Endpoint besteht aus einer Klasse mit
@ServerEndpointund ein paar Annotationen, deutlich weniger Aufwand als eine Servlet-Lösung.- Meine Meinung: Java EE wird leichter und holt auf. Bis außer GlassFish andere Server die Version unterstützen, wird es aber noch dauern.
Am 12. Juni ist Java EE 7 final geworden, mit GlassFish 4 als Referenzimplementierung. Wie schon bei Version 6 geht es weniger um einen großen Wurf als um viele einzelne Verbesserungen, die zusammen ein spürbar angenehmeres Bild ergeben. Ich habe mir ein paar der Neuerungen angesehen, die ich am interessantesten finde, und bei einigen kurz mitgeschrieben, wie der Code aussieht.
WebSockets: ein Chat in einer Klasse
Mit JSR 356 gibt es endlich eine standardisierte API für WebSockets. Bisher war man auf herstellerspezifische Lösungen angewiesen, jetzt reicht eine annotierte Klasse:
import java.io.IOException;
import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
@ServerEndpoint("/chat")
public class ChatEndpoint {
@OnOpen
public void verbunden(Session session) {
System.out.println("Verbunden: " + session.getId());
}
@OnMessage
public void nachricht(String text, Session absender) throws IOException {
for (Session s : absender.getOpenSessions()) {
if (s.isOpen()) {
s.getBasicRemote().sendText(text);
}
}
}
@OnClose
public void geschlossen(Session session, CloseReason grund) {
System.out.println("Getrennt: " + session.getId());
}
}Die Klasse landet in der WAR-Datei, der Container findet sie beim Start selbst. @OnOpen wird bei jeder neuen Verbindung aufgerufen, @OnMessage bei jeder eingehenden Nachricht, und getOpenSessions() liefert alle Verbindungen zu diesem Endpoint. Das ist ein einfacher Chat, der jede Nachricht an alle weiterreicht. Auf der Browserseite genügt new WebSocket("ws://localhost:8080/app/chat") mit einem onmessage-Handler. Für mich der größte praktische Gewinn: keine Polling-Konstruktionen mehr für Dinge, die der Server von sich aus melden soll.
JSON-P: JSON ohne Fremdbibliothek
Bisher musste man sich für JSON zwischen Jackson, Gson und anderen Bibliotheken entscheiden. JSON-P (JSR 353) bringt eine kleine Standard-API mit, die zwei Stile kennt, ein Objektmodell und ein Streaming-Modell. Das Objektmodell reicht für das meiste:
JsonObject o = Json.createObjectBuilder()
.add("name", "Anna")
.add("alter", 31)
.add("tags", Json.createArrayBuilder().add("java").add("ee"))
.build();
String text = o.toString();
try (JsonReader reader = Json.createReader(new StringReader(text))) {
JsonObject gelesen = reader.readObject();
String name = gelesen.getString("name");
int alter = gelesen.getInt("alter");
}Das ist bewusst schlank. Es gibt keine automatische Abbildung auf eigene Klassen, wie man sie von Jackson oder Gson kennt. Man baut und liest die Struktur von Hand. Für kleine Nachrichten, etwa im WebSocket-Beispiel oben, ist das angenehm. Für große Datenmodelle würde ich weiterhin eine der bekannten Bibliotheken nehmen und JSON-P eher als Grundlage sehen, auf der später mehr entstehen kann.
Batch: Verarbeitung in Blöcken
Batch (JSR 352) war bisher die Lücke im Standard, man hat sich mit Spring Batch oder eigenen Lösungen beholfen. Das Prinzip ist vertraut: Ein Job besteht aus Schritten, und ein Schritt liest Datensätze ein, verarbeitet sie und schreibt sie blockweise (Chunks) wieder weg. Beschrieben wird das in einer Job-XML unter META-INF/batch-jobs/:
<job id="import" xmlns="http://xmlns.jcp.org/xml/ns/javaee" version="1.0">
<step id="lesen">
<chunk item-count="100">
<reader ref="kundenReader"/>
<processor ref="kundenProcessor"/>
<writer ref="kundenWriter"/>
</chunk>
</step>
</job>Die Bausteine sind Java-Klassen, die ItemReader, ItemProcessor und ItemWriter umsetzen oder die vorgefertigten abstrakten Basisklassen erweitern. Gestartet wird der Job mit BatchRuntime.getJobOperator().start("import", new Properties()). Nach jedem Block von 100 Einträgen wird ein Checkpoint gesetzt, damit ein abgebrochener Lauf nicht ganz von vorn anfangen muss. Ich habe das nur grob ausprobiert und kann zu Details wie Wiederanlauf oder Fehlerbehandlung noch nichts Fundiertes sagen.
JAX-RS 2.0 und JMS 2.0
Zwei Dinge fallen bei den bekannten Teilen auf. JAX-RS 2.0 hat jetzt eine Client-API, mit der man REST-Dienste aufrufen kann, ohne selbst mit HttpURLConnection zu hantieren:
Client client = ClientBuilder.newClient();
String antwort = client.target("http://localhost:8080/api")
.path("kunden").path("{id}")
.resolveTemplate("id", 42)
.request("application/json")
.get(String.class);
client.close();Und JMS 2.0 ist deutlich entschlackt. Wo man früher Connection, Session und Producer einzeln anlegen musste, genügt jetzt ein injizierter Kontext:
@Inject
private JMSContext context;
@Resource(lookup = "jms/Auftraege")
private Queue queue;
public void senden(String text) {
context.createProducer().send(queue, text);
}Das ist ein Beispiel für das, was ich an Java EE 7 mag: nicht neue Konzepte, sondern weniger Zeremonie bei bestehenden. Wer schon einmal eine JMS-Nachricht in der alten Form verschickt hat, mit Factory, Connection, Session, Producer und einem finally-Block zum Aufräumen, weiß, wie viel Textbaustein dabei wegfällt. Der Kontext kümmert sich um das Schließen, und die Transaktion kommt vom Container.
Meine Einschätzung
Java EE hatte lange den Ruf, schwerfällig zu sein, und der war zu Zeiten von EJB 2 nicht ganz unverdient. Seit Version 6 und jetzt mit 7 ändert sich das, die Annotationen, CDI und die vereinfachten APIs sorgen dafür, dass man mit wenig Code auskommt. Im Vergleich zu Spring, das lange der pragmatische Gegenentwurf war, ist die Lücke deutlich kleiner geworden. Spring hat nach wie vor Vorteile: ein großes Ökosystem, eine lange Praxis mit Werkzeugen und einen Container, der nicht an einen Anwendungsserver gebunden ist. Java EE punktet dafür mit einem Standard, der von mehreren Herstellern getragen wird, und mit einer Spezifikation, die dokumentiert, was man bekommt.
Der Haken ist die Realität im Betrieb. Java EE 7 gibt es bisher mit GlassFish 4, bei den anderen Anwendungsservern dürfte es eine Weile dauern, bis die Zertifizierung abgeschlossen ist und die Produkte in Firmen ankommen. Wer in der Praxis auf einem Server der Vorversion läuft, wird die neuen APIs vorerst nur in Experimenten sehen. Auch die Werkzeuge müssen erst folgen: Die Unterstützung in den Entwicklungsumgebungen ist noch dünn, und manches Beispiel im Netz bezieht sich auf Entwurfsstände, die sich im Detail von der finalen Fassung unterscheiden. Man sollte sich also nicht wundern, wenn eine Anleitung von vor ein paar Monaten nicht mehr ganz passt. Mein Rat: GlassFish 4 herunterladen, die WebSocket-Klasse oben ausprobieren, und dann in Ruhe beobachten, wie schnell die anderen nachziehen.
Beitragsbild: Oracle PR, Wikimedia Commons, CC BY 2.0, zugeschnitten.
Christian Ackermann
Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.