WebSockets og sanntidssystemer med Spring · leksjon

Introduksjon til reaktiv programmering

Forstå prinsippene for reaktiv programmering og fordelene ved den for samtidige applikasjoner.

Leksjon 1 av 411 trinn

Introduksjon til reaktiv programmering er en gratis leksjon i WebSockets og sanntidssystemer med Spring på CoddyKit. Dette er leksjon 1 av 4. 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 WebSockets og sanntidssystemer med Spring, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i WebSockets og sanntidssystemer med Spring inneholder totalt 4 leksjoner.

Velkommen til reaktiv programmering!

Er De klar til å bygge svært responsive og robuste applikasjoner? Reaktiv programmering er et kraftig paradigme som hjelper Dem med nettopp dette!

Det handler om å håndtere datastrømmer og endringer over tid på en effektiv og ikke-blokkerende måte. Tenk på det som programmering med asynkrone datastrømmer.

Problemet med blokkering

I tradisjonell, imperativ programmering blokkerer operasjoner ofte. Det betyr at en tråd venter på at en operasjon, for eksempel lesing fra en database eller et nettverk, skal bli ferdig før den fortsetter.

Selv om dette er enkelt, kan det føre til:

Bortkastede ressurser: Tråder som blir stående inaktive.
Dårlig skalerbarhet: Flere brukere betyr flere blokkerte tråder, noe som raskt tømmer ressursene.
Redusert respons: Applikasjonen føles treg under belastning.

Definisjon av ikke-blokkerende og asynkron

Reaktiv programmering tar tak i blokkeringsproblemet:

Ikke-blokkerende: Operasjoner stanser ikke kjøringen av en tråd. I stedet starter de en handling og gir kontrollen tilbake umiddelbart.
Asynkron: Operasjoner skjer uavhengig av programmets hovedflyt. Resultatet håndteres senere, ofte ved hjelp av tilbakekallinger eller hendelseslyttere.

Dette lar én enkelt tråd håndtere mange samtidige operasjoner og forbedrer effektiviteten betydelig.

Datastrømmer i praksis

I bunn og grunn behandler reaktiv programmering alt som en datastrøm. Denne strømmen kan sende ut:

Verdier: Vanlige dataelementer.
Feil: Noe gikk galt.
Fullføringssignaler: Strømmen er ferdig.

De kan deretter «reagere» på disse utsendingene etter hvert som de oppstår, og behandle dem uten å vente på at hele strømmen skal bli tilgjengelig.

Forklaring av backpressure

Et av de viktigste konseptene i reaktiv programmering er backpressure.

Se for Dem for en rask produsent som sender data, og en langsom konsument som prøver å behandle dem. Uten backpressure ville konsumenten blitt overbelastet, noe som kan føre til:

Oppbrukt minne
Systemkrasj

Backpressure gjør det mulig for konsumenten å signalisere til produsenten: "Hei, senk farten! Jeg kan bare håndtere så mange elementer akkurat nå." Dette forhindrer overbelastning av ressurser.

Sentrale aktører: Publishers og Subscribers

Reactive Streams-spesifikasjonen definerer fire sentrale grensesnitt:

Publisher: Produserer en datastrøm.
Subscriber: Konsumerer dataene fra en Publisher.
Subscription: Representerer forholdet mellom en Publisher og en Subscriber, og gjør det mulig å sende backpressure-signaler.
Processor: Fungerer både som en Subscriber og en Publisher.

Disse grensesnittene danner grunnlaget for reaktive biblioteker som Project Reactor.

Project Reactor: Flux og Mono

Spring WebFlux, som vi skal bruke, er basert på Project Reactor. Det tilbyr to hovedtyper for reaktiv programmering:

Flux<T>: Representerer en strøm som kan sende ut 0 til N elementer (en uendelig strøm er mulig).
Mono<T>: Representerer en strøm som kan sende ut 0 eller 1 element (for eksempel ett enkelt resultat eller et tomt svar).

Dette er byggesteinene De trenger for reaktive applikasjoner.

Opprette en enkel Flux

La oss se en Flux i praksis. Vi oppretter en enkel strøm med tekststrenger og abonnerer på den. Metoden subscribe starter dataflyten.

Prøv å kjøre dette eksempelet:

import reactor.core.publisher.Flux;

public class Main {
  public static void main(String[] args) {
    Flux<String> greetingFlux = Flux.just("Hello", "Reactive", "World");

    System.out.println("Subscribing to the Flux:");
    greetingFlux.subscribe(
        item -> System.out.println("Received: " + item), // onNext
        error -> System.err.println("Error: " + error),   // onError
        () -> System.out.println("Completed!")            // onComplete
    );
  }
}

Transformasjon med operatorer

Reaktive strømmer er kraftige fordi De kan lenke sammen operatorer for å transformere og filtrere data. Operatorer som map() og filter() endrer ikke den opprinnelige strømmen; de oppretter nye strømmer.

Kjør dette eksempelet for å se hvordan data kan transformeres:

import reactor.core.publisher.Flux;

public class Main {
  public static void main(String[] args) {
    Flux<String> namesFlux = Flux.just("Alice", "bob", "Charlie");

    System.out.println("Processing names:");
    namesFlux
        .map(name -> name.toUpperCase())     // Transform each name to uppercase
        .filter(name -> name.startsWith("A")) // Filter names starting with 'A'
        .subscribe(
            item -> System.out.println("Processed: " + item),
            error -> System.err.println("Error: " + error),
            () -> System.out.println("Processing Complete!")
        );
  }
}

Rask sjekk: Grunnleggende reaktiv programmering

Hvilket av alternativene nedenfor beskriver best hovedproblemet som reaktiv programmering forsøker å løse?

Besvar den i den interaktive leksjonen

Oppsummering: Grunnlaget for moderne apper

De har nå tatt sine første steg inn i reaktiv programmering!

Vi lærte hvordan det kan bidra til å overvinne blokkerende I/O.
Vi ble kjent med konsepter som ikke-blokkerende, asynkrone strømmer og backpressure.
Vi møtte Publishers, Subscribers og Project Reactors Flux og Mono.
Vi så hvordan man oppretter enkle strømmer og bruker operatorer.

Deretter skal vi se nærmere på hvordan Spring WebFlux bruker disse prinsippene til å bygge kraftige reaktive webtjenester!

Gratis å komme i gang

Lær deg WebSockets og sanntidssystemer med Spring 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: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Introduksjon til reaktiv programmering» gratis?

Ja – hele teksten i «Introduksjon til reaktiv programmering» 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 WebSockets og sanntidssystemer med Spring-kurset, kan du oppgradere til CoddyKit PRO. Kurset i WebSockets og sanntidssystemer med Spring inneholder totalt 4 leksjoner.

Hva lærer jeg i «Introduksjon til reaktiv programmering»?

Forstå prinsippene for reaktiv programmering og fordelene ved den for samtidige applikasjoner. Du øver på WebSockets og sanntidssystemer med Spring 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 WebSockets og sanntidssystemer med Spring?

Ingen tidligere erfaring er nødvendig. WebSockets og sanntidssystemer med Spring 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 1 av 4.

Hvor lang tid tar leksjonen «Introduksjon til reaktiv programmering»?

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 WebSockets og sanntidssystemer med Spring-leksjonen?

Ja. Alle WebSockets og sanntidssystemer med Spring-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

Introduksjon til reaktiv programmering
WebFlux WebSocket-håndterere
Bygge reaktive sanntidstjenester
Håndtering av mottrykk i reaktive strømmer

← Tilbake til WebSockets og sanntidssystemer med Spring