Java Enterprise – eine Übersicht

Wenn Sie sich mit Java Enterprise beschäftigen möchten, mag es anfangs etwas überwältigend und verwirrend wirken. Aber keine Sorge, es ist nicht so schlimm, wie es scheint. Für den Anfang genügen grundlegende Kenntnisse über die Ideen und Konzepte.

Die Java Serie

zuletzt geändert::

Da Java EE weder ein Werkzeug noch ein Compiler ist, den man wie das Java Development Kit (JDK), auch bekannt als Software Development Kit (SDK), herunterlädt und verwendet, handelt es sich bei Java Enterprise um eine Reihe von Spezifikationen. Diese Spezifikationen werden durch eine API unterstützt, die wiederum eine Referenzimplementierung besitzt. Die Referenzimplementierung ist ein herunterladbares Paket namens Application Server.

Seit Java EE 8 wird Java Enterprise von der Eclipse Foundation gepflegt. Oracle und die Eclipse Foundation konnten sich nicht auf eine gemeinsame Vereinbarung zur Nutzung der Marke Java einigen, die Oracle gehört. Kurz gesagt: Die Eclipse Foundation benannte Java EE in Jakarta EE um. Dies hat auch Auswirkungen auf ältere Projekte, da sich in Jakarta EE 9 die Paketpfade von javax zu jakarta geändert haben. Jakarta EE 9.1 aktualisiert alle Komponenten von JDK 8 auf JDK 11.

Für die Entwicklung von Jakarta Enterprise [1]-Anwendungen sind einige Voraussetzungen erforderlich. Zunächst muss die richtige JDK-Version ausgewählt werden. Die Laufzeitumgebung Java Virtual Machine (JVM) ist bereits im JDK enthalten und muss nicht separat installiert werden. Eine gute Wahl ist stets die neueste LTS-Version. Java 17 JDK wurde 2021 veröffentlicht und wird bis 2024 unterstützt.

Um die Oracle-Lizenzbeschränkungen zu umgehen, können Sie auf eine freie Open-Source-Implementierung des JDK umsteigen. Eine der bekanntesten freien Varianten ist OpenJDK von adoptium [2]. Eine weitere interessante Implementierung ist GraalVM [3], das auf OpenJDK basiert. Die Enterprise Edition von GraalVM kann Ihre Anwendung um das 1,3-Fache beschleunigen. Für den Produktiveinsatz ist eine kommerzielle Lizenz der Enterprise Edition erforderlich. GraalVM enthält außerdem einen eigenen Compiler.

  Version  Year  JSR  Servlet  Tomcat  JavaSE
J2EE – 1.21999
J2EE – 1.32001JSR 58
J2EE – 1.42003JSR 151
Java EE 52006JSR 244
Java EE 62009JSR 316
Java EE 72013JSR 342
Java EE 82017JSR 366
Jakarta 820194.09.08
Jakarta 920205.010.08 & 11
Jakarta 9.120215.010.011
Jakarta 1020226.010.111
Jakarta 1120236.111.017
Jakarta 12under development6.221

Die obige Tabelle ist nicht vollständig, enthält aber die wichtigsten aktuellen Versionen. Sollten Ihnen weitere Informationen fehlen, schreiben Sie mir gerne eine Nachricht.

Bitte beachten Sie, dass die Jakarta EE-Spezifikation ein bestimmtes Java SDK benötigt und der Anwendungsserver möglicherweise ein anderes Java JDK als Laufzeitumgebung benötigt. Die beiden Java-Versionen müssen nicht identisch sein.

Dependencies (Maven):

<dependency>
    <groupId>jakarta.platform</groupId>
    <artifactId>jakarta.jakartaee-api</artifactId>
    <version>${version}</version>
    <scope>provided</scope>
</dependency> 
<dependency>
    <groupId>org.eclipse.microprofile</groupId>
    <artifactId>microprofile</artifactId> 
    <version>${version}</version>
    <type>pom</type>
    <scope>provided</scope>
</dependency>

Im nächsten Schritt wählen Sie die Implementierung der Jakarta EE-Umgebung. Das bedeutet, Sie entscheiden sich für einen Anwendungsserver. Es ist sehr wichtig, dass der gewählte Anwendungsserver mit der auf Ihrem System installierten JVM-Version kompatibel ist. Der Grund dafür ist einfach: Der Anwendungsserver ist in Java implementiert. Wenn Sie ein Servlet-Projekt entwickeln möchten, benötigen Sie keinen vollständigen Anwendungsserver. Ein einfacher Servlet-Container wie Apache Tomcat (Catalina) oder Jetty enthält alles Notwendige.

Referenzimplementierungen für Jakarta Enterprise sind beispielsweise: Payara (ein Fork von Glassfish), WildFly (ehemals JBoss), Apache Geronimo, Apache TomEE, Apache Tomcat und Jetty.

Vielleicht haben Sie schon von Microprofile [4] gehört. Keine Sorge, es ist gar nicht so kompliziert, wie es zunächst scheint. Microprofiles sind im Allgemeinen eine Teilmenge von JakartaEE zum Ausführen von Microservices. Sie wurden um verschiedene Technologien erweitert, um den Status der Dienste zu verfolgen, zu beobachten und zu überwachen. Version 5 wurde im Dezember 2021 veröffentlicht und ist vollständig kompatibel mit JakartaEE 9.


Core Technologies

Plain Old Java Beans

POJOs sind vereinfachte Java-Objekte ohne Geschäftslogik. Diese Art von Java-Beans enthält lediglich Attribute und die zugehörigen Getter und Setter. POJOs:

  • Erweitern keine vordefinierten Klassen: z. B. ist public class Test extends javax.servlet.http.HttpServlet keine POJO-Klasse.
  • Enthalten keine vordefinierten Annotationen: z. B. ist @javax.persistence.Entity public class Test keine POJO-Klasse.
  • Implementieren keine vordefinierten Schnittstellen: z. B. ist public class Test implements javax.ejb.EntityBean keine POJO-Klasse.

(Jakarta) Enterprise Java Beans

Eine EJB-Komponente, auch Enterprise Bean genannt, ist ein Codeblock mit Feldern und Methoden zur Implementierung von Modulen der Geschäftslogik. Man kann sich eine Enterprise Bean als Baustein vorstellen, der allein oder zusammen mit anderen Enterprise Beans verwendet werden kann, um Geschäftslogik auf dem Java-EE-Server auszuführen.

Enterprise Beans sind entweder zustandslose oder zustandsbehaftete Session Beans oder Message-Driven Beans. Zustandslos bedeutet, dass die Session Bean und ihre Daten gelöscht werden, sobald der Client die Ausführung beendet hat. Eine Message-Driven Bean kombiniert die Eigenschaften einer Session Bean mit denen eines Message Listeners und ermöglicht es einer Geschäftskomponente, asynchron (JMS-)Nachrichten zu empfangen.

(Jakarta) Servlet

Die Java-Servlet-Technologie ermöglicht die Definition HTTP-spezifischer Servlet-Klassen. Eine Servlet-Klasse erweitert die Funktionalität von Servern, die Anwendungen hosten, auf die über ein Anfrage-Antwort-Programmiermodell zugegriffen wird. Obwohl Servlets auf jede Art von Anfrage reagieren können, werden sie üblicherweise zur Erweiterung der von Webservern gehosteten Anwendungen eingesetzt.

(Jakarta) Server Pages

JSP ist eine UI-Technologie, mit der sich Servlet-Code-Schnipsel direkt in ein textbasiertes Dokument einfügen lassen. JSP-Dateien werden vom Compiler in ein Java-Servlet umgewandelt.

(Jakarta) Server Pages Standard Tag Library

Die JSTL kapselt Kernfunktionen, die vielen JSP-Anwendungen gemeinsam sind. Anstatt Tags verschiedener Anbieter in Ihren JSP-Anwendungen zu mischen, verwenden Sie einen einzigen, standardisierten Tag-Satz. Die JSTL enthält Iterator- und Bedingungs-Tags zur Ablaufsteuerung, Tags zur Bearbeitung von XML-Dokumenten, Internationalisierungs-Tags, Tags für den Datenbankzugriff mit SQL sowie Tags für häufig verwendete Funktionen.

(Jakarta) Server Faces

JSF ist ein Framework für Benutzeroberflächen zur Entwicklung von Webanwendungen. JSF wurde eingeführt, um das Problem von JSP zu lösen, bei dem Programmlogik und Layout stark voneinander getrennt waren.

(Jakarta) Managed Beans

Managed Beans sind leichtgewichtige, containerverwaltete Objekte (POJOs) mit minimalen Anforderungen. Sie unterstützen eine kleine Anzahl grundlegender Dienste wie Ressourceninjektion, Lebenszyklus-Callbacks und Interceptors. Managed Beans stellen eine Verallgemeinerung der von der Java Server Faces-Technologie spezifizierten Managed Beans dar und können überall in einer Java-EE-Anwendung eingesetzt werden, nicht nur in Webmodulen.

(Jakarta) Persistence API

Die Java Persistence API (JPA) ist eine auf Java-Standards basierende Lösung für die Datenpersistenz. Sie nutzt ein objektrelationales Mapping, um die Lücke zwischen einem objektorientierten Modell und einer relationalen Datenbank zu schließen. Die Java Persistence API kann auch in Java-SE-Anwendungen außerhalb der Java-EE-Umgebung verwendet werden. Hibernate und Eclipse Link sind Beispiele für JPA-Implementierungen.

(Jakarta) Transaction API

Die JTA bietet eine Standardschnittstelle zur Abgrenzung von Transaktionen. Die Java-EE-Architektur stellt standardmäßig einen automatischen Commit zur Verfügung, der Transaktions-Commits und -Rollbacks verarbeitet. Ein automatischer Commit bedeutet, dass alle anderen Anwendungen, die auf Daten zugreifen, nach jedem Lese- oder Schreibvorgang die aktualisierten Daten sehen. Führt Ihre Anwendung jedoch zwei voneinander abhängige Datenbankzugriffe durch, sollten Sie die JTA-API verwenden, um den Beginn, den Rollback und den Commit der gesamten Transaktion – einschließlich beider Operationen – festzulegen.

(Jakarta) API for RESTful Web Services

JAX-RS definiert APIs für die Entwicklung von Webdiensten gemäß dem REST-Architekturstil (Representational State Transfer). Eine JAX-RS-Anwendung ist eine Webanwendung, die aus Klassen besteht, die als Servlet in einer WAR-Datei zusammen mit den erforderlichen Bibliotheken verpackt sind.

(Jakarta) Dependency Injection for Java

Dependency Injection für Java definiert einen Standardsatz von Annotationen (und ein Interface) für die Verwendung injizierbarer Klassen wie Google Guice oder dem Sprig Framework. Auf der Java-EE-Plattform bietet CDI Unterstützung für Dependency Injection. Konkret können Injektionspunkte nur in einer CDI-fähigen Anwendung verwendet werden.

(Jakarta) Contexts & Dependency Injection for Java EE

CDI definiert eine Reihe von Kontextdiensten, die von Java-EE-Containern bereitgestellt werden und es Entwicklern erleichtern, Enterprise Beans zusammen mit Java Server Faces in Webanwendungen zu verwenden. CDI ist für die Verwendung mit zustandsbehafteten Objekten konzipiert, bietet aber auch viele weitere Einsatzmöglichkeiten und ermöglicht Entwicklern ein hohes Maß an Flexibilität bei der Integration verschiedener Komponententypen auf lose gekoppelte, aber typsichere Weise.

(Jakarta) Bean Validation

Die Bean-Validierungsspezifikation definiert ein Metadatenmodell und eine API zur Validierung von Daten in Java-Beans-Komponenten. Anstatt die Datenvalidierung auf mehrere Schichten, wie Browser und Server, zu verteilen, können die Validierungsbedingungen zentral definiert und schichtübergreifend genutzt werden.

(Jakarta) Message Service API

Die JMS-API ist ein Messaging-Standard, der es Java-EE-Anwendungskomponenten ermöglicht, Nachrichten zu erstellen, zu senden, zu empfangen und zu lesen. Sie ermöglicht eine lose gekoppelte, zuverlässige und asynchrone verteilte Kommunikation.

(Jakarta) EE Connector Architecture

Die Java-EE-Connector-Architektur wird von Softwareherstellern und Systemintegratoren verwendet, um Ressourcenadapter zu erstellen, die den Zugriff auf Enterprise-Informationssysteme (EIS) unterstützen und in jedes Java-EE-Produkt integriert werden können. Ein Ressourcenadapter ist eine Softwarekomponente, die es Java-EE-Anwendungskomponenten ermöglicht, auf den zugrunde liegenden Ressourcenmanager des EIS zuzugreifen und mit diesem zu interagieren. Da ein Ressourcenadapter spezifisch für seinen Ressourcenmanager ist, existiert typischerweise für jeden Datenbanktyp oder jedes Enterprise-Informationssystem ein eigener Ressourcenadapter.

Die Java EE Connector Architecture ermöglicht eine leistungsorientierte, sichere, skalierbare und nachrichtenbasierte Transaktionsintegration von Java EE-basierten Webdiensten mit bestehenden Enterprise-Integrated-Systemen (EIS), die sowohl synchron als auch asynchron arbeiten können. Bestehende Anwendungen und EIS, die über die Java EE Connector Architecture in die Java EE-Plattform integriert wurden, lassen sich mithilfe von JAX-WS und Java EE-Komponentenmodellen als XML-basierte Webdienste bereitstellen. JAX-WS und die Java EE Connector Architecture ergänzen sich somit ideal für die Enterprise Application Integration (EAI) und die durchgängige Geschäftsintegration.

(Jakarta) Mail API

Java-EE-Anwendungen nutzen die JavaMail-API zum Versenden von E-Mail-Benachrichtigungen. Die JavaMail-API besteht aus zwei Teilen:

  • einer Anwendungsschnittstelle, die von den Anwendungskomponenten zum Versenden von E-Mails verwendet wird,
  • und einer Dienstschnittstelle.

Die Java-EE-Plattform beinhaltet die JavaMail-API mit einem Dienstanbieter, der es Anwendungskomponenten ermöglicht, E-Mails über das Internet zu versenden.

(Jakarta) Authorization Contract for Containers

Die JACC-Spezifikation definiert einen Vertrag zwischen einem Java-EE-Anwendungsserver und einem Autorisierungsrichtlinienanbieter. Alle Java-EE-Container unterstützen diesen Vertrag. Die JACC-Spezifikation definiert java.security.Permission-Klassen, die dem Java-EE-Autorisierungsmodell entsprechen. Sie legt fest, wie Containerzugriffsentscheidungen an Operationen auf Instanzen dieser Berechtigungsklassen gebunden werden. Darüber hinaus definiert sie die Semantik von Richtlinienanbietern, die die neuen Berechtigungsklassen nutzen, um die Autorisierungsanforderungen der Java-EE-Plattform zu erfüllen, einschließlich der Definition und Verwendung von Rollen.

(Jakarta) Authentication Service Provider Interface for Containers

Die JASPIC-Spezifikation definiert eine Service-Provider-Schnittstelle (SPI), über die Authentifizierungsanbieter, die Mechanismen zur Nachrichtenauthentifizierung implementieren, in Client- oder Server-Container bzw. Laufzeitumgebungen zur Nachrichtenverarbeitung integriert werden können. Die über diese Schnittstelle integrierten Authentifizierungsanbieter verarbeiten Netzwerknachrichten, die ihnen von ihren aufrufenden Containern bereitgestellt werden. Sie transformieren ausgehende Nachrichten so, dass der Absender jeder Nachricht den Absender und der Empfänger den Absender authentifizieren kann. Eingehende Nachrichten werden von den Authentifizierungsanbietern authentifiziert, und die im Zuge der Nachrichtenauthentifizierung ermittelte Identität wird an die aufrufenden Container zurückgegeben.

(Jakarta) EE Security API

Ziel der Java EE Security API-Spezifikation ist die Modernisierung und Vereinfachung der Sicherheits-APIs. Dies geschieht durch die Etablierung einheitlicher Ansätze und Mechanismen sowie die Ausblendung komplexerer APIs aus der Entwicklersicht, wo immer möglich. Java EE Security führt die folgenden APIs ein:

  • SecurityContext-Schnittstelle: Bietet einen einheitlichen Zugriffspunkt, über den Anwendungen Aspekte der Aufruferdaten prüfen und den Zugriff auf Ressourcen gewähren oder verweigern können.
  • HttpAuthenticationMechanism-Schnittstelle: Authentifiziert Aufrufer einer Webanwendung und ist ausschließlich für die Verwendung im Servlet-Container vorgesehen.
  • IdentityStore-Schnittstelle: Bietet eine Abstraktion eines Identitätsspeichers, der zur Authentifizierung von Benutzern und zum Abrufen von Aufrufergruppen verwendet werden kann.

(Jakarta) Java API for WebSocket

WebSocket ist ein Anwendungsprotokoll, das Vollduplex-Kommunikation zwischen zwei Teilnehmern über TCP ermöglicht. Die Java-API für WebSocket erlaubt es Java-EE-Anwendungen, Endpunkte mithilfe von Annotationen zu erstellen, die die Konfigurationsparameter des Endpunkts festlegen und seine Lebenszyklus-Callback-Methoden definieren.

(Jakarta) Java API for JSON Processing

JSON-P ermöglicht Java-EE-Anwendungen das Parsen, Transformieren und Abfragen von JSON-Daten mithilfe des Objektmodells oder des Streaming-Modells.

JavaScript Object Notation (JSON) ist ein textbasiertes Datenaustauschformat, das von JavaScript abgeleitet ist und in Webdiensten und anderen verbundenen Anwendungen verwendet wird.

(Jakarta) Java API for JSON Binding

JSON-B stellt eine Bindungsschicht für die Konvertierung von Java-Objekten in und aus JSON-Nachrichten bereit. JSON-B ermöglicht zudem die Anpassung des standardmäßigen Mapping-Prozesses dieser Bindungsschicht durch Java-Annotationen für ein bestimmtes Feld, eine JavaBean-Eigenschaft, einen Typ oder ein Paket oder durch die Implementierung einer Strategie zur Benennung von Eigenschaften. JSON-B wurde mit der Java EE 8-Plattform eingeführt.

(Jakarta) Concurrency Utilities für Java EE

Concurrency Utilities for Java EE ist eine Standard-API zur Bereitstellung asynchroner Funktionen für Java EE-Anwendungskomponenten durch die folgenden Objekttypen: Managed Executor Service, Managed Scheduled Executor Service, Managed Thread Factory und Context Service.

(Jakarta) Batch Applications for the Java Platform

Batch-Jobs sind Aufgaben, die ohne Benutzerinteraktion ausgeführt werden können. Die Spezifikation „Batch Applications for the Java Platform“ (BAJP) ist ein Batch-Framework, das die Erstellung und Ausführung von Batch-Jobs in Java-Anwendungen unterstützt. Das Framework besteht aus einer Batch-Laufzeitumgebung, einer auf XML basierenden Job-Spezifikationssprache, einer Java-API zur Interaktion mit der Batch-Laufzeitumgebung und einer Java-API zur Implementierung von Batch-Artefakten.

Resources

Abonnement / Subscription

[English] This content is only available to subscribers.

[Deutsch] Diese Inhalte sind nur für Abonnenten verfügbar.


Eine Handvoll JAVA – Key Features der einzelnen Versionen

Die objektorientierte Programmiersprache Java wurde von James Gosling entworfen. Die erste Version wurde 1995 von der Firma Sun Microsystems veröffentlicht. Nach der Übernahme von Sun Microsystems durch Oracle im Jahr 2010 wurde Java Teil des Oracle Produktportfolios.

zu letzt geändert:

Die Java Serie

  • Java 21 LTS
  • Java 20
  • Java 19
  • Java 18
  • Java 17 LTS
  • Java 16
  • Java 15
  • Java 14
  • Java 13
  • Java 12
  • Java 11 LTS
  • Java 10
  • Java 9
  • Java 8
  • Java 7
  • Java 6
  • Java 5 / J5SE
  • Java 1.4
  • Java 1.3
  • Java 1.2 / Java2

Um Java-Programme auf dem Computer ausführen zu können, wird eine sogenannte virtuelle Maschine benötigt. Der Download dieser JVM heißt JRE (Java Runtime Environment). Wer selbst in der Programmiersprache Java entwickeln möchte, benötigt den zugehörigen Compiler, der unter dem allgemeinen Begriff SDK (Software Development Kit) oder etwas spezieller als JDK (Java Development Kit) bekannt ist. Das JDK enthält natürlich auch die dazu passende Laufzeitumgebung (die JVM).

Mit dem Erscheinen des Releases für Java 9 im September 2017 gab Oracle einen 6-monatigen Releasezyklus für künftige Java Versionen bekannt. Somit erscheint jedes Jahr im März und im September eine neue Version der beliebten Programmiersprache. Aber keine Sorge, es ist nicht notwendig, den Lizenzbestimmungen von Oracle zu folgen und in diesem Turnus die eigene Java Version zu aktualisieren. Um Unternehmen genügend Stabilität für die IT‑Infrastruktur zu bieten, erscheint jedes sechste Java Release als sogenanntes LTS (Long Term Support) und hat eine Laufzeit von drei Jahren, ab Erscheinen. Hierzu habe ich bereits einen tieferführenden Artikel veröffentlicht.

Mit dem häufigen Releasezyklus kommen natürlich auch mit jeder neuen Java-Version einige neue Schlüsselfunktionen in den Sprachkern. Hier kann man schnell den Überblick verlieren. Folglich habe ich eine kleine Übersicht zusammengetragen. Wer sich zusätzlich einen Überblick über die einzelnen Java Enterprise Versionen verschaffen möchte, dem sei mein entsprechender Artikel zu Java EE empfohlen.

Versionsübersicht

Um uns nicht zu sehr in Details zu verstricken, beginne ich mit der Version 1.2, die auch als JAVA 2 bekannt ist und 1998 veröffentlicht wurde. Die wichtigsten Funktionen von Java2 sind die grafische SWING API und die Vorstellung des Just In Time Compliers (JIT).

Im Jahr 2000 erschien die Version 1.3 mit Funktionen wie JNDI (Java Naming and Directory Interface) sowie JPDA (Java Platform Debugger Architecture).

Gleich zwei Jahre später, im Jahr 2002, erschien die Version 1.4, die, die verfügbare Standardbibliothek um Funktionen wie reguläre Ausdrücke, Logging API, integrierten XML & XSLT Prozessor, Image I/O API und New I/O erweiterte.

Mit der 2004 veröffentlichten Version 1.5 änderte sich auch die Bezeichnung beziehungsweise die Zählweise der Versionen. Java wird als Majorversion hochgezählt, was so viel bedeutet, dass man fortan von JAVA5 spricht. Ganz der Analogie, wie es bereits bei der Version 1.2 der Fall war. Die Java5 Standardedition (SE), oder kurz J5SE bringt eine Menge Änderungen für den Entwickleralltag, Dazu zählen: Autoboxing/ Unboxing, Annotations, Enums und Generics.

Die 2006 erschienene Java6 SE erweiterte die XML Funktionalität mit dem StAX Parser, stellte JAX-WS für Web Services bereit und brachte den Scripting Language Support, der es ermöglichte, Skriptsprachen wie JavaScript auf der JVM auszuführen. Wichtigste Vertreter sind die beiden JVM‑Sprachen Kotlin (2011, JetBrains) und Scala (2004).

Lange fünf Jahre später und erstmalig unter der Regie von Oracle erblickte Java7 SE 2011 das Licht der Welt. In diesem Java Release wurde der Diamond Operator <> eingeführt. Weitere Maßnahmen, die Sprache zu vereinfachen und die Ausdruckstärke zu erhöhen, waren die Vereinfachung der varargs-Methoden-Deklaration und die Möglichkeit, in Switch-Anweisungen Strings zu verwenden. Auch auf die Aussagen, Exceptions seien langsam und sollten sparsam benutzt werden, wurde Rechnung getragen und das Exception-Handling verbessert.

// Diamond Operator
List<String> myList = new ArrayList<>();

// varargs (variable-length arguments)
public void myMethod(String... args);

Java8 SE machte mit der Erscheinung 2014 wieder einen erheblichen Schritt. In diesem Release spendierte Oracle der Java Community lang ersehnte Features wie Lambdafunktionen und die Stream API, um die wichtigsten Neuerungen herauszugreifen. Zudem wurde die Date & Time API komplett überarbeitet und Änderungen von der bis dahin weitverbreiteten JODA-Time Bibliothek inspiriert.

// ForEach Lambda
myList.forEach(element -> System.out.println(element));

//Stream API
myList.stream()
    .filter(element -> element.startsWith("A"))
    .forEach(System.out.println); 

Mit dem Release 2017 für Java9 SE kam eine Zäsur. Wegen der Einführung des Modulsystems wurde die gesamte Standardbibliothek umgearbeitet, damit die einzelnen APIs nicht mehr in einer gigantischen JAR zusammengefasst sind. Die dadurch entstandenen Module haben nun weniger Speicher in Anspruch genommen. Die massiven Änderungen erforderten für viele bereits langjährige Projekte enorme Kräfte, auf die neue Java Version zu migrieren. Außerdem wurde mit Java9 die Java Shell, kurz JShell eingeführt. Ein Kommandozeilenwerkzeug, in dem Javafunktionen als Script ausgeführt werden können.

// module-info.java
module com.example.myapp {
  requires java.base;
  exports com.example.myapp;
}

Weitere erhebliche Veränderungen brachte das Release Java10 SE, welches nur wenige Monate nach Java9 in 2018 veröffentlicht wurde und weitere Migrationsaufwände nach sich zog. Hier wurde das Local-Variable-Type Interface mit dem zugehörigen Schlüsselwort var eingeführt. Zudem startet mit dem Release 10 auch das Time-Based Versioning für die Sprache Java. Im Zyklus von 6 Monaten kommt eine neue Major-Version jeweils im März und September. Alle 3 Jahre wird eine LTS-Version veröffentlicht.

// the var KeyWord
public static void main(String[] args) {
  var message = "Hello World, Java10!";
  System.out.println(message);
}


Bereits im Herbst 2018 wurde die erste Langzeitversion für Java veröffentlicht. Das Release Java11 besitzt den Zusatz LTS und erhält für 3 Jahre Updates. Aufgrund der kurzen Releaszyklen enthält diese Version nur wenige API Änderungen. Vor allem die Klasse String bekam viele neue Methoden spendiert, die den Umgang mit Zeichenketten vereinfachen sollen.

// String FUnctions
String text = new String(" Helle Java 11 LTS world! ");
text.strip();
text.isBlank();
text.lines().count();

Die wichtigste Änderung der im Frühjahr 2019 erschienenen Java12 SE Version, ist neben einigen API Erweiterungen die Möglichkeit, in switch Anweisungen Expressions zu nutzen.

// switch expressions
Var day = 1;
String weekday = switch(day) {
    default -> "";
    case 1 -> "Monday";
    case 2 -> "Tuesday";
    ...  
}

Java13 SE erschien planmäßig im Herbst 2019 und verbesserte die Expressions in switch Anweisungen. Zudem wurden Textblöcke eingeführt, die ressourcenfressende String‑Konkatenationen überflüssig machen.

// textblock
String text = """
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do
eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim 
ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut 
aliquip ex ea commodo consequat. Duis aute irure dolor in 
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla 
pariatur. Excepteur sint occaecat cupidatat non proident, sunt in 
culpa qui officia deserunt mollit anim id est laborum.
""";

Mit dem Release für Java14 SE im März 2020 wurden Records eingeführt. Diese Datenstrukturen sollen den Code kompakter und lesbarer machen, da Getter und Setter nicht mehr explizit definiert werden müssen.

// records
public record Person (String name, String address) {}

Das im Herbst 2020 erschienene Release Java15 SE standardisierte die Textblöcke und führte sealed Klassen ein. Sealed bedeutet so viel wie versiegelt und unterbindet die Möglichkeit, dass eine Klasse vererbt werden kann.

// inheritance protection
public sealed class Shape permits Circle {
    // Class body
}

public final class Circle extends Shape {
    // Class body
}

2021 standardisierte das Release für Java16 SE verschiedene Funktionen, unter anderem Sealed Classes, Pattern Matching für instanceof und Records.

// Pattern Matching instanceof with auto cast
if (obj instanceof String s) {
    System.out.println(s);
}

Java17 SE LTS, erschien wieder planmäßig im Herbst 2021 und löste nach drei Jahren Java11 SE LTS ab. In dieser Version wurden die Java Applet API und der Security Manager als deprecated markiert.

Die Version Java18 SE setzte die UTF-8-Codepage als Standard für die JVM. Außerdem wurde die Vector API mit dem Status „experimental“ eingeführt.

// Java Vector API
import jdk.incubator.vector.*;
import java.util.Random;

public class VectorExample {
    // Use preferred vector species for optimal CPU performance
    static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;

    // Vectorized implementation using the Vector API
    static void sqrtsumVector(float[] a, float[] b, float[] c) {
        int i = 0;
        int upperBound = SPECIES.loopBound(a.length); // Efficient loop bound

        // Process data in chunks matching the vector length
        for (; i < upperBound; i += SPECIES.length()) {
            var va = FloatVector.fromArray(SPECIES, a, i);
            var vb = FloatVector.fromArray(SPECIES, b, i);
            var vc = va.mul(va)           // a[i]²
                      .add(vb.mul(vb))    // + b[i]²
                      .neg();             // - (a[i]² + b[i]²)
            vc.intoArray(c, i);           // Store result
        }

        // Handle remaining elements (tail case) with scalar loop
        for (; i < a.length; ++i) {
            c[i] = -(a[i] * a[i] + b[i] * b[i]);
        }
    }
}   

Das Ende 2022 erschienene Release Java19 SE brachte neben einigen Optimierungen und integrierte das Projekt Loom um virtuelle Threads zu ermöglichen. Auch die Foreign Function & Memory API fand ihren Einzug in die JVM.

// Natice C Memory allocation & Slicing in Java 
Arena arena = Arena.ofAuto();
MemorySegment memorySegment = arena.allocate(12);

MemorySegment segment1 = memorySegment.asSlice(0, 4);
MemorySegment segment2 = memorySegment.asSlice(4, 4);
MemorySegment segment3 = memorySegment.asSlice(8, 4);

VarHandle intHandle = ValueLayout.JAVA_INT.varHandle();

intHandle.set(segment1, 0, Integer.MIN_VALUE);
intHandle.set(segment2, 0, 0);
intHandle.set(segment3, 0, Integer.MAX_VALUE);

Java20 SE, das wie gewohnt im Frühjahr erschien, brachte 2023 keine neuen Funktionen, sondern konzentrierte sich darauf, dass bereits eingeführte Features stabilisiert wurden.

Im Herbst 2023 erschien mit Java21 SE LTS wieder eine Long Term Support Version. In diesem Release wurden Virtual Thread finalisiert.

public class VirtualThreadsExample {
  public static void main(String[] args) throws
InterruptedException {
    var executor =
      Executors.newVirtualThreadPerTaskExecutor();
    executor.submit( () ->
      System.out.println("Running in virtual thread"));
    executor.submit( () ->
      System.out.println("Running another virtual thread"));
    Thread.sleep(1000);
    complete
  }
}