Bygga reaktiva realtidstjänster
Utveckla reaktiva realtidstjänster från början till slut som utnyttjar kraften i Project Reactor.
Bygga reaktiva realtidstjänster är en gratis lektion i WebSockets och realtidssystem med Spring på CoddyKit. Detta är lektion 3 av 4. 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 WebSockets och realtidssystem med Spring, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i WebSockets och realtidssystem med Spring innehåller totalt 4 lektioner.
Reaktiva realtidstjänster
Välkommen! I den här lektionen bygger vi reaktiva realtidstjänster från början till slut med Spring WebFlux och Project Reactor.
Reaktiva tjänster är utmärkta för att effektivt hantera många samtidiga anslutningar. De erbjuder bättre skalbarhet och snabbare respons jämfört med traditionella blockerande lösningar.
Project Reactor: Flux och Mono
I centrum för reaktiv programmering i Spring finns Project Reactor. Det tillhandahåller två viktiga typer för hantering av dataströmmar:
Flux: Representerar en ström med 0 till N objekt. Tänk på den som en publisher som kan avge flera värden över tid.Mono: Representerar en ström med 0 till 1 objekt. Den är användbar för operationer som returnerar ett enda resultat eller inget resultat alls (somvoid).
Dessa typer gör att vi kan sätta samman asynkrona operationer på ett tydligt och icke-blockerande sätt.
WebFlux WebSocket-hanterare
Spring WebFlux använder gränssnittet WebSocketHandler för att hantera WebSocket-anslutningar. Dess huvudmetod, handle(), tar emot en WebSocketSession och returnerar en Mono.
Denna Mono visar att hanteringen är klar när den reaktiva ström som den representerar avslutas. Vi kan använda Flux inuti den för att skicka kontinuerliga meddelanden.
Utforma en reaktiv datakälla
För att bygga en realtidstjänst behöver vi en datakälla. Vi ska skapa en enkel Flux som avger ett meddelande med jämna mellanrum. Det simulerar ett realtidsdataflöde, till exempel en aktiekurs eller en sensoravläsning.
Vi använder Flux.interval() för att generera händelser och map() för att omvandla dem till användbara meddelanden.
Implementera en ticker-tjänst
Här är en grundläggande WebSocketHandler som skickar ett "tick"-meddelande varje sekund. Den använder Flux.interval() som vi gick igenom tidigare.
Metoden session.send() tar emot en Flux för att skicka data till klienten.
import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.WebSocketMessage;
import org.springframework.web.reactive.socket.WebSocketSession;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.Duration;
public class TimeTickerHandler implements WebSocketHandler {
@Override
public Mono<Void> handle(WebSocketSession session) {
// Send messages to the client
Flux<WebSocketMessage> output = Flux.interval(Duration.ofSeconds(1))
.map(i -> session.textMessage("Tick #" + i));
// Receive messages from the client (and ignore them for now)
// We use .then() to ensure the Mono<Void> completes only when the session closes.
Mono<Void> input = session.receive().then();
return session.send(output).and(input);
}
}
Fullständig körbar ticker-tjänst
För att göra vår TimeTickerHandler körbar behöver vi en Spring Boot-applikation. Det här exemplet konfigurerar WebFlux-servern och registrerar vår hanterare.
Öppna ws://localhost:8080/ticker i en WebSocket-klient (som Postman eller webbläsarens DevTools-konsol) för att se den i praktiken.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.reactive.handler.SimpleUrlHandlerMapping;
import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.WebSocketMessage;
import org.springframework.web.reactive.socket.WebSocketSession;
import org.springframework.web.reactive.socket.server.support.WebSocketHandlerAdapter;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
@SpringBootApplication
public class ReactiveTickerApplication {
public static void main(String[] args) {
SpringApplication.run(ReactiveTickerApplication.class, args);
}
@Bean
public SimpleUrlHandlerMapping webSocketHandlerMapping(WebSocketHandler webSocketHandler) {
Map<String, WebSocketHandler> map = new HashMap<>();
map.put("/ticker", webSocketHandler);
return new SimpleUrlHandlerMapping(map, 1);
}
@Bean
public WebSocketHandler webSocketHandler() {
return new WebSocketHandler() {
@Override
public Mono<Void> handle(WebSocketSession session) {
// Send a 'tick' message every second
Flux<WebSocketMessage> output = Flux.interval(Duration.ofSeconds(1))
.map(i -> session.textMessage("Tick #" + i + " at " + System.currentTimeMillis()));
// Handle incoming messages (e.g., echo them back, or process commands)
// For this example, we'll just log and then complete the input stream
Mono<Void> input = session.receive()
.doOnNext(msg -> System.out.println("Received: " + msg.getPayloadAsText()))
.then(); // ensures the Mono completes after processing all incoming
return session.send(output).and(input);
}
};
}
@Bean
public WebSocketHandlerAdapter handlerAdapter() {
return new WebSocketHandlerAdapter();
}
}
Hantera klientindata
Vår tidigare ticker skickade bara data. För att göra den verkligt interaktiv kan vi även behandla meddelanden som kommer från klienten.
Metoden session.receive() returnerar en Flux som representerar inkommande meddelanden. Du kan prenumerera på denna Flux för att reagera på klientindata, till exempel genom att filtrera, transformera eller använda data för att styra utdataflödet.
Felhantering i reaktiva strömmar
Fel kan uppstå i alla delar av en reaktiv pipeline. Project Reactor tillhandahåller operatorer för att hantera dem på ett smidigt sätt och förhindra att applikationen kraschar:
onErrorResume(): Återhämtar sig från ett fel genom att byta till en alternativ publisher.doOnError(): Utför en sidoeffekt (som loggning) när ett fel inträffar och kastar sedan felet vidare eller slutför flödet.retry(): Försöker köra sekvensen igen om ett fel inträffar.
Med dessa operatorer kan du bygga robusta realtidstjänster som återhämtar sig från tillfälliga problem.
Hantera backpressure
Backpressure är avgörande för reaktiva system. Det är en mekanism där en konsument kan signalera till en producent att data tas emot för snabbt och att producenten behöver sakta ner.
Project Reactor hanterar backpressure automatiskt. När en klient inte hinner med kan WebSocket-anslutningen buffra meddelanden eller till slut stängas, men serverns Flux överbelastar varken sig själv eller nätverket.
Koncept för reaktiva tjänster
Vilka av följande är viktiga egenskaper när man bygger reaktiva realtidstjänster med Spring WebFlux och Project Reactor?
Sammanfattning: Reaktiv realtid
Vi har gått igenom hur man bygger reaktiva realtidstjänster med Spring WebFlux och Project Reactor.
- Vi såg hur
Fluxkan generera kontinuerliga dataströmmar. - Vi implementerade en
WebSocketHandlerför att skicka dessa strömmar till klienter. - Vi konfigurerade en grundläggande Spring Boot-applikation som är värd för vår reaktiva WebSocket-slutpunkt.
- Vi berörde felhantering och mottryck, vilket är avgörande för robusta system.
Dessa principer möjliggör mycket skalbara och responsiva realtidsapplikationer.
Lär dig WebSockets och realtidssystem med Spring 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
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Bygga reaktiva realtidstjänster” gratis?
Ja – hela texten till ”Bygga reaktiva realtidstjänster” 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 WebSockets och realtidssystem med Spring, kan Ni uppgradera till CoddyKit PRO. Kursen i WebSockets och realtidssystem med Spring innehåller totalt 4 lektioner.
Vad lär jag mig i ”Bygga reaktiva realtidstjänster”?
Utveckla reaktiva realtidstjänster från början till slut som utnyttjar kraften i Project Reactor. Ni övar på WebSockets och realtidssystem med Spring 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 WebSockets och realtidssystem med Spring?
Du behöver inga förkunskaper. Utbildningen i WebSockets och realtidssystem med Spring 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 3 av 4.
Hur lång tid tar lektionen ”Bygga reaktiva realtidstjänster”?
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 WebSockets och realtidssystem med Spring-lektionen?
Ja. Varje WebSockets och realtidssystem med Spring-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
- Introduktion till reaktiv programmering
- WebFlux WebSocket-hanterare
- Bygga reaktiva realtidstjänster
- Hantera backpressure i reaktiva strömmar