0Pricing
Spring Boot 4 Complete Guide · Pelajaran

Spring WebFlux & Reactor Core

Bangun API REST reaktif menggunakan Spring WebFlux, dengan menggunakan `Mono` dan `Flux` dari Reactor Core.

Spring WebFlux & Reactor Core adalah pelajaran Spring Boot 4 Complete Guide gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Spring Boot 4 Complete Guide, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Spring Boot 4 Complete Guide mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Spring WebFlux & Reactor Core” gratis?

Ya — teks lengkap “Spring WebFlux & Reactor Core” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Spring Boot 4 Complete Guide, upgrade ke CoddyKit PRO. Kursus Spring Boot 4 Complete Guide mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Spring WebFlux & Reactor Core”?

Bangun API REST reaktif menggunakan Spring WebFlux, dengan menggunakan `Mono` dan `Flux` dari Reactor Core. Kamu berlatih Spring Boot 4 Complete Guide dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Spring Boot 4 Complete Guide?

Tidak diperlukan pengalaman sebelumnya. Spring Boot 4 Complete Guide di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Spring WebFlux & Reactor Core” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Spring Boot 4 Complete Guide ini?

Ya. Setiap pelajaran Spring Boot 4 Complete Guide menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Pengenalan Pemrograman Reaktif
  2. Spring WebFlux & Reactor Core
  3. Akses & Integrasi Data Reaktif
  4. Tekanan Balik dan Penanganan Galat dalam Aliran Reaktif
← Kembali ke Spring Boot 4 Complete Guide