Get ready for java.util.concurrent.Flow!

Slide 1

Slide 1 text

No content

Slide 2

Slide 2 text

● ● ● ● ● ●

Slide 3

Slide 3 text

List list = Arrays.asList(1, 2, 3, 4, 5); for (Integer n : list) { if (n % 2 == 0) { operate(n); } }

Slide 4

Slide 4 text

● ● ● ● ● ● ● ●

Slide 5

Slide 5 text

No content

Slide 6

Slide 6 text

Publisher pushes data to Subscriber onSubscribe onNext onError onComplete

Slide 7

Slide 7 text

No content

Slide 8

Slide 8 text

List list = Arrays.asList(1, 2, 3, 4, 5); for (Integer n : list) { if (n % 2 == 0) { operate(n); } }

Slide 9

Slide 9 text

List list = Arrays.asList( , , , , ); for (Integer n : list) { if (n % 2 == 0) { operate(n); } } 1 2 4 3 5

Slide 10

Slide 10 text

1 2 4 3 5 filter(n -> n % 2 == 0) 2 4

Slide 11

Slide 11 text

1 2 4 3 5 Flowable.fromArray( , , , , ) .filter(n -> n % 2 == 0) .subscribe(n -> operate(n));

Slide 12

Slide 12 text

Flowable.fromArray(1, 2, 3, 4, 5) .filter(n -> n % 2 == 0) .subscribe(n -> operate(n));

Slide 13

Slide 13 text

No content

Slide 14

Slide 14 text

No content

Slide 15

Slide 15 text

● RxJava 1 ○ ○ ○ ● RxJava 2 ○ ○ ○

Slide 16

Slide 16 text

● Observable ○ ○ ● Completable ○ ○ ● Flowable ○ ○ ● Single ○ ● Maybe ○

Slide 17

Slide 17 text

Observable.range(1, 10) .map(i -> i * 100) .doOnNext(i -> printNumberWithThreadInfo("emitting", i)) .map(i -> i * 10) .subscribeOn(Schedulers.computation()) .observeOn(Schedulers.newThread()) .subscribe(integer -> printNumberWithThreadInfo("received", integer));

Slide 18

Slide 18 text

Slide 19

Slide 19 text

No content

Slide 20

Slide 20 text

List list = new ArrayList<>(); new Thread(() -> ((Callback) () -> { list.add("one"); ((Callback) () -> { list.add("two"); ((Callback) () -> { list.add("three"); System.out.println(list.stream().collect(Collectors.joining(" "))); }).execute(); }).execute(); }).execute()).start(); ● ● ● ●

Slide 21

Slide 21 text

Flowable .fromCallable(() -> "one") .flatMap(name -> Flowable.fromCallable(() -> name.concat(" two"))) .flatMap(name -> Flowable.fromCallable(() -> name.concat(" three"))) .subscribe(System.out::println);

Slide 22

Slide 22 text

flowable.subscribe(new Subscriber() { @Override public void onSubscribe(Subscription s) { } @Override public void onNext(Object o) { } @Override public void onError(Throwable throwable) { System.out.println(throwable.getMessage()); } @Override public void onComplete() { } }); Subscriber

Slide 23

Slide 23 text

Map words = new HashMap(); Flowable .fromArray(1, 2, 3, 4, 5) .flatMap(i -> Flowable.just(i * 2)) .map(words::get) .throttleWithTimeout(1, TimeUnit.SECONDS) .lastElement() .subscribe(System.out::println);

Slide 24

Slide 24 text

sample( ) throttleLast( ) throttleFirst( ) throttleWithTimeout( ) debounce( ) BUFFER LATEST DROP Flowable

Slide 25

Slide 25 text

No content

Slide 26

Slide 26 text

No content

Slide 27

Slide 27 text

No content

Slide 28

Slide 28 text

Flux.just(1, 2, 3, 4) .subscribe(System.out::println); Mono.just("foo") .subscribe(System.out::println); Flowable Single

Slide 29

Slide 29 text

List list = new ArrayList<>(); ActorSystem actorSystem = ActorSystem.create(); ActorMaterializer mat = ActorMaterializer.create(actorSystem); Source source = Source.range(1, 5); source.runForeach(list::add, mat);

Slide 30

Slide 30 text

Flowable flowable = Flowable.just(1, 2, 3, 4); Flux flux = Flux.just(5, 6, 7, 8); flowable .mergeWith(flux) .sorted() .subscribe(System.out::println); io.reactivex.Flowable reactor.core.publisher.Flux org.reactivestreams.Publisher java.util.concurrent.Flow.Publisher

Slide 31

Slide 31 text

● ● ● ● provide interfaces are their implementations ● ●

Slide 32

Slide 32 text

Publisher pushes data to Subscriber onSubscribe onNext onError onComplete java.util.concurrent.Flow

Slide 33

Slide 33 text

Flow.Publisher publisher = subscriber -> { … // to be implemented }; publisher.subscribe(new Flow.Subscriber<>() { @Override public void onSubscribe(Flow.Subscription subscription) { ... } @Override public void onNext(Integer item) { ... } @Override public void onError(Throwable throwable) { ... } @Override public void onComplete() { ... } }); Publisher Subscriber

Slide 34

Slide 34 text

Just for a presentation demo it’s better to use production ready libraries has to pass TCK (Technology Compatibility Kit) tests to keep RS ecosystem healthy!

Slide 35

Slide 35 text

No content

Slide 36

Slide 36 text

No content

Slide 37

Slide 37 text

● part of Java 9 language ● interfaces for reactive applications without implementations ● external production ready implementations RxJava Reactor Akka Stream ● have to be compatible with TCK ● data transformation ● callback hell ● asynchronous operations ● efficient consumption of the hardware resources ● error handling API ● can be used anywhere ● clean maintainable concise modern

Slide 38

Slide 38 text

Thank you for the attention! https://github.com/pwittchen/java-flow-experiments https://speakerdeck.com/pwittchen