0Pricing
Spring Boot 4 Complete Guide · Lezione

Spring WebFlux e Reactor Core

Creare API REST reattive usando Spring WebFlux e lavorare con `Mono` e `Flux` di Reactor Core.

Spring WebFlux e Reactor Core è una lezione Spring Boot 4 Complete Guide gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Spring Boot 4 Complete Guide, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Spring Boot 4 Complete Guide include 4 lezioni in totale.

Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.

Reactive Web with Spring WebFlux

Welcome to Spring WebFlux! This framework is Spring's answer to building reactive, non-blocking web applications.

Unlike traditional Spring MVC which uses a servlet-based, blocking model, WebFlux is designed for concurrency and high throughput with fewer threads.

It's perfect for microservices and applications needing to handle many concurrent connections efficiently.

Diving into Reactor Core

At the heart of Spring WebFlux lies Reactor Core. Reactor is a reactive programming library that implements the Reactive Streams specification.

It provides two key types for handling asynchronous data streams:

  • Mono: For sequences of 0 or 1 item.
  • Flux: For sequences of 0 to N items.

These types represent publishers that emit data, which subscribers then consume.

`Mono`: Zero or One Element

A Mono is a specialized Publisher that can emit at most one item, or complete without emitting any item, or emit an error.

Think of it as an asynchronous container for a single value. It's ideal for operations that return a single result, like fetching a user by ID or performing a single update.

Your First `Mono`

Let's see Mono in action. We create a Mono and then subscribe() to it. The subscribe() method triggers the data flow.

import reactor.core.publisher.Mono;

public class Main {
  public static void main(String[] args) {
    Mono<String> greetingMono = Mono.just("Hello, Mono!");

    // Subscribe to the Mono to consume the data
    greetingMono.subscribe(
      data -> System.out.println(data), // onNext consumer
      error -> System.err.println("Error: " + error), // onError consumer
      () -> System.out.println("Mono completed.") // onComplete callback
    );
  }
}

`Flux`: Zero to Many Elements

A Flux is a Publisher that can emit 0 to N items over time, and then optionally terminate with a completion signal or an error.

It's perfect for handling streams of data, like a list of products, real-time events, or database query results that return multiple rows.

Your First `Flux`

Here's an example of creating a Flux from a list of items. Just like Mono, you need to subscribe() to start the emission of data.

import reactor.core.publisher.Flux;
import java.util.Arrays;
import java.util.List;

public class Main {
  public static void main(String[] args) {
    List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry");
    Flux<String> fruitFlux = Flux.fromIterable(fruits);

    // Subscribe to the Flux to consume the data stream
    fruitFlux.subscribe(
      data -> System.out.println(data), // onNext consumer for each item
      error -> System.err.println("Error: " + error), // onError consumer
      () -> System.out.println("Flux completed.") // onComplete callback
    );
  }
}

Building Reactive Endpoints

Spring WebFlux seamlessly integrates with Reactor Core's Mono and Flux. You can define your REST endpoints to return these reactive types.

When a WebFlux controller method returns a Mono or Flux, Spring handles the subscription and streaming of data automatically, allowing for non-blocking I/O.

Endpoint Returning `Mono`

Here's how you'd create a simple WebFlux endpoint that returns a Mono<String>. This endpoint would respond with a single string asynchronously.

Note: This code snippet is part of a Spring Boot application and cannot be run in isolation.

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;

@RestController
public class HelloController {

  @GetMapping("/hello-mono")
  public Mono<String> getHelloMono() {
    // Simulate a non-blocking operation that returns a single greeting
    return Mono.just("Hello from Mono endpoint!");
  }
}

Endpoint Returning `Flux`

For endpoints that need to stream multiple items, you can return a Flux<T>. WebFlux will handle sending these items as they become available, often using Server-Sent Events (SSE).

Note: This code snippet is part of a Spring Boot application and cannot be run in isolation.

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;
import java.time.Duration;

@RestController
public class HelloController {

  @GetMapping(value = "/hello-flux", produces = "text/event-stream")
  public Flux<String> getHelloFlux() {
    // Emit 5 items, one every second
    return Flux.interval(Duration.ofSeconds(1))
               .map(sequence -> "Item " + sequence + " from Flux!")
               .take(5); 
  }
}

Check Your Knowledge

Let's test your understanding of Spring WebFlux and Reactor Core.

Recap: WebFlux & Reactor Core

In this lesson, you've learned about the core components of reactive programming with Spring Boot:

  • Spring WebFlux: The non-blocking web framework.
  • Reactor Core: The underlying library providing reactive types.
  • Mono: For handling 0 or 1 data item.
  • Flux: For handling 0 to N data items.

You also saw how to define reactive endpoints in WebFlux controllers by returning Mono and Flux.

Domande Frequenti

La lezione «Spring WebFlux e Reactor Core» è gratuita?

Sì — il testo completo di «Spring WebFlux e Reactor Core» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Spring Boot 4 Complete Guide, passa a CoddyKit PRO. Il corso Spring Boot 4 Complete Guide include 4 lezioni in totale.

Cosa imparerò in «Spring WebFlux e Reactor Core»?

Creare API REST reattive usando Spring WebFlux e lavorare con `Mono` e `Flux` di Reactor Core. Eserciti Spring Boot 4 Complete Guide con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Spring Boot 4 Complete Guide?

Non è richiesta alcuna esperienza precedente. Spring Boot 4 Complete Guide su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Spring WebFlux e Reactor Core»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Spring Boot 4 Complete Guide?

Sì. Ogni lezione Spring Boot 4 Complete Guide include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Introduzione alla programmazione reattiva
  2. Spring WebFlux e Reactor Core
  3. Accesso e integrazione con dati reattivi
  4. Backpressure e gestione degli errori negli stream reattivi
← Torna a Spring Boot 4 Complete Guide