Von Java 8 auf 17: Ein Fahrplan

Keine Zeit? Hier die Kurzversion in 30 Sekunden.
- Java 17 ist seit September 2021 ein LTS-Release und damit das naheliegende Ziel für alle, die noch auf Java 8 sitzen.
- Der Umstieg scheitert selten an der Sprache, sondern an Build-Werkzeugen, alten Bibliotheken und Abhängigkeiten auf JDK-Interna.
- Reihenfolge: Inventar erstellen, Build und Bibliotheken aktualisieren, entfernte Java-EE-Module nachrüsten, dann erst die JDK-Version wechseln.
--add-opensist eine Notlösung;jdeps --jdk-internalsundjdeprscanzeigen, wo es wirklich hakt.- Der Gewinn: Records, Textblöcke, switch-Ausdrücke,
var, hilfreiche NullPointerExceptions und ein ganzes Stück Laufzeitverbesserungen.
Bei einem Gespräch über Altlasten fiel neulich der Satz: „Wir sind auf Java 8, das läuft ja.“ Stimmt, es läuft. Es läuft sogar erstaunlich gut, und genau das ist das Problem. Es gibt keinen akuten Schmerz, also wird der Umstieg verschoben, und je länger man wartet, desto größer wirkt der Sprung.
Dabei ist der Zeitpunkt günstig. Java 17 ist seit September 2021 ein Release mit Langzeitunterstützung, und das Oracle JDK 17 darf unter den NFTC-Bedingungen kostenlos genutzt werden. Im März kommt Java 18, aber das ist wie immer ein Zwischenrelease. Wer ein stabiles Ziel sucht, hat es. Ich habe in den letzten Monaten ein paar Anwendungen angefasst und möchte aufschreiben, in welcher Reihenfolge ich dabei vorgehe. Nicht als Rezept, das überall passt, eher als Landkarte.
Schritt 0: Inventar
Bevor irgendetwas umgestellt wird, muss klar sein, womit man es zu tun hat. Das klingt langweilig, ist aber der Teil, der später am meisten Zeit spart. Seit Log4Shell im Dezember wissen viele ohnehin, wie sich eine Liste der eigenen Bestandteile anfühlt, wenn man sie nicht hat.
Ich notiere mir für jedes Projekt:
- Mit welchem JDK wird gebaut, mit welchem läuft es produktiv, und sind das wirklich dieselben?
- Welche Build-Werkzeuge und welche Versionen (Maven, Gradle, Ant-Reste)?
- Welche Plugins sind im Build, vor allem alles, was Bytecode anfasst oder Code erzeugt?
- Welche Frameworks und Bibliotheken, direkt und transitiv?
- Was läuft sonst noch mit Java: Skripte, Testwerkzeuge, Entwicklungsumgebungen, CI-Agenten?
Der letzte Punkt wird gern vergessen. Es hilft nichts, wenn die Anwendung auf 17 läuft, aber der Build-Server nur ein altes JDK kennt.
Zuerst die Werkzeuge, dann die JDK-Version
Mein wichtigster Rat: Nicht zuerst das JDK tauschen und dann schauen, was kaputtgeht. Besser ist es, zunächst unter Java 8 alles auf Versionen zu bringen, die auch mit 17 umgehen können. Das lässt sich in kleinen Schritten committen und jeder Schritt ist einzeln testbar.
Beim Maven-Compiler-Plugin lohnt sich der Wechsel von source und target auf release:
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<release>17</release>
</configuration>
</plugin>release stellt sicher, dass nicht nur die Sprachversion, sondern auch die verfügbare API zur Zielversion passt. Das setzt allerdings ein JDK ab 9 beim Bauen voraus. Das Plugin sollte dafür in einer aktuellen Version laufen, genauso wie Surefire und Failsafe. Alte Surefire-Versionen haben mit neueren JDKs gern Ärger gemacht.
Dann die Bibliotheken, die tief in die Klassen greifen. Das sind die üblichen Verdächtigen:
- Lombok muss eine Version haben, die das neue JDK kennt, sonst scheitert schon die Kompilierung.
- Mockito und ByteBuddy erzeugen zur Laufzeit Klassen und müssen die Klassendatei-Version von Java 17 verstehen. Ältere Stände brechen mit Meldungen über unbekannte Klassenversionen ab.
- ASM steckt in vielen Werkzeugen, oft versteckt. Auch hier gilt: aktuelle Version, notfalls das umgebende Werkzeug aktualisieren.
- Hibernate und andere Persistenz-Frameworks arbeiten mit Proxys und Bytecode-Erzeugung und sollten nicht hinterherhinken.
- Spring Boot verträgt Java 17 ab der Reihe 2.5, am besten fährt man mit 2.6. Das ist kein Zufall, sondern liegt an den genannten Bibliotheken darunter.
Praktisch heißt das oft: erst Spring Boot hochziehen, dann Tests grün bekommen, dann weiter. Die Tests sind das Sicherheitsnetz. Wer kaum welche hat, sollte vor dem Umstieg ein paar schreiben, am besten für die Stellen, die mit Reflection, Serialisierung oder Zeit arbeiten.
Was seit Java 11 fehlt
Wer von 8 kommt, trifft auf ein Phänomen, das mit Java 11 beschlossen wurde: Die Java-EE-Module sind aus dem JDK verschwunden. Das betrifft JAXB, JAX-WS, javax.annotation und die Activation-Klassen. Der Code kompiliert plötzlich nicht mehr, obwohl man nichts geändert hat. Die Lösung ist unspektakulär: Die Bibliotheken als normale Abhängigkeiten eintragen. Je nach Projekt sind das die JAXB-API samt Implementierung, die Annotations-API und die Activation-Bibliothek. Dass man die Jakarta-Nachfolger bekommt, ändert an den Paketnamen zunächst nichts, die heißen in diesen Versionen weiter javax.
Weitere Dinge, die in der Zwischenzeit entfernt wurden: Der Skriptmotor Nashorn ist seit Java 15 weg, der Garbage Collector CMS seit 14. Java Web Start und das Applet-Plugin sind ebenfalls Geschichte. Wer noch ein -XX:+UseConcMarkSweepGC in einem Startskript hat, bekommt das beim Start zu spüren. Im Zweifel sucht man in allen Start- und Konfigurationsdateien nach JVM-Optionen und räumt auf.
Zum Aufspüren helfen zwei Werkzeuge, die im JDK stecken. jdeprscan untersucht Klassen und JARs auf Verwendung veralteter oder entfernter API. Und jdeps zeigt mit --jdk-internals, wo Code auf JDK-interne Klassen zugreift:
jdeps --jdk-internals --multi-release 17 -cp "lib/*" anwendung.jarDie Ausgabe ist trocken, aber ehrlich. Sie sagt, ob die eigene Anwendung oder eine Bibliothek an Stellen herumfummelt, die nie zur offiziellen API gehörten.
Starke Kapselung
Das ist der Teil, bei dem die meisten Umstiege ins Stolpern geraten. Seit Java 9 kapselt das Modulsystem die Interna des JDK. Unter Java 9 bis 15 war der Zugriff per Reflection noch mit einer Warnung möglich. Mit 16 hat sich der Standard geändert, mit 17 ist die alte Schalterei dafür weg. Reflection auf interne Klassen schlägt jetzt mit einer Fehlermeldung fehl, meist InaccessibleObjectException.
Der Ausweg heißt --add-opens, zum Beispiel:
java --add-opens java.base/java.lang=ALL-UNNAMED -jar anwendung.jarDas hilft sofort, und ich habe das auch schon benutzt, um erst einmal weiterzukommen. Aber ich betrachte es als Notlösung. Jedes --add-opens ist eine Schuld, die notiert werden sollte: Welche Bibliothek braucht das, gibt es eine neuere Version, die es nicht mehr tut? Meistens gibt es sie. Bei Eigenbauten ist die Frage unbequemer, aber auch ehrlicher.
Container, GC und die Frage der Zwischenstation
Wer in Containern läuft, profitiert von neueren JDKs: Sie erkennen die Limits des Containers und richten sich danach, statt auf die Werte des Hosts zu schauen. Das ist kein Grund zum Umstieg allein, aber ein schöner Nebeneffekt, über den man sich später nicht mehr wundert.
Beim Garbage Collector ist G1 der Standard. Für die meisten Anwendungen ist das in Ordnung, und ich würde die Finger von handgestrickten Tuning-Optionen lassen, die jemand vor Jahren gesetzt hat. Wer extreme Anforderungen an Pausenzeiten hat, kann sich ZGC oder Shenandoah ansehen. Die sind inzwischen verfügbar. Aber erst messen, dann umstellen, und messen heißt: mit der echten Last der eigenen Anwendung.
Bleibt die Frage, ob man den Umweg über Java 11 gehen sollte. Beides ist vertretbar. Der Zwischenschritt über 11 hat den Vorteil, dass die Probleme in zwei kleinere Pakete zerfallen: erst die entfernten Module und die Modulwelt, dann die starke Kapselung. Wenn die Anwendung überschaubar ist, gehe ich direkt auf 17. Bei großen, gewachsenen Systemen mit vielen Abhängigkeiten ist die Zwischenstation oft das beruhigendere Gefühl, und sie kostet weniger, als man denkt, weil Build und Bibliotheken ohnehin schon modernisiert sind.
Was man davon hat
Ein Umstieg ist Arbeit, also muss er sich lohnen. Aus meiner Sicht tut er das, und zwar nicht nur wegen der Wartungsfrage. Die Sprache hat sich in den Jahren spürbar verändert. var spart Tipparbeit, wo der Typ offensichtlich ist. Switch-Ausdrücke sind kürzer und lassen sich nicht mehr durch ein vergessenes break verbiegen. Textblöcke machen SQL, JSON und HTML in Quelltexten erträglich. Records ersetzen eine Menge Boilerplate bei einfachen Datenträgern. Auch Sealed Classes sind mit 17 dabei, wer Typhierarchien sauber modellieren will, findet dort Handwerkszeug.
Dazu kommen die kleinen Dinge, die den Alltag verbessern: Hilfreiche NullPointerExceptions sagen nun, welche Variable oder welcher Aufruf null war, statt nur eine Zeilennummer auszuspucken. Wer schon einmal eine verschachtelte Methodenkette debuggt hat, weiß, wie viel das wert ist. Und unter der Haube hat sich viel getan, am Garbage Collector, an der Startzeit, an der Laufzeit. Konkrete Zahlen nenne ich bewusst nicht, die hängen zu stark von der Anwendung ab. Aber dass ein neueres JDK die gleiche Anwendung nicht langsamer macht, war bisher meine Erfahrung.
Mein Fahrplan fürs Nachmachen: Inventar anlegen, Werkzeuge und Bibliotheken unter Java 8 aktualisieren, fehlende Module nachziehen, mit jdeps und jdeprscan prüfen, dann den Build auf 17 stellen, Tests laufen lassen und --add-opens nur dort setzen, wo es nicht anders geht. Wenn ihr schon umgestellt habt: Welche Bibliothek hat euch am meisten Nerven gekostet? Ich vermute, es ist wieder die, an die man als Letztes denkt.
Über die Neuerungen von Java 17 selbst habe ich im September schon etwas geschrieben, dort stehen die Sprachfeatures ausführlicher.
Beitragsbild: Foto Abfahrtstafel, Bahnhof Inverness von Stephen Craven, CC BY-SA 2.0 (via Wikimedia Commons; zugeschnitten auf 16:9).
Christian Ackermann
Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.