Reaktive Systeme in Java

Vorwort

Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: [e-mail]

In der IT-Welt sind die Grenzen von heute die Tore von morgen. In den letzten 50 Jahren hat sich die IT-Welt unermüdlich weiterentwickelt und ist dabei immer wieder an ihre Grenzen gestoßen. Diese Veränderungen sind nicht nur auf den technischen Fortschritt zurückzuführen, sondern auch auf uns, die Verbraucher. Als Verbraucher stellen wir immer höhere Ansprüche an die Software, mit der wir täglich interagieren. Außerdem hat sich unsere Art, mit Software zu interagieren, völlig verändert. Wir können nicht mehr ohne mobile Anwendungen und Geräte leben und akzeptieren es, den ganzen Tag über Benachrichtigungen zu erhalten. Das Internet der Dinge (IoT) ist ein aufstrebender Markt, der viele weitere Innovationen verspricht und die Zahl der Ereignisse und Daten, die ununterbrochen verarbeitet werden, erhöht. Die Cloud und Kubernetes haben nicht nur unsere Nutzung, sondern auch die Art und Weise, wie wir Anwendungen entwerfen, entwickeln, einsetzen und warten, radikal verändert.

Aber täuschen Sie sich nicht: All diese Revolutionen haben ihren Preis. Sie haben zwar neue Einsatzmöglichkeiten und Anwendungen ermöglicht, aber auch eine enorme Komplexität mit sich gebracht. Die meisten Softwaresysteme sind heute verteilte Systeme. Und verteilte Systeme sind schwer zu entwerfen, zu entwickeln und zu betreiben, vor allem in der Größenordnung, die wir für die Implementierung dieser neuen, modernen Anwendungen brauchen. Wir müssen mit Ausfällen, asynchroner Kommunikation, einer sich ständig ändernden Topologie, der dynamischen Verfügbarkeit von Ressourcen usw. umgehen. Während die Cloud unbegrenzte Ressourcen verspricht, ist Geld ein begrenzender Faktor, und die Erhöhung der Einsatzdichte, d.h. die Ausführung von mehr auf weniger Ressourcen, wird zu einem zwingenden Anliegen.

Was ist also Reactive? Es ist keine Bibliothek, die du in deinem Code verwendest, und auch kein magisches Framework.Reactive ist eine Reihe von Prinzipien, Werkzeugen, Methoden und Frameworks, die dazu führen, bessere verteilte Systeme zu bauen. Wie viel besser? Das hängt vom System ab, aber Anwendungen, die den Reactive-Prinzipien folgen, nehmen die Herausforderungen verteilter Systeme an und konzentrieren sich auf Elastizität, Belastbarkeit und Reaktionsfähigkeit, wie in The Reactive Manifesto erklärt.

In diesem Buch verwenden wir das Substantiv Reactive mit einem großen R, um all die verschiedenen Facetten der reaktiven Landschaft zusammenzufassen, wie z.B. reaktive Programmierung, reaktive Systeme, reaktive Streams usw. Mit diesem Buch lernst du, wie Reactive uns hilft, diese neuen Probleme zu bewältigen und wie es in Cloud-Umgebungen passt. Nach der Lektüre dieses Buches wirst du in der Lage sein, reaktive Systeme zu bauen - belastbare, anpassungsfähige, ereignisgesteuerte verteilte Systeme.

Wer sollte dieses Buch lesen?

Dieses Buch richtet sich an fortgeschrittene Java-Entwickler. Am besten ist es, wenn du mit Java einigermaßen vertraut bist; Vorkenntnisse über reaktive Programmierung oder sogar Reactive im Allgemeinen sind jedoch nicht erforderlich. Viele Konzepte in diesem Buch beziehen sich auf verteilte Systeme, aber auch damit musst du nicht vertraut sein.

Reaktive Systeme stützen sich oft auf Message-Broker wie Apache Kafka oder Advanced Message Queuing Protocol (AMQP). Dieses Buch vermittelt das nötige Grundwissen, um zu verstehen, wie solche Broker bei der Entwicklung und Implementierung reaktiver Systeme helfen.

Drei verschiedene Gruppen können von diesem Buch profitieren:

• Entwickler/innen, die Cloud-native Anwendungen oder verteilte Systeme entwickeln

• Architekten, die die Rolle von reaktiven und ereignisgesteuertenArchitekturen verstehen wollen

• Neugierige Entwickler, die von Reactive gehört haben und es besser verstehen wollen

Mit diesem Buch machst du dich auf die Reise, um reaktive Architekturen zu verstehen, zu entwerfen, zu bauen und zu implementieren. Du lernst nicht nur, wie du damit bessere verteilte Systeme und Cloud-Anwendungen bauen kannst, sondern auch, wie du reaktive Muster nutzen kannst, um bestehende Systeme zu verbessern.

Was ist mit Quarkus?

Aufmerksamen Lesern wird aufgefallen sein, dass Quarkus im Untertitel dieses Buches erwähnt wird. Bisher haben wir es aber nicht erwähnt.Quarkus ist ein Java-Stack, der auf die Cloud zugeschnitten ist. Er nutzt Build-Time-Techniken, um den Speicherbedarf der Anwendung zu reduzieren und eine schnelle Startzeit zu gewährleisten.

Aber Quarkus ist auch ein reaktiver Stack. Im Kern ermöglicht eine reaktive Engine die Erstellung von nebenläufigen und belastbaren Anwendungen. Quarkus bietet außerdem alle Funktionen, die du brauchst, um verteilte Systeme zu bauen, die sich an schwankende Lasten und unvermeidliche Ausfälle anpassen können.

In diesem Buch nutzen wir Quarkus, um die Vorteile des reaktiven Ansatzes zu demonstrieren und verschiedene Muster und bewährte Methoden vorzustellen. Keine Angst, wenn du noch keine Vorkenntnisse oder Erfahrungen damit hast. Wir begleiten dich auf deiner Reise und leiten dich bei jedem Schritt an.

Dieses Buch konzentriert sich auf die Erstellung reaktiver Anwendungen und Systeme, die die Fähigkeiten von Quarkus nutzen, und vermittelt das gesamte Wissen, das für die Erstellung solcher Systeme erforderlich ist. Wir behandeln nicht das gesamte Quarkus-Ökosystem, da sich dieses Buch auf die Quarkus-Komponenten konzentriert, die bei der Erstellung reaktiver Systeme helfen.

Navigieren in diesem Buch

Wenn du Reactive gerade erst entdeckst und mehr darüber wissen willst, wirst du nach der Lektüre dieses Buches von vorne bis hinten verstehen, was Reactive ist und wie es dir helfen kann. Wenn du ein erfahrener Reactive-Entwickler bist und dich für Quarkus und seine reaktiven Funktionen interessierst, kannst du den ersten Teil des Buches überspringen und zu den Kapiteln springen, die dich am meisten interessieren.

Teil I ist eine kurze Einführung, die den Kontext darstellt:

• Kapitel 1 gibt einen kurzen Überblick über die reaktive Landschaft, einschließlich ihrer Vor- und Nachteile.

• Kapitel 2 stellt Quarkus und seinen Build-Time-Ansatz zur Reduzierung der Startzeit und des Speicherverbrauchs vor.

Teil II behandelt Reactive im Allgemeinen:

• In Kapitel 3 werden die Komplexität verteilter Systeme und die Missverständnisse erklärt; das sind die Gründe, warum wir reaktiv sind.

• In Kapitel 4 werden die Merkmale von reaktiven Systemen vorgestellt.

• Kapitel 5 behandelt die verschiedenen Formen asynchroner Entwicklungsmodelle, wobei der Schwerpunkt auf der reaktiven Programmierung liegt.

Teil III erklärt, wie man mit Quarkus reaktive Anwendungen erstellt:

• In Kapitel 6 geht es um die reaktive Engine und die Verbindung von imperativer und reaktiver Programmierung.

• Kapitel 7 ist ein tiefer Einblick in SmallRye Mutiny, die reaktive Programmierbibliothek, die in Quarkus verwendet wird.

• Kapitel 8 erklärt die Eigenschaften von HTTP-Anfragen und wie wir mit HTTP reaktiv sein können.

• In Kapitel 9 wird erklärt, wie du Quarkus verwenden kannst, um hochgradig nebenläufige und effiziente Anwendungen zu entwickeln, die mit einer Datenbank interagieren.

Der letzte Teil, Teil IV, verbindet die Punkte und zeigt, wie du mit Quarkus reaktive Systeme bauen kannst:

• Kapitel 10 befasst sich mit der Integration von Quarkus-Anwendungen mit Messaging-Technologien, einem wesentlichen Bestandteil reaktiver Systeme.

• Kapitel 11 befasst sich mit der Integration von Apache Kafka und AMQP und wie man damit reaktive Systeme aufbaut.

• Kapitel 12 untersucht die verschiedenen Möglichkeiten, HTTP-Endpunkte von einer Quarkus-Anwendung zu nutzen und wie man Ausfallsicherheit und Reaktionsfähigkeit erzwingen kann.

• Kapitel 13 befasst sich mit der Beobachtbarkeit reaktiver Systeme, wie Selbstheilung, Tracing und Monitoring.

Wir machen dich bereit

In diesem Buch wirst du viele Code-Beispiele sehen. Diese Beispiele veranschaulichen die in diesem Buch behandelten Konzepte. Einige sind einfach und laufen in einer IDE, andere erfordern ein paar Voraussetzungen.

Diese Beispiele werden im Laufe des Buches nacheinander behandelt. Vielleicht magst du keine Spannung, oder du hast es schon satt, uns lange reden zu hören, und willst einfach nur sehen, wie es funktioniert. Wenn das der Fall ist, rufe einfach https://github.com/cescoffier/reactive-systems-in-java auf und probiere es aus. Du kannst den Code mit Git abrufen, indem du git clone https://github.com/cescoffier/reactive-systems-in-java.git verwendest. Alternativ kannst du eine ZIP-Datei herunterladen und sie entpacken.

Der Code ist nach Kapiteln geordnet. Der Code zu Kapitel 2 befindet sich zum Beispiel im Verzeichnis chapter-2(Tabelle P-1). Je nach Kapitel kann der Code in mehrere Module aufgeteilt sein. Bei Beispielen, die im Code-Repository verfügbar sind, gibt der Titel des Codeschnipsels im Buch an, wo sich die Datei im Repository befindet.

Tabelle P-1. Code-Standort pro Kapitel

Kapitel	Titel	Pfad
Kapitel 2	Einführung in Quarkus	https://github.com/cescoffier/reactive-systems-in-java/tree/master/chapter-2
Kapitel 3	Die dunkle Seite der verteilten Systeme	https://github.com/cescoffier/reactive-systems-in-java/tree/master/chapter-3
Kapitel 4	Entwurfsprinzipien für reaktive Systeme	https://github.com/cescoffier/reactive-systems-in-java/tree/master/chapter-4
Kapitel 5	Reaktive Programmierung: Die Zähmung der Asynchronität	https://github.com/cescoffier/reactive-systems-in-java/tree/master/chapter-5
Kapitel 7	Mutiny: Eine ereignisgesteuerte reaktive Programmierschnittstelle	https://github.com/cescoffier/reactive-systems-in-java/tree/master/chapter-7
Kapitel 8	HTTP mit Reaktivität im Hinterkopf	https://github.com/cescoffier/reactive-systems-in-java/tree/master/chapter-8
Kapitel 9	Reaktiver Zugriff auf Daten	https://github.com/cescoffier/reactive-systems-in-java/tree/master/chapter-9
Kapitel 10	Reaktive Botschaften: Das Bindegewebe	https://github.com/cescoffier/reactive-systems-in-java/tree/master/chapter-10
Kapitel 11	Der Event Bus: Das Rückgrat	https://github.com/cescoffier/reactive-systems-in-java/tree/master/chapter-11
Kapitel 12	Reaktiver REST-Client: Verbinden mit HTTP-Endpunkten	https://github.com/cescoffier/reactive-systems-in-java/tree/master/chapter-12
Kapitel 13	Beobachtung reaktiver und ereignisgesteuerter Architekturen	https://github.com/cescoffier/reactive-systems-in-java/tree/master/chapter-13

Die Beispiele aus dem Code Repository verwenden Java 11. Achte also darauf, dass du ein geeignetes Java Development Kit (JDK) auf deinem Rechner installiert hast. Außerdem verwenden sie Apache Maven als Build-Tool. Du musst Maven nicht installieren, da das Repository den Maven Wrapper verwendet (der Maven automatisch bereitstellt).Wenn du es jedoch lieber selbst installieren möchtest, lade es von der Apache Maven Project Website herunter und befolge die Anweisungen auf der Seite Installing Apache Maven.

Um den Code zu bauen, führe mvn verify im Stammverzeichnis des Projekts aus. Maven wird eine Reihe von Artefakten herunterladen, also stelle sicher, dass du eine Internetverbindung hast.

Dieses Buch behandelt Quarkus, einen Kubernetes-nativen Java-Stack. Du musst nichts installieren, um Quarkus zu nutzen, solange du Java und Maven hast. Alles andere wird automatisch heruntergeladen.

Du brauchst Docker. Docker wird verwendet, um Container für unsere Anwendungen zu erstellen.Installiere Docker, indem du den Anweisungen auf der Seite Get Docker folgst.

Abschließend wird in mehreren Kapiteln der Einsatz unserer reaktiven Anwendungen in Kubernetes erläutert.Für den Einsatz in Kubernetes benötigst du zunächst kubectl, ein Kommandozeilentool für die Interaktion mit Kubernetes. Installiere es, indem du den Anweisungen auf der Seite Kubernetes Install Tools folgst. Wenn du keinen Kubernetes-Cluster zur Hand hast, empfehlen wir außerdem die Installation von minikube, um eine Kubernetes-Umgebung bereitzustellen. Folge den Anweisungen auf der minikube-Website, um es zu installieren.

Warum brauchen wir all diese Werkzeuge? Du wirst in diesem Buch sehen, dass reaktive Anwendungen nicht nur deine Anwendung, sondern auch deine Infrastruktur einschränken. Kubernetes stellt die Primitive bereit, die wir brauchen, um Anwendungen bereitzustellen, Replikate zu erstellen und unser System auf Kurs zu halten. Auf der anderen Seite bietet Quarkus die Funktionen, die wir brauchen, um reaktive Anwendungen zu implementieren, einschließlich nicht blockierender I/O, reaktiver Programmierung, reaktiver APIs und Messaging-Funktionen. Quarkus bietet auch eine Integration mit Kubernetes, um die Bereitstellung und Konfiguration von Anwendungen zu erleichtern.

Tabelle P-2 listet die Werkzeuge auf, die wir in diesem Buch verwenden werden.

Tabelle P-2. In diesem Buch verwendete Werkzeuge

Werkzeug	Website	Beschreibung
Java 11	https://adoptopenjdk.net	Java Virtual Machine (JVM) und Java Development Kit (JDK)
Apache Maven	https://maven.apache.org/download.cgi	Werkzeug zur Build-Automatisierung, basierend auf dem Projektobjektmodell (POM)
Quarkus	https://quarkus.io	Ein Kubernetes-nativer Stack, der Java für Container optimiert
Docker	https://www.docker.com/get-started	Erstellung und Ausführung von Containern
Kubernetes	https://kubernetes.io	Eine Container-Orchestrierungsplattform, auch bekannt als K8s
minikube	https://minikube.sigs.k8s.io/docs/start	Eine lokale Verteilung von Kubernetes
GraalVM	https://www.graalvm.org	Stellt u.a. einen Compiler zur Verfügung, um aus Java-Code native ausführbare Dateien zu erstellen
Node.js	https://nodejs.org/en	Eine JavaScript-Laufzeit-Engine

In diesem Buch verwendete Konventionen

In diesem Buch werden die folgenden typografischen Konventionen verwendet:

Kursiv

Weist auf neue Begriffe, URLs, E-Mail-Adressen, Dateinamen und Dateierweiterungen hin.

Constant width

Wird für Programmlistings sowie innerhalb von Absätzen verwendet, um auf Programmelemente wie Variablen- oder Funktionsnamen, Datenbanken, Datentypen, Umgebungsvariablen, Anweisungen und Schlüsselwörter hinzuweisen.

Constant width bold

Zeigt Befehle oder anderen Text an, der vom Benutzer wortwörtlich eingetippt werden sollte.

Constant width italic

Zeigt Text an, der durch vom Benutzer eingegebene Werte oder durch kontextabhängige Werte ersetzt werden soll.

Tipp

Dieses Element steht für einen Tipp oder eine Anregung.

Hinweis

Dieses Element steht für einen allgemeinen Hinweis.

Warnung

Dieses Element weist auf eine Warnung oder einen Warnhinweis hin.

O'Reilly Online Learning

Hinweis

Seit mehr als 40 Jahren bietet O'Reilly Media Schulungen, Wissen und Einblicke in Technologie und Wirtschaft, um Unternehmen zum Erfolg zu verhelfen.

Unser einzigartiges Netzwerk von Experten und Innovatoren teilt sein Wissen und seine Erfahrung durch Bücher, Artikel und unsere Online-Lernplattform. Die Online-Lernplattform von O'Reilly bietet dir On-Demand-Zugang zu Live-Trainingskursen, ausführlichen Lernpfaden, interaktiven Programmierumgebungen und einer umfangreichen Text- und Videosammlung von O'Reilly und über 200 anderen Verlagen. Weitere Informationen erhältst du unter http://oreilly.com.

Wie du uns kontaktierst

Bitte richte Kommentare und Fragen zu diesem Buch an den Verlag:

• O'Reilly Media, Inc.
• 1005 Gravenstein Highway Nord
• Sebastopol, CA 95472
• 800-998-9938 (in den Vereinigten Staaten oder Kanada)
• 707-829-0515 (international oder lokal)
• 707-829-0104 (Fax)

Wir haben eine Webseite für dieses Buch, auf der wir Errata, Beispiele und zusätzliche Informationen auflisten. Du kannst diese Seite unter https://oreil.ly/ReactiveSysJava aufrufen .

Schreib eine E-Mail an [e-mail], um Kommentare oder technische Fragen zu diesem Buch zu stellen.

Neuigkeiten und Informationen über unsere Bücher und Kurse findest du unter http://oreilly.com.

Finde uns auf Facebook: http://facebook.com/oreilly

Folge uns auf Twitter: http://twitter.com/oreillymedia

Schau uns auf YouTube: http://youtube.com/oreillymedia

Danksagungen

Ein Buch zu schreiben ist nie einfach. Es ist eine lange und anstrengende Aufgabe, die viel Energie kostet und viel Zeit mit der Familie verschlingt. Deshalb geht unser erster Dank an unsere Familien, die uns während dieses Marathons unterstützt haben.

Wir sind auch dankbar, dass wir mit außergewöhnlichen Menschen bei Red Hat zusammenarbeiten. Unzählige Menschen haben uns auf dieser Reise geholfen; es ist unmöglich, sie alle zu nennen. Ein besonderer Dank gilt Georgios Andrianakis, Roberto Cortez, Stuart Douglas, Stéphane Epardaud, Jason Greene, Sanne Grinovero, Gavin King, Martin Kouba, Julien Ponge, Erin Schnabel, Guillaume Smet, Michal Szynkiewicz, Ladislav Thon und Julien Viet. Ihre Arbeit ist nicht nur brillant, sondern auch atemberaubend. Es ist ein Privileg für uns, mit so hochkarätigen Entwicklern zusammenzuarbeiten.

Schließlich danken wir allen Gutachtern, die uns fantastisches und konstruktives Feedback gegeben haben: Mary Grygleski, Adam Bellemare, Antonio Goncalves, Mark Little, Scott Morrison, Nick Keune und Chris Mayfield.