Schnell reagiert! Reaktive Systeme auf der Java-Plattform mit Vert.x und Reactor

Martin Lehmann: „Schnell reagiert! Reaktive Systeme auf der Java-Plattform mit Vert.x und Reactor“. Java Forum Stuttgart 2015, 9. Juli 2015

Transcript

1. 1 Schnell reagiert! Reaktive Systeme auf der Java-Plattform mit Vert.x und Reactor Martin Lehmann, Accso GmbH – Java Forum Stuttgart 2015
2. 3  Diplom-Informatiker  Seit 2010 Mitglied der Geschäftsleitung und CTO bei der Accso – Accelerated Solutions GmbH in Darmstadt www.accso.de  Seit Ende der 90er Jahre in Projekten für Individualentwicklung, v.a. als Technischer Architekt und Berater  Schwerpunkte: Java, SW-Architektur, Entwicklungsmethodik, Verteilte Systeme  Aktive Mitarbeit im iSAQB jfs2015:~ # who am i
3. 4 Copyright © Accso GmbH Reaktive Systeme Vert.x und Demo Reactor Framework Reactive Streams Fazit Reaktive Systeme
4. 5 Copyright © Accso GmbH Anforderungen an Performance: Geringe Antwortzeiten, minimale Latenz, hoher Durchsatz Anforderungen an Skalierbarkeit: steigende Nutzerzahlen, Multi-Core Anforderungen an Verfügbarkeit: 24x7, Failover, hohe Fehlertoleranz Was sind die Anforderungen? Forderungen des Reactive Manifesto: Responsive, Resilient, Elastic, Message-Driven Event-basiert Viele parallele Requests Viele Abnehmer Pipelining, Verarbeitungsketten
5. 7 Copyright © Accso GmbH Wetterdaten aus aller Welt Verteilung Aggregation Archivierung Monitoring Archiv
6. 8 Copyright © Accso GmbH Aktoren- Modell Nebenläufigkeitsprogrammierung mit Low-Level-APIs ist komplex: Kompliziert und damit fehleranfällig! Reactor Pattern Weitere Anforderung: Beherrschbarkeit der Komplexität „Altbekannte“ Nebenläufigkeitsprogrammierung nutzt i.d.R. Ressourcen nicht optimal aus. LMAX Disruptor
7. 9 Copyright © Accso GmbH Aktorenmodell Carl Hewitt, 1973 Modell für nebenläufige Programmierung Aktoren sind die ausführbaren Einheiten im System Shared-Nothing-Architektur (kein globaler Zustand) Kommunikation nur über asynchrones Messaging Aktor Aktor Aktor State State State
8. 10 Copyright © Accso GmbH Design Pattern für Event-Handling Reactor = Dispatcher (von Events an Callback-Handler) Entkoppelt Applikationslogik von Ausführungslogik Reactor Pattern: Ausführung auf 1 Event-Loop-Thread Multi-Reactor Pattern: Skalierung auf n ELTs Handler müssen Blockierung des ELT vermeiden! (Multi-)Reactor Pattern Douglas Schmidt u.a., 1996f Client Client Client Event Loop
9. 11 Copyright © Accso GmbH (Multi-)Reactor Pattern Douglas Schmidt u.a., 1996f loop { // you control the flow doSomething(); } registerHandler(doSomething); loop { // event loop controls the flow // calls registered callback event = getEventFromEventQueue(); dispatch(event); } Event Driven Normal
10. 12 Copyright © Accso GmbH ab 2010 bis heute …
11. 13 Copyright © Accso GmbH Reaktive Systeme Vert.x und Demo Reactor Framework Reactive Streams Fazit Vert.x und Demo http://vertx.io/
12. 14 Copyright © Accso GmbH Vert.x im Überblick JVM 2.1.5 (und 3) modular Laufzeit- Umgebung nicht- blockierend Message- Bus polyglott nebenläufig single-threaded Laufzeitmodell Programmiermodell Open- Source
13. 15 Copyright © Accso GmbH Vert.x Cluster Vert.x Laufzeitumgebung Vert.x Laufzeitumgebung Vert.x Modul Event-Bus Verticle Verticle Verticle A Verticle Verticle Verticle Verticle B Verticle Verticle A Verticle Verticle Verticle C Shared Data Shared Data Event Loop Threads Event Loop Threads Browser Java- script SockJS Clustering (Hazelcast) Clustering (Hazelcast) Die Baustein-Architektur von Vert.x
14. 16 Copyright © Accso GmbH Die Laufzeit-Architektur von Vert.x Vert.x Laufzeitumgebung Event Loop Thread 1 Event Loop Thread 2 Event Loop Thread 3 Event Loop Thread 4 Zeit Verticle A Verticle B Verticle A Verticle C Verticle D Verticle E Verticle F Verticle F Verticle G Verticle H
15. 17 Copyright © Accso GmbH Die Laufzeit-Architektur von Vert.x Vert.x Laufzeitumgebung Event Loop Thread 1 Event Loop Thread 2 Event Loop Thread 3 Event Loop Thread 4 Zeit Verticle A Verticle B Verticle A Verticle C Verticle D Verticle E Verticle F Verticle F Verticle G Verticle H Verticles werden immer auf demselben ELT ausgeführt! Keine parallele Ausführung! Programmiermodell = single-threaded Blockierung vermeiden! Wenn G blockiert, verhungert H! Langläufige und blockierende Operationen in spezielle Worker- Verticles auslagern! (separater Thread-Pool) Jedes Verticle hat eigenen Classloader. Kein Shared State!
16. 18 Copyright © Accso GmbH Demo
17. public class HelloWorldHttpServer extends Verticle { @Override public void start() { vertx.createHttpServer(). requestHandler( (HttpServerRequest req) -> { logInfoString(" received request " + req.remoteAddress() + " for " + req.path()); req.response().putHeader("content-type", "text/plain") .end("Hello JFS!"); } ).listen(8123); logInfoString("registered HTTP server on port 8123"); }
18. public class PongVerticle extends Verticle { @Override public void start() { Handler<Message<String>> handler = new Handler<Message<String>>() { public void handle(Message<String> message) { logInfoString(" receives message " + message.body()); vertx.eventBus().send(BUS_ADDRESS_PONG, "pong"); } }; // Obiger Handler wird fuer "Ping"-Nachrichten registriert vertx.eventBus().registerHandler(BUS_ADDRESS_PING, handler); logInfoString("PongVerticle has been registered for " + BUS_ADDRESS_PING); }
19. public class PingVerticle extends Verticle { @Override public void start() { Handler<Message<String>> handler = new Handler<Message<String>>() { public void handle(Message<String> message) { logInfoString(" receives message " + message.body()); Handler<Message<String>> replyHandler = this; // erneuten Ping verzoegert nach 1sec rausschicken vertx.setTimer(1000, new Handler<Long>() { public void handle(Long event) { vertx.eventBus().send(BUS_ADDRESS_PING, "ping", replyHandler); } }); } }; // Obiger Handler wird fuer "Pong"-Replys registriert vertx.eventBus().registerHandler(BUS_ADDRESS_PONG, handler); // Bootstrap: Erste, initiale Nachricht an alle PongVerticles // Alle Pong-Verticles muessen vorher gestartet sein, sonst geht Nachricht verloren! vertx.eventBus().send(BUS_ADDRESS_PING, "ping", handler); } Demo
20. public class PingVerticle extends Verticle { @Override public void start() { Handler<Message<String>> handler = new Handler<Message<String>>() { public void handle(Message<String> message) { logInfoString(" receives message " + message.body()); // erneuten Ping verzoegert nach 1sec rausschicken vertx.setTimer(1000, new Handler<Long>() { public void handle(Long event) { vertx.eventBus().publish(BUS_ADDRESS_PING, "ping"); } }); } }; // Obiger Handler wird fuer "Pong"-Replys registriert vertx.eventBus().registerHandler(BUS_ADDRESS_PONG, handler); // Bootstrap: Erste, initiale Nachricht an alle PongVerticles // Alle Pong-Verticles muessen vorher gestartet sein, sonst geht Nachricht verloren! vertx.eventBus().publish(BUS_ADDRESS_PING, "ping"); }
21. 25 Copyright © Accso GmbH Ganz frisch! Vert.x 3.0 24. Juni 2015 Verticles sind nun (potentiell) verzichtbar Modulsystem ist umgebaut Trennung in Core und Web Asynchrone DB-Zugriffe (JDBC, MongoDB, …) Integration von Mail, JCA, Cloud, Docker, … Authentifizierung und Autorisierung Neues Unit-Test-Framework Metriken Cluster-Manager austauschbar Bus-Serialisierung austauschbar Reactive: Rx und Reactive Streams 3.0 Erst mit 3.1
22. 26 Copyright © Accso GmbH Reaktive Systeme Vert.x und Demo Reactor Framework Reactive Streams Fazit Reactor Framework https://github.com/reactor/reactor
23. 27 Copyright © Accso GmbH JVM 2.0.3 Keine Laufzeit- Umgebung Beeinflusst durch: Reactor Pattern, Java 8 Streams Open- Source Reactor-Framework im Überblick polyglott Optimiert auf Performance u. Durchsatz … foundational library for reactive fast data applications
24. 28 Copyright © Accso GmbH Kern des Reactor-Frameworks: Asynchroner Event-Bus Reactor Nimmt Events von Produzenten entgegen Heisst Event-Bus ab Version 2 Dispatcher Scheduling und Routing von Events Nutzt Thread-Pool, Ringbuffer, je nach Konfiguration Selector Bestimmt die Adressaten eines Events Adressierung über Strings, Objekttyp, Regulären Ausdruck, … Consumer Verarbeitet Events Bus-API oder alternativ Stream-API
25. Reactor Framework: Stream-API // Init CountDownLatch latch = new CountDownLatch(10); Environment.initialize(); Broadcaster<String> stream = Streams.broadcast(Environment.get()); // Consumer stream.map(String::toUpperCase) .consume(s -> { System.out.printf("Received %s on thread %s%n", s, Thread.currentThread()); latch.countDown(); }); // Publisher for (int i=0; i<10; i++) { String message = "hello world " + i; System.out.printf("Sending %s on thread %s%n", message, Thread.currentThread()); stream.onNext(message); } stream.onComplete(); // shutdown latch.await() Environment.terminate();
26. 31 Copyright © Accso GmbH Reaktive Systeme Vert.x und Demo Reactor Framework Reactive Streams Fazit Reactive Streams RxJava Ratpack
27. 32 Copyright © Accso GmbH Mit Reactive Streams aus der Callback-Hölle Problem 1: Callback-Hölle public class PingVerticle extends Verticle { @Override public void start() { Handler<Message<String>> handler = new Handler<Message<String>>() { public void handle(Message<String> message) { vertx.setTimer(1000, new Handler<Long>() { public void handle(Long event) { ... } }); } };
28. 33 Copyright © Accso GmbH Sender und Empfänger müssen zusammenarbeiten Sender Empfänger Problem 2: Unterschiedliche Verarbeitungsgeschwindigkeiten
29. 34 Copyright © Accso GmbH Sender und Empfänger müssen zusammenarbeiten Sender Empfänger Problem 2: Unterschiedliche Verarbeitungsgeschwindigkeiten
30. 35 Copyright © Accso GmbH Reactive Streams: Spezifikation von Schnittstellen Publisher Subscriber Publish-Subscribe-Modell (nur JVM-intern, nicht -übergreifend) Subscribe (n Datenpakete) Umgang mit Backpressure im Publisher: Puffern, Verwerfen, Backpressure weiterreichen nach „Upstream“
31. 37 Copyright © Accso GmbH Reaktive Systeme Vert.x und Demo Reactor Framework Reactive Streams Fazit Fazit
32. 38 Copyright © Accso GmbH Zum Nachlesen JavaSPEKTRUM 5/2014 Dr. Rüdiger Grammes, Martin Lehmann, Dr. Kristine Schaal Gut verknotet - Vert.x im Einsatz für hochskalierbare Architekturen PDF: http://goo.gl/j4zyb0 Dr. Rüdiger Grammes, Martin Lehmann, Dr. Kristine Schaal Reaktive Anwendungen mit dem Reactor-Framework http://heise.de/-2405139
33. 39 Begeisterung für die anspruchsvollen Aufgaben unserer Kunden Accso – Accelerated Solutions GmbH www.accso.de twitter.com/accso Berliner Allee 58 64295 Darmstadt Telefon: +49 (6151) 13029-0 Fax: +49 (6151) 13029-10 Moltkestraße 131 a 50674 Köln Telefon: +49 (221) 630691-0 Fax: +49 (221) 630691-10 Theatinerstraße 11 80333 München Telefon: +49 (89) 71042-2040 Fax: + 49 (89) 71042-2001