Spring Boot 4-microservices en REST-API's · Les

Asynchrone verwerking met WebFlux

Implementeer reactief programmeren met Spring WebFlux om zeer concurrerende en schaalbare API's te bouwen.

Les 2 van 911 stappen

Asynchrone verwerking met WebFlux is een gratis Spring Boot 4-microservices en REST-API's-les op CoddyKit. Dit is les 2 van 9. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Spring Boot 4-microservices en REST-API's. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Spring Boot 4-microservices en REST-API's bevat in totaal 9 lessen.

Waarom reactief? Het blokkeringsprobleem

In traditionele applicaties blokkeert je code vaak de huidige thread wanneer deze moet wachten op iets, zoals een databasequery of een aanroep van een externe API.

Dit betekent dat de thread niets anders kan doen totdat de bewerking is voltooid. Bij veel gelijktijdige gebruikers kan dit leiden tot:

Hoog resourceverbruik door veel threads.
Langzamere responstijden bij zware belasting.
Beperkte schaalbaarheid.

Kennismaken met Spring WebFlux

Spring WebFlux is het reactieve webframework van Spring, gebouwd op Project Reactor. Hiermee kun je asynchrone, niet-blokkerende applicaties bouwen.

In tegenstelling tot Spring MVC, dat een model met één thread per verzoek gebruikt, gebruikt WebFlux een eventloopmodel. Daardoor kunnen enkele threads veel gelijktijdige verzoeken efficiënt afhandelen, waardoor je API beter schaalbaar is.

Kernconcepten: Mono en Flux

De kern van reactief programmeren in Spring WebFlux wordt gevormd door twee publishers van Project Reactor:

Mono: Vertegenwoordigt een stroom die 0 of 1 item uitzendt en daarna voltooit, of een fout oplevert. Zie het als een optionele toekomstige waarde.
Flux: Vertegenwoordigt een stroom die 0 tot N items uitzendt en daarna voltooit, of een fout oplevert. Dit gebruik je voor verzamelingen of continue gegevensstromen.

Ze doen niets totdat iemand zich erop abonneert!

Je eerste reactieve eindpunt

Laten we een eenvoudige WebFlux-controller maken. Let op: we retourneren een Mono<String> in plaats van een gewone String. Hiermee geven we Spring WebFlux de opdracht om de respons reactief af te handelen.

Voer dit voorbeeld uit en open /hello in je 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!");
  }
}

Gegevens transformeren met 'map'

Mono en Flux bieden operators om gegevens te transformeren. De operator map() past een synchrone functie toe op elk uitgegeven item.

Hier transformeren we de tekenreeks "hello" naar hoofdletters. De oorspronkelijke gegevens worden niet gewijzigd; er wordt een nieuwe, getransformeerde waarde uitgegeven.

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!");
  }
}

Met verzamelingen werken met Flux

Wanneer je een stroom met meerdere items wilt retourneren, is Flux de aangewezen publisher. Deze kan in de loop van de tijd nul, één of veel items uitgeven.

Hier is een voorbeeld dat een Flux<String> met fruit retourneert. Wanneer je dit opent, ontvangt de browser de items als een JSON-array of als een stroom, afhankelijk van de Accept-header van de client.

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");
  }
}

Praktijkvoorbeeld: reactieve gebruikersservice

Laten we combineren wat we hebben geleerd. Stel je een eenvoudige gegevensklasse User voor. We kunnen een service maken die een Flux<User> retourneert en het ophalen van gebruikers uit een database simuleert met een korte vertraging om asynchroniciteit te demonstreren.

Dit eindpunt streamt gebruikers zodra ze beschikbaar zijn, in plaats van te wachten tot ze allemaal beschikbaar zijn.

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));
  }
}

Foutafhandeling zonder onderbreking

Reactieve streams kunnen mislukken. WebFlux biedt operators zoals onErrorResume() en onErrorReturn() om fouten op een nette manier af te handelen, zodat je een terugvalwaarde of een andere reactieve reeks kunt aanbieden.

Zonder foutafhandeling zou een mislukte stream de fout doorgeven aan de subscriber, wat mogelijk tot een crash van de applicatie of een ongewenste HTTP-status 500 leidt.

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");
               });
  }
}

Waarom WebFlux de schaalbaarheid verbetert

Door WebFlux te gebruiken, kunnen je applicaties een hogere verwerkingscapaciteit en een beter gebruik van resources bereiken, vooral bij I/O-taken. Dat komt doordat:

Minder threads: Een klein aantal threads kan een groot aantal gelijktijdige verbindingen beheren.
Niet-blokkerend: Threads wachten niet doelloos; ze verwerken andere verzoeken terwijl I/O-bewerkingen worden voltooid.
Efficiënt resourcegebruik: Dit leidt bij hoge belasting tot een lager geheugengebruik en minder CPU-gebruik.

Daarom is WebFlux ideaal voor microservices die vaak met externe systemen communiceren.

Korte controle van reactieve typen

Denk na over de belangrijkste reactieve typen die we zojuist hebben geleerd.

Beantwoord dit in de interactieve les

Samenvatting: reactief werken met WebFlux

Goed gedaan! Je hebt je eerste stappen gezet in asynchrone programmering met Spring WebFlux.

We hebben geleerd hoe blokkerende I/O de schaalbaarheid beperkt.
Spring WebFlux biedt een niet-blokkerend, reactief alternatief.
Mono verwerkt 0-1 items en Flux verwerkt 0-N items.
Met deze publishers kun je resources efficiënter gebruiken en een hogere gelijktijdigheid bereiken.

Ontdek hierna hoe je WebFlux integreert met reactieve datarepository's voor volledig niet-blokkerende applicaties!

Gratis beginnen

Leer Java met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 24
Lessen: 93

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Asynchrone verwerking met WebFlux” gratis?

Ja — de volledige tekst van “Asynchrone verwerking met WebFlux” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Spring Boot 4-microservices en REST-API's wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Spring Boot 4-microservices en REST-API's bevat in totaal 9 lessen.

Wat leer ik in “Asynchrone verwerking met WebFlux”?

Implementeer reactief programmeren met Spring WebFlux om zeer concurrerende en schaalbare API's te bouwen. Je oefent met Spring Boot 4-microservices en REST-API's door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Spring Boot 4-microservices en REST-API's te beginnen?

Ervaring vooraf is niet nodig. Spring Boot 4-microservices en REST-API's op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 9.

Hoe lang duurt de les “Asynchrone verwerking met WebFlux”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Spring Boot 4-microservices en REST-API's?

Ja. Elke les over Spring Boot 4-microservices en REST-API's bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Spring Boot 4-microservices en REST-API's