Publisher and Subscriber Roles in Reactive Java

In reactive Java, publishers and subscribers are the core participants in a reactive stream. The publisher is responsible for generating and emitting data items, while the subscriber consumes those items as they become available. This relationship forms the foundation of asynchronous, non-blocking data processing.

Publishers control the flow of data, sending items only when requested by a subscriber. Subscribers express their interest in data and handle each item as it arrives, managing backpressure to avoid being overwhelmed. This separation of concerns enables you to build scalable, efficient applications that react to data in real time.

Understanding these roles is essential for designing robust reactive systems, as each participant has clear responsibilities that ensure safe and predictable data flow.

Publisher and Subscriber Interaction in Reactive Streams

In reactive streams, publishers and subscribers work together to manage data flow in an efficient, non-blocking way. Understanding their interaction is essential for building responsive and resilient Java applications.

How Publishers and Subscribers Work Together

1. Publisher Creation: You define a publisher that produces data. In Java, this is often an implementation of the Publisher<T> interface;
2. Subscriber Registration: A subscriber expresses interest in the data by subscribing to the publisher. This subscriber implements the Subscriber<T> interface;
3. Subscription Establishment: When the subscriber subscribes, the publisher creates a Subscription object and passes it to the subscriber's onSubscribe() method;
4. Demand Signaling: The subscriber requests a specific number of items from the publisher using the request(n) method of the subscription. This is called backpressure management;
5. Data Delivery: The publisher sends the requested number of data items to the subscriber using the onNext() method;
6. Completion or Error: When all items are sent, the publisher calls onComplete(). If an error occurs, it calls onError(Throwable) instead.

Java Example Reference

Here is a simplified flow using Java's reactive streams interfaces:

package com.example;

import org.reactivestreams.Publisher;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;

public class SimplePublisher implements Publisher<Integer> {
    private final int[] data = {1, 2, 3, 4, 5};

    @Override
    public void subscribe(Subscriber<? super Integer> subscriber) {
        subscriber.onSubscribe(new Subscription() {
            private int index = 0;
            private boolean cancelled = false;

            @Override
            public void request(long n) {
                int sent = 0;
                while (sent < n && index < data.length && !cancelled) {
                    subscriber.onNext(data[index++]);
                    sent++;
                }
                if (index == data.length && !cancelled) {
                    subscriber.onComplete();
                }
            }

            @Override
            public void cancel() {
                cancelled = true;
            }
        });
    }
}

In this example:

• The publisher (SimplePublisher) produces a sequence of integers;
• The subscriber (not shown) would subscribe to the publisher, request items, and handle them as they arrive;
• The publisher only sends the number of items requested, demonstrating backpressure and controlled data flow.

This interaction ensures that data is delivered efficiently, preventing resource exhaustion and enabling responsive applications.