Java 9 – Alles, was Sie über die Funktionen von New Java wissen müssen

Java, die leicht zugängliche Programmiersprache, ist für Entwickler auf der ganzen Welt ein Kinderspiel. Seit ihrer Einführung im Jahr 1995 hat die Sprache eine breite Verwendung in verschiedenen Branchen erfahren.

Heute finden Sie Java auf Ihren Telefonen. Powering Android OS und die unzähligen Apps, die Android bietet. Es wird für die Entwicklung von Spielen wie Minecraft verwendet, das eine riesige Spielerbasis hat. Es findet auch Verwendung in Geschäftsanwendungen wie dem Lesen von Kreditkarteninformationen an Ladenkassen und dem Weiterleiten der Informationen zwischen den Systemen und den Banken.

Nach einer Pause von 3 Jahren hat Java seine neue Edition herausgebracht – Java SE 9. Mit mehreren wichtigen architektonischen Änderungen und Zusatzfunktionen bietet Java SE 9 eine leistungsstarke Lösung, nach der sich Entwickler gesehnt haben.

Java 7 hat 2011 Try-with-Ressource hinzugefügt und bietet eine bessere Ressourcenverwaltungsfunktionalität.
Java 8 fügte Lambda-Ausdrücke hinzu, ein guter Schritt, aber unter dem OOP-Paradigma leicht fehlerhaft.

Jetzt erlaubt Java Solutions Programmierern, private Methoden zu haben. Private statische Methoden! JA, Sie haben richtig gelesen!

Java SE 8 bot viele strukturelle Änderungen, die von den Entwicklern mit gemischten Gefühlen aufgenommen wurden. Im Wesentlichen sind dies die Mängel von Java SE 8, die Java SE 9 zu überwinden versucht hat:

1. Das JDK war für das kleine Computergerät nicht navigierbar
2. Es gab keine allgemeine Verbesserung der Anwendungsleistung
3. Es gab keine allgemeine Sicherheit und Wartung von JDK
4. Java-Entwickler hatten Schwierigkeiten, die Codebibliotheken und größere Anwendungen zu erstellen und zu warten

Schauen wir uns also die wichtigsten Änderungen und Verbesserungen an, die Java 9 gegenüber seinen Vorgängern bietet

API-Aktualisierungen in Java 9 verarbeiten

Traditionell war die API von Java primitiver Natur. Diese Unterstützung zum Starten neuer Prozesse, Umleiten von Ausgaben und Fehlerströmen. In Java 9 ermöglichen die neuen Updates der Prozess-API Folgendes:

1. Abrufen der PID des aktuellen und eines beliebigen anderen JVM-Prozesses
2. Unterprozesse verwalten
3. Unterprozesse verwalten
4. Rufen Sie Informationen wie PID, Name und Ressourcennutzung der im System laufenden Prozesse ab.

Dies ist ein Beispielcode, der die aktuelle PID sowie die aktuellen Prozessinformationen ausgibt:

public class NewFeatures
{
public static void main(String [] args)
{
ProcessHandle currentProcess = ProcessHandle.current();
System.out.println("PID:"+ currentProcess.getPid());
ProcessHandle.Info currentProcessInfo = currentProcess.info();
System.out.println("Info:" + currentProcessInfo);
}
}


HTTP/2-Client in Java 9

Diese Funktion wird voraussichtlich in den nachfolgenden Versionen reformiert oder sogar vollständig entfernt.
Früher verließen sich Entwickler auf die Bibliotheken von Drittanbietern, zum Beispiel Apache HTTP, Jersey und so viele. Die HTTP-API von Java ist älter als die HTTP/1.1-Spezifikation und ist synchron und schwer zu warten. Diese Einschränkungen machten es erforderlich, eine neue API hinzuzufügen. Die neue HTTP-Client-API bietet Folgendes:

1. Eine einfache und prägnante API zur Bearbeitung der meisten HTTP-Anforderungen
2. Unterstützung der HTTP/2-Spezifikation
3. Bessere Leistung
4. Bessere Sicherheit
5. Noch ein paar Verbesserungen

Hier ist ein Code-Snippet, um eine HTTP-GET-Anforderung mit den neuen APIs zu erstellen. Dies ist das Modul, wie es in der Datei module-info.java definiert ist:

module newfeatures{
requires jdk.incubator.httpclient;
}

Der folgende Code verwendet die HTTP-Client-API. Dies ist ein Teil des Moduls jdk.incubator.httpclient :

import jdk.incubator.http.*;
import java.net.URI;
public class Http2Feature{
public static void main(String[] args) throws Exception{
HttpClient client = HttpClient.newBuilder().build();
HttpRequest request = HttpRequest
.newBuilder(new URI(http://httpbin.org/get;))
.GET()
.version(HttpClient.Version.HTTP_1_1)
.build();
HttpResponse.String response = client.send(request,
HttpResponse.BodyHandler.asString());
System.out.println("Status code:" + response.statusCode());
System.out.println("Response Body:" + response.body());
}
}
}

Mehr Concurrency-Updates-Funktion in Java 9

Mit Java 9 wurde eine neue Klasse namens – java.util.concurrent.Flow eingeführt, die die Implementierung eines Publish-Subscribe-Frameworks unterstützt. Dieses Framework ermöglicht es Entwicklern, Komponenten zu erstellen. Diese Komponenten können einen Live-Datenstrom asynchron konsumieren, indem sie Herausgeber einrichten, die die Daten produzieren, und Abonnenten, die die Daten konsumieren. Das sind die neuen Schnittstellen:

• java.util.concurrent.Flow.Publisher
• java.util.concurrent.Flow.Subscriber
• java.util.concurrent.Flow.Subscription
• java.util.concurrent.Flow.Processor (der sowohl als Herausgeber als auch als Abonnent fungiert).

Java Shell Scripting (Read-Eval-Print-Loop) in Java 9

Das Ziel des Projekts Kulla war es, die Hinzufügung des REPL-Tools (Read-Eval-Print-Loop) für Java 9 zu untersuchen. Diese Version von Java verfügt über ein spezielles Befehlszeilentool namens JShell. Das Ziel hier ist es, die Verwendung von REPL bekannt zu machen und zu maximieren. Was bedeutet das? Jetzt müssen Sie nicht mehr ein paar Codezeilen in eine separate Methode packen, um sie auszuführen. Effizient? Ich sage ja.
Beispielsweise wird in Scala ein einfaches „Hello World“-Programm als scala>println(„Hello World“);
Lassen Sie uns den JShell-Befehl ausführen, wie in der folgenden Abbildung gezeigt:

Projekt Jigsaw in Java 9

Der Trumpf der Neuerungen in Java 9 ist das völlig neue Modulsystem. Das Erstellen komplexer Systeme erfordert häufig komplexe Codes auf hoher Ebene, die zu Mehrdeutigkeiten führen. Bei der Codekomplexität treten zwei grundlegende Probleme auf: Die Kapselung des Codes ist schwierig, und es gibt keine Vorstellung von expliziten Abhängigkeiten zwischen verschiedenen JAR-Dateien eines Systems. Auf jede öffentliche Klasse kann von jeder anderen öffentlichen Klasse im Klassenpfad zugegriffen werden. Dies führt zu einer unnötigen Verwendung von Klassen, die nicht als öffentliche API gedacht waren. Außerdem ist der Klassenpfad selbst problematisch: Woher wissen Sie, ob alle erforderlichen JARs vorhanden sind, und was ist mit doppelten Einträgen? Das Modulsystem löst beide Probleme.
Hier zeigt sich die Robustheit von Java 9. Modulare JAR-Dateien enthalten einen zusätzlichen Moduldeskriptor. In diesem Moduldeskriptor werden 'requires'-Anweisungen verwendet, um Abhängigkeiten von anderen Modulen auszudrücken. Zusätzlich steuern "exports"-Anweisungen, welche Pakete für verschiedene Module zugänglich sind. Standardmäßig werden alle nicht exportierten Pakete im Modul gekapselt.

Es gibt verschiedene JEPs, die Teil dieses Projekts sind, wie folgt:

JEP 200 – modulares JDK: Dies wendet das Modulsystem der Java-Plattform an, um das JDK zu modularisieren, das zur Kompilierzeit, Buildzeit oder Laufzeit kombiniert werden kann.
JEP 201 – modularer Quellcode: Wird zum Erstellen von Modulen verwendet und ermöglicht Erstellungstools zum Kompilieren der erstellten Module
JEP 220 – modulare Laufzeit-Images: Dieses JEP verbessert die Leistung, Sicherheit und Wartbarkeit, indem es die JDK- und JRE-Laufzeit-Images umstrukturiert, um Module aufzunehmen
JEP 282 – Der jlink, bekannt als Java-Linker: Verwendungen als Verpackungsmodule und ihre Abhängigkeiten in weniger Laufzeiten.

JAR-Dateien mit mehreren Releases

Um die neuen Funktionen der Java-Plattform in neueren Versionen nutzen zu können, müssen die Bibliotheksentwickler eine neuere Version ihrer Bibliothek veröffentlichen. Bald werden mehrere Versionen der Bibliothek von den Entwicklern gepflegt, was katastrophal sein kann. Um diese Einschränkung zu überwinden, bietet Java 9 mehrere Versionen von JAR-Dateien, die es Entwicklern ermöglichen, JAR-Dateien mit verschiedenen Versionen von Klassendateien für verschiedene Java-Versionen zu erstellen. Schauen Sie sich dieses Beispiel an.

Eine Illustration der aktuellen JAR-Dateien wie folgt:

Glaswurzel
- Eine Klasse
– B.Klasse
– C.Klasse

So sehen Multi-Release-JAR-Dateien aus:

Glaswurzel

- Eine Klasse
– B.Klasse
– C.Klasse
– META-INF
– Versionen
– – 9
- - - - Eine Klasse
– – 10
– – – – B.Klasse

In der vorherigen Abbildung unterstützten die JAR-Dateien Klassendateien für zwei Java-Versionen 9 und 10. Wenn also die JAR-Datei auf der Java-Version 9 ausgeführt wird, wird die A.class unter den Ordnern „versions – 9“ zur Ausführung ausgewählt.

Bei früheren Java-Versionen, die JAR-Dateien mit mehreren Versionen nicht unterstützen, werden die Klassen im Versionsverzeichnis nie verwendet. Wenn Sie also die Multi-Release-JAR-Datei unter Java 8 ausführen, ist dies so gut wie das Ausführen einer einfachen JAR-Datei.

Meiner Meinung nach beginnen sich die Dinge mit Java zu ändern. Und das ist ein wachsender Trend. Bedeutet dies, dass die Popularität von Java und seiner Verwendung beeinträchtigt wird? Gar nicht. Java war und ist heute eine unglaublich leistungsfähige und robuste Programmiersprache in der Technologiebranche. Beginnen Sie mit dem Erlernen von Java und beobachten Sie, wie es Ihre Karriere verändert. Viel Glück!

Anmerkung des Verfassers:
Dieser technische Artikel wird von Sumit beigesteuert, das an Trendtechnologien wie DevOps, Big Data und Python arbeitet. Und im Digital Marketing Team bei Edureka.