Twitter & GitHub: romanroe

Transkript

1 ReactiveX mit RxJava Roman Roelofsen - WK GmbH / thecodecampus Twitter & GitHub: romanroe

2 Über mich Alpha Geek, Entwickler, Trainer WK GmbH - The Web Engineers Individualsoftware thecodecampus Schulungsanbieter Angular & TypeScript

3 Reaktive Programmierung

4 ... a programming paradigm oriented around data flows and the propagation of change."

5 Im Kleinen Strom von Daten: Liste Änderungen verfolgen: Events (Mouse-Clicks,...) Im Großen Strom von Daten: Web-Sockets Änderungen verfolgen: Message Bus

6 Iterator java.util.iterator Synchron, Pull Keine Fehler-Konzept Callback java.util.function.funtion<t, R> Asynchron, Push Kein standardisiertes Fehler-Konzept

7 Reactive Programming = Iterator + Callback (+ Fehlerbehandlung)

8 ReactiveX RxJava Implementierungen für Java, JavaScript/TypeScript,.NET, Scala, Clojure, Swift, etc.

9 Java Flow API ab Java 9 Reactive Programming basierend auf Observable -> Flowable *Subject -> *Processor

10 API Observable Liefert Daten Observer Bekommt Daten subscribe am Observable -> Disposable

11 Operatoren Methoden am Observable map/filter/... Kombination von Observables flatmap/withlatestfrom/... Operatoren erzeugen immer neue Observables

12 Demo - Operatoren

13 API - cold/synchron Observable<Integer> observable = Observable.create(e -> { e.onnext(); e.onnext(2); e.oncomplete(); }); observable.subscribe(new Observer<Integer>() { public void onsubscribe(disposable d) { } public void onnext(integer i) { } public void onerror(throwable e) { } public void oncomplete() { } });

14 Fehlerbehandung Observer Observable<Integer> observable = Observable.create(e -> { e.onnext(); e.onnext(2); e.onerror(new RuntimeException("error")); e.onnext(3); // wird nicht "gesendet" }); Stream termininert bei einem Fehler!

15 Use Cases Http Client - RxNetty HttpClient.newClient(serverAddress).enableWireLogging("hello-client", LogLevel.ERROR).createGet("/hello").doOnNext(resp -> logger.info(resp.tostring())).flatmap(resp -> resp.getcontent().map(bb -> bb.tostring(charset.defaultcharset())))

16 Http Client - Netflix Ribbon

17 User Interface

18 Subject

19 Observable und Observer Multiplexer Puffer

20 Nützlich, wenn Datenquelle nicht verschachtelt werden kann Observable.create(e -> { }); z.b. Servlet -> Subject -> Observer public class Servlet extends HttpServlet { protected void doget(httpservletrequest req, HttpServletResponse res) { subject.onnext(pair.of(req, res)); } }

21 PublishSubject Subject<Integer> sub = PublishSubject.create(); sub.onnext(); sub.onnext(2); sub.subscribe(system.out::println); sub.onnext(3); Ausgabe 3

22 ReplaySubject Subject<Integer> sub = ReplaySubject.createWithSize(3); sub.onnext(); sub.onnext(2); sub.onnext(3); sub.onnext(4); sub.onnext(5); sub.subscribe(system.out::println); sub.onnext(6); Ausgabe

23 ReplaySubject Subject<Integer> sub = BehaviorSubject.createDefault(99); sub.subscribe(system.out::println); sub.onnext(); sub.onnext(2); sub.onnext(3); Ausgabe

24 Java 9 Flow API

25 Flowable.create(subscriber -> { int count = 0; while (true) { subscriber.onnext(count++); } }, BackpressureStrategy.DROP).observeOn(Schedulers.newThread(), false, ).subscribe(val -> { Thread.sleep(000); System.out.println(val); ); }

26 Flowable.create(subscriber -> { int count = 0; while (true) { subscriber.onnext(count++); } }, BackpressureStrategy.MISSING).onBackpressureDrop().observeOn(Schedulers.newThread(), false, ).subscribe(val -> { Thread.sleep(000); System.out.println(val); ); }

27 Flowable.create(subscriber -> { int count = 0; while (true) { subscriber.onnext(count++); } }, BackpressureStrategy.MISSING).onBackpressureBuffer(0).observeOn(Schedulers.newThread(), false, ).subscribe(val -> { Thread.sleep(000); System.out.println(val); ); }

28 Marble Diagramme

29 zip

30 map

31 flatmap

32 Schedulers

33 Observable Streams sind nicht grundsätzlich asynchron! Schedulers verlagern den Observer und die Operatoren in Threads obs$.observeon(schedulers.io()).map(i -> iobound(i)); obs$.observeon(schedulers.computation()).map(i -> heavyoncpu(i));

34 Integrationsmöglichkeiten

35 Mit Observable/Observer lassen sich alle Kommunikationsszenarien abbilden Lokal JDBC Thread Kommunikation Remote REST WebServices

36 Servlets

37 JDBC

38 Diverses Ratpack - Akka - RxJS

39 Fazit Lernkurve: kurz flach dann lange steil dann wieder flach ReactiveX macht komplexe Datenflüsse "einfach" Keine komplexe Datenflüsse? Dann ggf. overkill Kein echtes Projekt zum Lernen nehmen

40 Roman Roelofsen - wk