Spring Boot 4-mikrotjenester og REST API-er · leksjon

Asynkron behandling med WebFlux

Implementer reaktiv programmering med Spring WebFlux for å bygge svært samtidige og skalerbare API-er.

Leksjon 2 av 911 trinn

Asynkron behandling med WebFlux er en gratis leksjon i Spring Boot 4-mikrotjenester og REST API-er på CoddyKit. Dette er leksjon 2 av 9. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Spring Boot 4-mikrotjenester og REST API-er, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Spring Boot 4-mikrotjenester og REST API-er inneholder totalt 9 leksjoner.

Hvorfor reaktivt? Problemet med blokkering

I tradisjonelle applikasjoner vil koden ofte blokkere den gjeldende tråden når den må vente på noe, for eksempel et databasespørring eller et kall til et eksternt API.

Det betyr at tråden ikke kan gjøre noe annet før operasjonen er fullført. For mange samtidige brukere kan dette føre til:

Høyt ressursforbruk (mange tråder).
Tregere svartider under høy belastning.
Begrenset skalerbarhet.

Introduksjon til Spring WebFlux

Spring WebFlux er Springs reaktive web-rammeverk, bygget på Project Reactor. Det lar Dem bygge asynkrone, ikke-blokkerende applikasjoner.

I motsetning til Spring MVC, som bruker en modell med én tråd per forespørsel, bruker WebFlux en hendelsesløkke-modell. Det betyr at noen få tråder kan håndtere mange samtidige forespørsler effektivt, slik at API-et blir mer skalerbart.

Kjernebegreper: Mono og Flux

Grunnlaget for reaktiv programmering i Spring WebFlux er to publishers fra Project Reactor:

Mono: Representerer en strøm som sender ut 0 eller 1 element og deretter fullføres (eller feiler). Tenk på den som en valgfri fremtidig verdi.
Flux: Representerer en strøm som sender ut 0 til N elementer og deretter fullføres (eller feiler). Den brukes for samlinger eller kontinuerlige datastrømmer.

De gjør ingenting før noen abonnerer på dem!

Deres første reaktive endepunkt

La oss lage en enkel WebFlux-kontroller. Legg merke til at vi returnerer en Mono<String> i stedet for en vanlig String. Dette forteller Spring WebFlux at responsen skal håndteres reaktivt.

Prøv å kjøre dette eksempelet og åpne /hello i nettleseren.

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

Transformere data med «map»

Mono og Flux tilbyr operatorer for å transformere data. Operatoren map() bruker en synkron funksjon på hvert element som sendes ut.

Her transformerer vi strengen «hello» til store bokstaver. De opprinnelige dataene endres ikke; i stedet sendes en ny, transformert verdi ut.

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

Arbeide med samlinger ved hjelp av Flux

Når De trenger å returnere en strøm med flere elementer, er Flux utgiveren De bør bruke. Den kan sende ut null, ett eller mange elementer over tid.

Her er et eksempel som returnerer en Flux<String> med frukter. Når endepunktet åpnes, mottar nettleseren elementene som en JSON-tabell eller en strøm, avhengig av klientens 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");
  }
}

Praktisk eksempel: Reaktiv brukertjeneste

La oss kombinere det vi har lært. Tenk Dem en enkel User-dataklasse. Vi kan opprette en tjeneste som returnerer en Flux<User> og simulerer henting av brukere fra en database med en liten forsinkelse for å demonstrere asynkronitet.

Dette endepunktet strømmer brukerne etter hvert som de blir tilgjengelige, i stedet for å vente på alle sammen.

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

Elegant feilhåndtering

Reaktive strømmer kan mislykkes. WebFlux tilbyr operatorer som onErrorResume() eller onErrorReturn() for å håndtere feil på en elegant måte, slik at De kan angi en reserveverdi eller en annen reaktiv sekvens.

Uten feilhåndtering vil en mislykket strøm videreføre feilen til abonnenten, noe som potensielt kan føre til at applikasjonen krasjer eller returnerer en uønsket 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");
               });
  }
}

Hvorfor WebFlux gir bedre skalerbarhet

Ved å ta i bruk WebFlux kan applikasjonene Deres oppnå høyere gjennomstrømning og bedre ressursutnyttelse, spesielt ved I/O-bundne oppgaver. Dette skyldes følgende:

Færre tråder: Et lite antall tråder kan håndtere et stort antall samtidige tilkoblinger.
Ikke-blokkerende: Trådene venter ikke passivt, men håndterer andre forespørsler mens I/O-operasjoner fullføres.
Effektiv ressursbruk: Dette gir lavere minneforbruk og CPU-bruk under høy belastning.

Dette gjør WebFlux ideelt for mikrotjenester som ofte kommuniserer med eksterne systemer.

Kort kontroll av reaktive typer

Se på de sentrale reaktive typene vi nettopp har lært om.

Besvar den i den interaktive leksjonen

Oppsummering: Ta i bruk reaktiv programmering med WebFlux

Godt jobbet! De har tatt de første stegene inn i asynkron programmering med Spring WebFlux.

Vi lærte hvordan blokkerende I/O begrenser skalerbarheten.
Spring WebFlux tilbyr et ikke-blokkerende, reaktivt alternativ.
Mono håndterer 0–1 elementer, mens Flux håndterer 0–N elementer.
Disse utgiverne muliggjør mer effektiv ressursbruk og høyere samtidighet.

Deretter kan De utforske hvordan WebFlux integreres med reaktive datarepositorier for ende-til-ende ikke-blokkerende applikasjoner!

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 24
Leksjoner: 93

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Asynkron behandling med WebFlux» gratis?

Ja – hele teksten i «Asynkron behandling med WebFlux» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Spring Boot 4-mikrotjenester og REST API-er-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Spring Boot 4-mikrotjenester og REST API-er inneholder totalt 9 leksjoner.

Hva lærer jeg i «Asynkron behandling med WebFlux»?

Implementer reaktiv programmering med Spring WebFlux for å bygge svært samtidige og skalerbare API-er. Du øver på Spring Boot 4-mikrotjenester og REST API-er med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Spring Boot 4-mikrotjenester og REST API-er?

Ingen tidligere erfaring er nødvendig. Spring Boot 4-mikrotjenester og REST API-er på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 9.

Hvor lang tid tar leksjonen «Asynkron behandling med WebFlux»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Spring Boot 4-mikrotjenester og REST API-er-leksjonen?

Ja. Alle Spring Boot 4-mikrotjenester og REST API-er-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Spring Boot 4-mikrotjenester og REST API-er