How do you create a reactive stream in Java?

Table of Contents

• Introduction
• Understanding the Basics: Mono and Flux
  • 1. Mono
  • Example of a Mono stream:
  • 2. Flux
  • Example of a Flux stream:
• Creating a Reactive Stream with Mono and Flux
  • 1. Using **Mono.just()** and **Flux.just()**
    • Example with Mono.just():
    • Example with Flux.just():
  • 2. Creating Empty Streams with **Mono.empty()** and **Flux.empty()**
    • Example with Mono.empty():
    • Example with Flux.empty():
  • 3. Creating a Stream with Delayed Items
    • Example with Mono.delay():
    • Example with Flux.interval():
• Operators for Manipulating Reactive Streams
  • 1. Transforming Elements
    • Example with map():
  • 2. Filtering Elements
    • Example with filter():
  • 3. Combining Streams
    • Example with concat():
• Conclusion

Introduction

In Java, reactive streams are a powerful tool for handling asynchronous, non-blocking data streams. Reactive programming allows for more efficient handling of I/O-bound operations, like database calls or API requests, by using a stream of data that can be processed in a non-blocking manner.

A reactive stream is defined by a sequence of elements that can be asynchronously processed and emitted to subscribers. In Java, this concept is implemented in the Reactive Streams API and is most commonly used with Project Reactor, a library built on top of the Reactive Streams specification.

In this article, we'll explore how to create reactive streams using Project Reactor, including Mono and Flux, the two main abstractions in reactive programming, and how they help create non-blocking data flows.

Understanding the Basics: Mono and Flux

In Project Reactor, there are two main types for working with reactive streams:

1. Mono

• Mono is a reactive stream that emits at most one element. It can be used for operations where you expect a single value or no value at all.
• Mono represents an asynchronous computation that may yield a result (or fail).

Example of a Mono stream:

In the example above, we created a Mono that emits a single value "Hello, Reactive World!". When subscribe() is called, the value is printed to the console.

2. Flux

• Flux is a reactive stream that can emit 0 to N elements. It's useful for handling multiple items, such as streams of data, collections, or events.
• A Flux can represent an asynchronous computation that produces a sequence of values over time.

Example of a Flux stream:

Here, we created a Flux that emits multiple values: "apple", "banana", and "cherry". The subscribe() method is used to print each of these values to the console.

Creating a Reactive Stream with Mono and Flux

1. Using **Mono.just()** and **Flux.just()**

The simplest way to create a reactive stream in Java is by using Mono.just() for a single item or Flux.just() for multiple items.

Example with Mono.just():

Example with Flux.just():

2. Creating Empty Streams with **Mono.empty()** and **Flux.empty()**

You can create an empty stream using Mono.empty() for no items or Flux.empty() for an empty sequence.

Example with Mono.empty():

Example with Flux.empty():

3. Creating a Stream with Delayed Items

In reactive programming, you can also create streams that emit items after a delay or at a regular interval.

Example with Mono.delay():

Example with Flux.interval():

Operators for Manipulating Reactive Streams

In reactive programming, operators are methods that transform, filter, or combine reactive streams. Project Reactor provides a rich set of operators that can be applied to Mono and Flux objects.

1. Transforming Elements

You can use operators like map() and flatMap() to transform items in a stream.

Example with map():

2. Filtering Elements

You can filter the items in the stream with filter().

Example with filter():

3. Combining Streams

Reactive streams can be combined using operators like concat(), merge(), or zip().

Example with concat():

Conclusion

Creating reactive streams in Java using Project Reactor allows you to build highly efficient, non-blocking applications. By leveraging the **Mono** and **Flux** types, you can represent a variety of asynchronous data flows, from a single value to multiple items over time.

Key points to remember:

• Mono: Represents a single value or no value at all (0 or 1 item).
• Flux: Represents a sequence of 0 to N items.
• Operators: Transform, filter, and combine data in reactive streams.

Reactive programming is especially beneficial when working with I/O-bound tasks or handling a large number of concurrent connections, making it ideal for building scalable and responsive applications. With Project Reactor, Java developers can embrace non-blocking programming patterns and unlock the full potential of reactive streams.