Java
Summary - Reactive
Combine Flow API and SubmissionPublisher to write a temperature monitor.
Summary - Reactive
In this group we saw the foundations of Reactive Streams: the three interfaces of the Flow API, the interaction of Publisher and Subscriber, a ready Publisher with SubmissionPublisher, demand control with backpressure, and declarative flow with Project Reactor Mono. These organize asynchronous data flow.
The Flow API contract is standard; Reactor wraps it in a declarative style. Backpressure prevents memory bloat with demand-based delivery. Now we review flow and subscription with two small tasks.
Contract and library
The Flow API only defines the contract; how items are delivered is up to the implementation. SubmissionPublisher offers an asynchronous implementation, while you can also write your own synchronous Publisher. Reactor adds declarative operators on top of this contract.
The key is that, whichever path you pick, the flow goes from Publisher to Subscriber and demand comes from the Subscriber. These two principles are the foundation of all reactive applications. When the flow ends, onComplete comes; on error, onError.
Exercise Filter and transform with Mono
Create a Mono with Mono.just(3). Filter with .filter(x -> x > 1). Increase by one with .map(x -> x + 1). Print the result with .subscribe(System.out::println).
Show example solution
import reactor.core.publisher.Mono;
public class MonoFilterDemo {
public static void main(String[] args) {
Mono.just(3)
.filter(x -> x > 1)
.map(x -> x + 1)
.subscribe(System.out::println);
}
}
Exercise Count two subscribers
Define an EmptySubscriber class that implements Subscriber<Integer> (onSubscribe calls request(1), the rest are empty). In main, create new SubmissionPublisher<Integer>(), subscribe two EmptySubscribers, and print the getNumberOfSubscribers result with System.out.println. Then close with pub.close().
Show example solution
import java.util.concurrent.SubmissionPublisher;
import java.util.concurrent.Flow.*;
class EmptySubscriber implements Subscriber<Integer> {
public void onSubscribe(Subscription s) { s.request(1); }
public void onNext(Integer v) { }
public void onError(Throwable t) { }
public void onComplete() { }
}
public class SubCountDemo {
public static void main(String[] args) {
SubmissionPublisher<Integer> pub = new SubmissionPublisher<>();
pub.subscribe(new EmptySubscriber());
pub.subscribe(new EmptySubscriber());
System.out.println(pub.getNumberOfSubscribers());
pub.close();
}
}
Test yourself
-
Which side sets backpressure?
- Subscriber
- Channel
- Publisher
- Buffer
Show answer
Subscriber — The Subscriber sets the demand with request.
-
Complete the subscribe call
pub.____(new EmptySubscriber());
Show answer
pub.subscribe(new EmptySubscriber());
Next lesson: native methods
