Spring Boot 4 Microservices & REST APIs · Aula

Processamento assíncrono com WebFlux

Implemente programação reativa com o Spring WebFlux para criar APIs altamente concorrentes e escaláveis.

Processamento assíncrono com WebFlux é uma aula grátis de Spring Boot 4 Microservices & REST APIs no CoddyKit. Esta é a aula 2 de 9. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Spring Boot 4 Microservices & REST APIs, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Spring Boot 4 Microservices & REST APIs inclui 9 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

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!

Perguntas Frequentes

A aula “Processamento assíncrono com WebFlux” é grátis?

Sim — o texto completo de “Processamento assíncrono com WebFlux” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Spring Boot 4 Microservices & REST APIs, atualize para CoddyKit PRO. O curso de Spring Boot 4 Microservices & REST APIs inclui 9 aulas no total.

O que vou aprender em “Processamento assíncrono com WebFlux”?

Implemente programação reativa com o Spring WebFlux para criar APIs altamente concorrentes e escaláveis. Você pratica Spring Boot 4 Microservices & REST APIs com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Spring Boot 4 Microservices & REST APIs?

Nenhuma experiência prévia é necessária. Spring Boot 4 Microservices & REST APIs no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 9.

Quanto tempo leva a aula “Processamento assíncrono com WebFlux”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Spring Boot 4 Microservices & REST APIs?

Sim. Cada aula de Spring Boot 4 Microservices & REST APIs inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Spring Boot 4 Microservices & REST APIs