Spring Boot 4-mikrotjenester og REST-API'er · Lektion

Asynkron behandling med WebFlux

Implementér reaktiv programmering med Spring WebFlux for at bygge API'er med høj samtidighed og skalerbarhed.

Lektion 2 af 911 trin

Asynkron behandling med WebFlux er en gratis Spring Boot 4-mikrotjenester og REST-API'er-lektion på CoddyKit. Dette er lektion 2 af 9. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Spring Boot 4-mikrotjenester og REST-API'er, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Spring Boot 4-mikrotjenester og REST-API'er-kurset indeholder 9 lektioner i alt.

Hvorfor reaktivt? Problemet med blokering

I traditionelle applikationer blokerer din kode ofte den aktuelle tråd, når den skal vente på noget (f.eks. en databaseforespørgsel eller et kald til en ekstern API).

Det betyder, at tråden ikke kan gøre noget andet, før handlingen er fuldført. For mange samtidige brugere kan det føre til:

Højt ressourceforbrug (mange tråde).
Langsommere svartider under stor belastning.
Begrænset skalerbarhed.

Introduktion til Spring WebFlux

Spring WebFlux er Springs reaktive webframework, der er bygget på Project Reactor. Det gør det muligt at bygge asynkrone, ikke-blokerende applikationer.

I modsætning til Spring MVC, der bruger en model med én tråd pr. forespørgsel, bruger WebFlux en event-loop-model. Det betyder, at få tråde effektivt kan håndtere mange samtidige forespørgsler, hvilket gør din API mere skalerbar.

Kernebegreber: Mono og Flux

I hjertet af reaktiv programmering i Spring WebFlux findes to publishers fra Project Reactor:

Mono: Repræsenterer en strøm, der udsender 0 eller 1 element og derefter afsluttes (eller giver en fejl). Tænk på den som en valgfri fremtidig værdi.
Flux: Repræsenterer en strøm, der udsender 0 til N elementer og derefter afsluttes (eller giver en fejl). Den bruges til samlinger eller kontinuerlige datastrømme.

De gør ikke noget, før nogen abonnerer på dem!

Dit første reaktive slutpunkt

Lad os oprette en grundlæggende WebFlux-controller. Bemærk, at vi returnerer en Mono<String> i stedet for en almindelig String. Det fortæller Spring WebFlux, at svaret skal håndteres reaktivt.

Prøv at køre dette eksempel, og åbn /hello i din 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!");
  }
}

Transformering af data med 'map'

Mono og Flux har operatorer til transformering af data. Operatoren map() anvender en synkron funktion på hvert udsendt element.

Her transformerer vi strengen "hello" til store bogstaver. De oprindelige data ændres ikke; der udsendes en ny transformeret værdi.

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

Arbejde med samlinger ved hjælp af Flux

Når du skal returnere en strøm med flere elementer, er Flux den oplagte udgiver. Den kan udsende nul, ét eller mange elementer over tid.

Her er et eksempel, der returnerer en Flux<String> med frugter. Når den tilgås, modtager browseren elementerne som et JSON-array eller som en strøm, afhængigt af 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 brugertjeneste

Lad os samle det, vi har lært. Forestil dig en simpel User-dataklasse. Vi kan oprette en tjeneste, der returnerer en Flux<User> og simulerer hentning af brugere fra en database med en kort forsinkelse for at demonstrere asynkronitet.

Dette slutpunkt streamer brugere, efterhånden som de bliver tilgængelige, i stedet for at vente på dem alle.

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 fejlhåndtering

Reaktive strømme kan mislykkes. WebFlux har operatorer som onErrorResume() og onErrorReturn(), der håndterer fejl på en elegant måde, så du kan angive en reserveværdi eller en anden reaktiv sekvens.

Uden fejlhåndtering ville en mislykket strøm videregive fejlen til abonnenten, hvilket potentielt kunne få programmet til at gå ned eller medføre 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 forbedrer skalerbarheden

Ved at anvende WebFlux kan dine applikationer opnå højere gennemløb og bedre ressourceudnyttelse, især ved I/O-begrænsede opgaver. Det skyldes:

Færre tråde: Et lille antal tråde kan håndtere et stort antal samtidige forbindelser.
Ikke-blokerende: Tråde venter ikke inaktive; de håndterer andre forespørgsler, mens I/O-operationer afsluttes.
Effektiv ressourceanvendelse: Det giver et lavere hukommelsesforbrug og CPU-forbrug under høj belastning.

Det gør WebFlux ideel til mikrotjenester, der ofte kommunikerer med eksterne systemer.

Hurtig kontrol af reaktive typer

Overvej de centrale reaktive typer, vi netop har lært.

Besvar den i den interaktive lektion

Opsummering: Brug reaktiv programmering med WebFlux

Godt klaret! Du har taget dine første skridt ind i asynkron programmering med Spring WebFlux.

Vi lærte, hvordan blokerende I/O begrænser skalerbarheden.
Spring WebFlux tilbyder et ikke-blokerende, reaktivt alternativ.
Mono håndterer 0-1 elementer, mens Flux håndterer 0-N elementer.
Disse udgivere muliggør mere effektiv ressourceanvendelse og højere samtidighed.

Undersøg derefter, hvordan du integrerer WebFlux med reaktive datarepositories for at skabe fuldt ud ikke-blokerende applikationer.

Gratis at komme i gang

Lær Java med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 24
Lektioner: 93

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Asynkron behandling med WebFlux” gratis?

Ja — hele teksten til “Asynkron behandling med WebFlux” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Spring Boot 4-mikrotjenester og REST-API'er-kurset, skal du opgradere til CoddyKit PRO. Spring Boot 4-mikrotjenester og REST-API'er-kurset indeholder 9 lektioner i alt.

Hvad lærer jeg i “Asynkron behandling med WebFlux”?

Implementér reaktiv programmering med Spring WebFlux for at bygge API'er med høj samtidighed og skalerbarhed. Du øver dig i Spring Boot 4-mikrotjenester og REST-API'er med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Spring Boot 4-mikrotjenester og REST-API'er?

Der kræves ingen tidligere erfaring. Spring Boot 4-mikrotjenester og REST-API'er på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 9.

Hvor lang tid tager lektionen “Asynkron behandling med WebFlux”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Spring Boot 4-mikrotjenester og REST-API'er-lektion?

Ja. Alle Spring Boot 4-mikrotjenester og REST-API'er-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Spring Boot 4-mikrotjenester og REST-API'er