Spring Boot 4 Microservices & REST APIs · Ders

WebFlux ile Eş Zamansız İşleme

Yüksek eşzamanlılığa ve ölçeklenebilirliğe sahip API'ler oluşturmak için Spring WebFlux ile tepkisel programlama uygulayın.

WebFlux ile Eş Zamansız İşleme, CoddyKit'te ücretsiz bir Spring Boot 4 Microservices & REST APIs dersidir. Bu, 9 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Spring Boot 4 Microservices & REST APIs öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Spring Boot 4 Microservices & REST APIs kursu toplamda 9 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

Why Reactive? The Blocking Problem

In traditional applications, when your code needs to wait for something (like a database query or an external API call), it often blocks the current thread.

This means the thread can't do anything else until the operation completes. For many concurrent users, this can lead to:

High resource consumption (many threads).
Slower response times under heavy load.
Limited scalability.

Introducing Spring WebFlux

Spring WebFlux is Spring's reactive web framework, built on Project Reactor. It allows you to build asynchronous, non-blocking applications.

Unlike Spring MVC, which uses a thread-per-request model, WebFlux uses an event-loop model. This means a few threads can handle many concurrent requests efficiently, making your API more scalable.

Core Concepts: Mono and Flux

At the heart of reactive programming in Spring WebFlux are two publishers from Project Reactor:

Mono: Represents a stream that emits 0 or 1 item, then completes (or errors). Think of it like an optional future value.
Flux: Represents a stream that emits 0 to N items, then completes (or errors). This is for collections or continuous streams of data.

They don't do anything until someone subscribes to them!

Your First Reactive Endpoint

Let's create a basic WebFlux controller. Notice we return a Mono<String> instead of a plain String. This tells Spring WebFlux to handle the response reactively.

Try running this example and access /hello in your browser.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;

@SpringBootApplication
@RestController
public class WebfluxApp {

  public static void main(String[] args) {
    SpringApplication.run(WebfluxApp.class, args);
  }

  @GetMapping("/hello")
  public Mono<String> hello() {
    return Mono.just("Hello, WebFlux!");
  }
}

Transforming Data with 'map'

Mono and Flux provide operators to transform data. The map() operator applies a synchronous function to each emitted item.

Here, we transform the "hello" string to uppercase. The original data is not changed, a new transformed value is emitted.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;

@SpringBootApplication
@RestController
public class WebfluxApp {

  public static void main(String[] args) {
    SpringApplication.run(WebfluxApp.class, args);
  }

  @GetMapping("/greet")
  public Mono<String> greet() {
    return Mono.just("hello")
               .map(String::toUpperCase)
               .map(s -> s + " WORLD!");
  }
}

Working with Collections using Flux

When you need to return a stream of multiple items, Flux is your go-to publisher. It can emit zero, one, or many items over time.

Here's an example returning a Flux<String> of fruits. When accessed, the browser will receive the items as a JSON array or a stream, depending on the client's Accept header.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;

@SpringBootApplication
@RestController
public class WebfluxApp {

  public static void main(String[] args) {
    SpringApplication.run(WebfluxApp.class, args);
  }

  @GetMapping("/fruits")
  public Flux<String> getFruits() {
    return Flux.just("Apple", "Banana", "Cherry", "Date");
  }
}

Practical Example: Reactive User Service

Let's combine what we've learned. Imagine a simple User data class. We can create a service that returns a Flux<User>, simulating fetching users from a database with a slight delay to demonstrate asynchronicity.

This endpoint will stream users as they become available, rather than waiting for all of them.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.Duration;

@SpringBootApplication
@RestController
public class WebfluxApp {

  public static void main(String[] args) {
    SpringApplication.run(WebfluxApp.class, args);
  }

  record User(String id, String name) {}

  @GetMapping("/users")
  public Flux<User> getUsers() {
    return Flux.just(
      new User("1", "Alice"),
      new User("2", "Bob"),
      new User("3", "Charlie")
    )
    .delayElements(Duration.ofMillis(500)); // Simulate async delay
  }

  @GetMapping("/users/{id}")
  public Mono<User> getUserById(String id) {
    return Mono.just(new User(id, "User " + id))
               .delayElement(Duration.ofSeconds(1));
  }
}

Graceful Error Handling

Reactive streams can fail. WebFlux provides operators like onErrorResume() or onErrorReturn() to handle errors gracefully, allowing you to provide a fallback value or another reactive sequence.

Without error handling, a failed stream would propagate the error to the subscriber, potentially causing an application crash or an undesirable HTTP 500 status.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;

@SpringBootApplication
@RestController
public class WebfluxApp {

  public static void main(String[] args) {
    SpringApplication.run(WebfluxApp.class, args);
  }

  @GetMapping("/fail")
  public Mono<String> failingEndpoint() {
    return Mono.error(new RuntimeException("Something went wrong!"))
               .onErrorResume(e -> {
                   System.err.println("Error: " + e.getMessage());
                   return Mono.just("Fallback Message");
               });
  }
}

Why WebFlux Boosts Scalability

By adopting WebFlux, your applications can achieve higher throughput and better resource utilization, especially for I/O-bound tasks. This is because:

Fewer Threads: A small number of threads can manage a large number of concurrent connections.
Non-Blocking: Threads are not idly waiting; they handle other requests while I/O operations complete.
Efficient Resource Use: Leads to lower memory footprint and CPU usage under high load.

This makes WebFlux ideal for microservices that frequently interact with external systems.

Quick Check on Reactive Types

Consider the core reactive types we just learned.

Recap: Embracing Reactive with WebFlux

Great job! You've taken your first steps into asynchronous programming with Spring WebFlux.

We learned how blocking I/O limits scalability.
Spring WebFlux provides a non-blocking, reactive alternative.
Mono handles 0-1 items, and Flux handles 0-N items.
These publishers enable more efficient resource usage and higher concurrency.

Next, explore how to integrate WebFlux with reactive data repositories for end-to-end non-blocking applications!

Sıkça Sorulan Sorular

“WebFlux ile Eş Zamansız İşleme” dersi ücretsiz mi?

Evet — “WebFlux ile Eş Zamansız İşleme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Spring Boot 4 Microservices & REST APIs kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Spring Boot 4 Microservices & REST APIs kursu toplamda 9 dersten oluşur.

“WebFlux ile Eş Zamansız İşleme” dersinde ne öğreneceğim?

Yüksek eşzamanlılığa ve ölçeklenebilirliğe sahip API'ler oluşturmak için Spring WebFlux ile tepkisel programlama uygulayın. Spring Boot 4 Microservices & REST APIs ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Spring Boot 4 Microservices & REST APIs öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Spring Boot 4 Microservices & REST APIs, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 9 dersinin 2. dersidir.

“WebFlux ile Eş Zamansız İşleme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Spring Boot 4 Microservices & REST APIs dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Spring Boot 4 Microservices & REST APIs dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Spring Boot 4 Microservices & REST APIs Sayfasına Dön