WebSockets och realtidssystem med Spring · Lektion

Arkitekturer för push av realtidsdata

Utforma arkitekturer för att skicka kontinuerliga dataströmmar och uppdateringar till anslutna klienter.

Lektion 2 av 411 steg

Arkitekturer för push av realtidsdata är en gratis lektion i WebSockets och realtidssystem med Spring på CoddyKit. Detta är lektion 2 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.

Push av realtidsdata

Moderna applikationer bygger på omedelbara uppdateringar. Föreställ er en aktiekurs, en app med sportresultat eller ett chattrum – alla behöver få data levererad när den uppstår, inte först efter en begäran.

Den här lektionen utforskar hur man utformar arkitekturer på serversidan som aktivt pushar kontinuerliga dataströmmar och uppdateringar till anslutna klienter.

Publisher-Subscriber-modellen

Grunden för push av data är mönstret Publisher-Subscriber (Pub/Sub). Så här fungerar det:

Publishers: Komponenter på serversidan som genererar och skickar meddelanden.
Subscribers: Anslutna klienter, till exempel webbläsare och mobilappar, som visar intresse för vissa typer av meddelanden.

Systemet levererar meddelanden från publishers till alla intresserade subscribers och frikopplar därmed datakällan från dess konsumenter.

Datakällor på serversidan

Varifrån kommer data som ni vill pusha? Vanliga källor är:

Databasändringar: Realtidsuppdateringar när data i databasen ändras.
Externa API:er: Händelser eller data som tas emot från tredjepartstjänster.
Interna applikationshändelser: Åtgärder i den egna applikationen, till exempel en ny lagd order eller en ändrad användarstatus.
Meddelandeköer: Data som konsumeras från system som Kafka eller RabbitMQ.

Er push-arkitektur fungerar som en brygga som hämtar data från dessa källor och skickar den till klienterna.

Exempel på en Spring-pushtjänst

Vi ska titta på en enkel Spring Boot-tjänst som simulerar generering och push av data till ett STOMP-ämne. Vi använder SimpMessagingTemplate, Springs hjälpare för att skicka meddelanden till broker-destinationer.

Prova att köra exemplet:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

// Main Spring Boot Application
@SpringBootApplication
@EnableScheduling // Enables scheduled tasks like our data push
@EnableWebSocketMessageBroker // Enables STOMP over WebSockets
public class RealTimeApp {
    public static void main(String[] args) {
        SpringApplication.run(RealTimeApp.class, args);
    }
}

// WebSocket Configuration for STOMP
@Configuration
@EnableWebSocketMessageBroker
class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        // Enable a simple in-memory broker for '/topic' and '/user' destinations
        config.enableSimpleBroker("/topic", "/user");
        // Prefix for messages from clients to server-side @MessageMapping methods
        config.setApplicationDestinationPrefixes("/app");
    }

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        // Register the '/ws' endpoint for WebSocket handshake
        registry.addEndpoint("/ws").withSockJS();
    }
}

// Service to push real-time data
@Service
class DataPushService {

    private final SimpMessagingTemplate messagingTemplate;
    private int counter = 0;

    public DataPushService(SimpMessagingTemplate messagingTemplate) {
        this.messagingTemplate = messagingTemplate;
    }

    // This method runs every 3 seconds and pushes data
    @Scheduled(fixedRate = 3000)
    public void pushTimeUpdate() {
        String message = "Current time: " + LocalDateTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")) + " (Update " + (++counter) + ")";
        // Push to a public topic. Clients can subscribe to '/topic/updates'.
        messagingTemplate.convertAndSend("/topic/updates", message);
        System.out.println("Pushed to /topic/updates: " + message);
    }
}

Utsändning av uppdateringar

Exemplet i föregående scen visar utsändning. När vår DataPushService skickar ett meddelande till /topic/updates skickas det till alla klienter som för närvarande prenumererar på det ämnet.

Detta passar utmärkt för offentliga dataflöden som chattrum, nyhetsflöden eller globala aviseringar.
Det är en effektiv fan-out-arkitektur där ett enda meddelande från servern når flera klienter samtidigt.

Riktad push: ämnen och användare

Även om ämnen passar bra för utsändning behöver ni ibland skicka meddelanden till en specifik användare eller en liten grupp. STOMP stöder två huvudtyper av destinationer för push av data:

Ämnen (till exempel /topic/news): För att sända meddelanden till alla subscribers.
Användardestinationer (till exempel /user/{userId}/queue/notifications): För att skicka privata, användarspecifika meddelanden.

Det är avgörande att förstå denna skillnad när ni utformar flexibla push-arkitekturer.

Privata användaraviseringar

För att skicka ett privat meddelande eller en avisering till en specifik användare tillhandahåller Springs SimpMessagingTemplate-klass metoden convertAndSendToUser().

Metoden dirigerar automatiskt meddelandet till de WebSocket-sessioner som är kopplade till användarens ID.

import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.stereotype.Service;

@Service
public class NotificationService {

    private final SimpMessagingTemplate messagingTemplate;

    public NotificationService(SimpMessagingTemplate messagingTemplate) {
        this.messagingTemplate = messagingTemplate;
    }

    public void sendPrivateNotification(String userId, String message) {
        // The client would subscribe to '/user/queue/notifications'
        // Spring handles the '/user/{userId}' part automatically.
        messagingTemplate.convertAndSendToUser(userId, "/queue/notifications", message);
        System.out.println("Sent private notification to " + userId + ": " + message);
    }
}

Integration med externa händelser

I komplexa, högvolymbaserade eller distribuerade system kan datakällorna vara externa meddelandebrokers som Apache Kafka eller RabbitMQ.

Er push-arkitektur skulle då omfatta:

En Spring-komponent som fungerar som consumer och lyssnar efter meddelanden från den externa brokern.
När komponenten tar emot ett meddelande använder den sedan SimpMessagingTemplate för att pusha data via WebSockets till relevanta klienter.

Detta mönster ger lös koppling och skalbarhet.

Skalning av push-arkitekturer

När applikationen växer behöver ni skala systemet för push av data:

Horisontell skalning: Kör flera instanser av WebSocket-servern.
Externa meddelandebrokers: Avgörande för kommunikation mellan servrar vid horisontell skalning. De ser till att meddelanden når alla relevanta klienter, oavsett vilken serverinstans de är anslutna till.
Lastbalanserare: Fördelar klientanslutningar mellan serverinstanserna. Sticky sessions kan behövas i enkla konfigurationer, medan mer avancerad sessionshantering kan krävas i komplexa lösningar.

Arkitekturquiz

Ni bygger en realtidsapplikation. Användarna behöver få uppdateringar om sina egna specifika beställningar och samtidigt se ett offentligt flöde med nyligen lagda beställningar från alla användare. Vilken arkitekturmetod passar bäst för respektive scenario?

Besvara frågan i den interaktiva lektionen

Sammanfattning: bemästra push av data

Ni har nu gått igenom de viktigaste koncepten bakom arkitekturer för push av realtidsdata:

Modellen Publisher-Subscriber som grund.
Identifiering av olika datakällor på serversidan.
Implementering av utsändning via ämnen och privata aviseringar via användardestinationer i Spring.
Förståelse för rollen hos externa händelsekällor och strategier för att skala push-systemet.

Med denna kunskap kan ni utforma robust och effektiv leverans av realtidsdata för alla applikationer!

Gratis att börja

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

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Arkitekturer för push av realtidsdata” gratis?

Ja – hela texten till ”Arkitekturer för push av realtidsdata” 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 ”Arkitekturer för push av realtidsdata”?

Utforma arkitekturer för att skicka kontinuerliga dataströmmar och uppdateringar till anslutna klienter. 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 2 av 4.

Hur lång tid tar lektionen ”Arkitekturer för push av realtidsdata”?

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

Server-Sent Events (SSE) jämfört med WebSockets
Arkitekturer för push av realtidsdata
Implementera användaraviseringar
Spåra närvaro och onlinestatus

← Tillbaka till WebSockets och realtidssystem med Spring