Spring Boot 4-mikrotjänster och REST API:er · Lektion

Asynkron bearbetning med WebFlux

Implementera reaktiv programmering med Spring WebFlux för att bygga mycket samtidiga och skalbara API:er.

Lektion 2 av 911 steg

Asynkron bearbetning med WebFlux är en gratis lektion i Spring Boot 4-mikrotjänster och REST API:er på CoddyKit. Detta är lektion 2 av 9. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Spring Boot 4-mikrotjänster och REST API:er, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Spring Boot 4-mikrotjänster och REST API:er innehåller totalt 9 lektioner.

Varför reaktivt? Problemet med blockering

I traditionella applikationer blockerar koden ofta den aktuella tråden när den behöver vänta på något, till exempel en databasfråga eller ett anrop till ett externt API.

Det innebär att tråden inte kan göra något annat förrän operationen är klar. För många samtidiga användare kan detta leda till:

Hög resursförbrukning, med många trådar.
Längre svarstider under hög belastning.
Begränsad skalbarhet.

Introduktion till Spring WebFlux

Spring WebFlux är Springs reaktiva webbramverk, byggt på Project Reactor. Det gör det möjligt att bygga asynkrona, icke-blockerande applikationer.

Till skillnad från Spring MVC, som använder en modell med en tråd per begäran, använder WebFlux en händelseslingemodell. Det innebär att ett fåtal trådar effektivt kan hantera många samtidiga begäranden, vilket gör ditt API mer skalbart.

Kärnkoncept: Mono och Flux

Två publishers från Project Reactor står i centrum för reaktiv programmering i Spring WebFlux:

Mono: Representerar en ström som skickar ut 0 eller 1 objekt och sedan slutförs, eller ger ett fel. Se den som ett valfritt framtida värde.
Flux: Representerar en ström som skickar ut 0 till N objekt och sedan slutförs, eller ger ett fel. Den används för samlingar eller kontinuerliga dataströmmar.

De gör ingenting förrän någon prenumererar på dem!

Din första reaktiva slutpunkt

Vi skapar en enkel WebFlux-controller. Observera att vi returnerar en Mono<String> i stället för en vanlig String. Det talar om för Spring WebFlux att hantera svaret reaktivt.

Prova att köra det här exemplet och öppna /hello i webbläsaren.

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

Transformera data med "map"

Mono och Flux tillhandahåller operatorer för att transformera data. Operatorn map() tillämpar en synkron funktion på varje emitterat objekt.

Här transformerar vi strängen "hello" till versaler. De ursprungliga data ändras inte, utan ett nytt transformerat värde emitteras.

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

Arbeta med samlingar med Flux

När ni behöver returnera en ström med flera objekt är Flux er självklara publisher. Den kan emittera noll, ett eller många objekt över tid.

Här är ett exempel som returnerar en Flux<String> med frukter. När webbläsaren hämtar den får den objekten som en JSON-array eller som en ström, beroende på 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");
  }
}

Praktiskt exempel: Reaktiv användartjänst

Nu kombinerar vi det vi har lärt oss. Föreställ er en enkel User-dataklass. Vi kan skapa en tjänst som returnerar en Flux<User> och simulerar hämtning av användare från en databas med en liten fördröjning för att demonstrera asynkronitet.

Den här endpointen strömmar användare allt eftersom de blir tillgängliga, i stället för att vänta på alla användare.

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 felhantering

Reaktiva strömmar kan misslyckas. WebFlux tillhandahåller operatorer som onErrorResume() och onErrorReturn() för att hantera fel på ett elegant sätt, så att ni kan ange ett reservvärde eller en annan reaktiv sekvens.

Utan felhantering skulle en misslyckad ström vidarebefordra felet till prenumeranten, vilket kan leda till att programmet kraschar eller till en oönskad 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");
               });
  }
}

Varför WebFlux förbättrar skalbarheten

Genom att använda WebFlux kan era applikationer uppnå högre genomströmning och bättre resursutnyttjande, särskilt för I/O-bundna uppgifter. Det beror på följande:

Färre trådar: Ett litet antal trådar kan hantera ett stort antal samtidiga anslutningar.
Icke-blockerande: Trådar väntar inte sysslolösa, utan hanterar andra förfrågningar medan I/O-operationer slutförs.
Effektiv resursanvändning: Leder till mindre minnesanvändning och lägre processorbelastning vid hög belastning.

Det gör WebFlux idealiskt för mikrotjänster som ofta kommunicerar med externa system.

Snabb kontroll av reaktiva typer

Fundera på de centrala reaktiva typer som vi just har lärt oss.

Besvara frågan i den interaktiva lektionen

Sammanfattning: Använd reaktiv programmering med WebFlux

Bra jobbat! Ni har tagit era första steg inom asynkron programmering med Spring WebFlux.

Vi lärde oss hur blockerande I/O begränsar skalbarheten.
Spring WebFlux tillhandahåller ett icke-blockerande, reaktivt alternativ.
Mono hanterar 0–1 objekt och Flux hanterar 0–N objekt.
Dessa publishers möjliggör effektivare resursanvändning och högre samtidighet.

Utforska härnäst hur ni integrerar WebFlux med reaktiva data repositories för helt igenom icke-blockerande applikationer!

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 24
Lektioner: 93

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Asynkron bearbetning med WebFlux” gratis?

Ja – hela texten till ”Asynkron bearbetning med WebFlux” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Spring Boot 4-mikrotjänster och REST API:er, kan Ni uppgradera till CoddyKit PRO. Kursen i Spring Boot 4-mikrotjänster och REST API:er innehåller totalt 9 lektioner.

Vad lär jag mig i ”Asynkron bearbetning med WebFlux”?

Implementera reaktiv programmering med Spring WebFlux för att bygga mycket samtidiga och skalbara API:er. Ni övar på Spring Boot 4-mikrotjänster och REST API:er med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Spring Boot 4-mikrotjänster och REST API:er?

Du behöver inga förkunskaper. Utbildningen i Spring Boot 4-mikrotjänster och REST API:er på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 9.

Hur lång tid tar lektionen ”Asynkron bearbetning med WebFlux”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Spring Boot 4-mikrotjänster och REST API:er-lektionen?

Ja. Varje Spring Boot 4-mikrotjänster och REST API:er-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Spring Boot 4-mikrotjänster och REST API:er