WebSockets en realtime systemen met Spring · Les

Architecturen voor realtime datapush

Ontwerp architecturen voor het naar verbonden clients pushen van doorlopende gegevensstromen en updates.

Les 2 van 411 stappen

Architecturen voor realtime datapush is een gratis WebSockets en realtime systemen met Spring-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject WebSockets en realtime systemen met Spring. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus WebSockets en realtime systemen met Spring bevat in totaal 4 lessen.

Realtime gegevens pushen

Moderne applicaties zijn afhankelijk van directe updates. Denk aan een koerstikker, een app met sportuitslagen of een chatruimte: al deze toepassingen hebben gegevens nodig zodra die beschikbaar zijn, niet pas na een aanvraag.

In deze les leer je hoe je serverarchitecturen ontwerpt die actief continue gegevensstromen en updates naar verbonden clients pushen.

Publisher-subscriber-model

De kern van het pushen van gegevens is het patroon Publisher-Subscriber (Pub/Sub). Zo werkt het:

Publishers: serveronderdelen die berichten genereren en verzenden.
Subscribers: verbonden clients, zoals webbrowsers en mobiele apps, die belangstelling tonen voor specifieke berichttypen.

Het systeem levert berichten van publishers aan alle geïnteresseerde subscribers en koppelt de gegevensbron los van de afnemers ervan.

Gegevensbronnen aan de serverkant

Waar komen de gegevens vandaan die je wilt pushen? Veelvoorkomende bronnen zijn:

Wijzigingen in databases: realtime-updates wanneer gegevens in je database worden gewijzigd.
Externe API's: gebeurtenissen of gegevens die van diensten van derden worden ontvangen.
Interne applicatiegebeurtenissen: acties binnen je eigen applicatie, zoals het plaatsen van een nieuwe bestelling of het wijzigen van de status van een gebruiker.
Berichtenwachtrijen: gegevens die worden verwerkt uit systemen zoals Kafka of RabbitMQ.

Je pusharchitectuur fungeert als een brug: deze haalt gegevens uit deze bronnen en stuurt ze naar clients.

Voorbeeld van een Spring-pushservice

Bekijk een eenvoudige Spring Boot-service die het genereren en pushen van gegevens naar een STOMP-onderwerp simuleert. We gebruiken SimpMessagingTemplate, de helper van Spring voor het verzenden van berichten naar brokerbestemmingen.

Probeer dit voorbeeld uit te voeren:

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

Updates uitzenden

Het voorbeeld uit de vorige scène demonstreert uitzending. Wanneer onze DataPushService een bericht naar /topic/updates stuurt, wordt het naar alle clients gepusht die momenteel op dat onderwerp zijn geabonneerd.

Dit is ideaal voor openbare gegevensstromen zoals chatruimtes, nieuwsfeeds of algemene meldingen.
Dit is een efficiënte fan-out-architectuur, waarbij één bericht van de server meerdere clients tegelijk bereikt.

Gerichte push: onderwerpen en gebruikers

Onderwerpen zijn geweldig voor uitzendingen, maar soms moet je berichten naar een specifieke gebruiker of een kleine groep sturen. STOMP ondersteunt twee belangrijke typen bestemmingen voor het pushen van gegevens:

Onderwerpen (bijvoorbeeld /topic/news): om berichten naar alle subscribers uit te zenden.
Gebruikersbestemmingen (bijvoorbeeld /user/{userId}/queue/notifications): om privéberichten te verzenden die voor een specifieke gebruiker bedoeld zijn.

Dit onderscheid begrijpen is cruciaal voor het ontwerpen van flexibele pusharchitecturen.

Privémeldingen voor gebruikers

Om een privébericht of een melding naar een specifieke gebruiker te sturen, biedt Spring's SimpMessagingTemplate de methode convertAndSendToUser().

Deze methode routeert het bericht automatisch naar de juiste WebSocketsessie(s) die aan die gebruikers-ID zijn gekoppeld.

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

Integratie van externe gebeurtenissen

Voor complexe, omvangrijke of gedistribueerde systemen kunnen je gegevensbronnen externe berichtenbrokers zijn, zoals Apache Kafka of RabbitMQ.

Je pusharchitectuur zou het volgende omvatten:

Een Spring-component die als consumer fungeert en luistert naar berichten van de externe broker.
Na ontvangst van een bericht gebruikt dit component SimpMessagingTemplate om de gegevens via WebSockets naar relevante clients te pushen.

Dit patroon zorgt voor losse koppeling en schaalbaarheid.

Pusharchitecturen schalen

Naarmate je applicatie groeit, moet je je systeem voor het pushen van gegevens schalen:

Horizontaal schalen: voer meerdere instanties van je WebSocket-server uit.
Externe berichtenbrokers: essentieel voor communicatie tussen servers wanneer je horizontaal schaalt. Ze zorgen ervoor dat berichten alle relevante clients bereiken, ongeacht met welke serverinstantie ze verbonden zijn.
Load balancers: verdelen clientverbindingen over je serverinstanties. Voor eenvoudige opstellingen zijn sticky sessions mogelijk nodig; voor complexe opstellingen is geavanceerder sessiebeheer vereist.

Architectuurquiz

Je bouwt een realtime-applicatie. Gebruikers moeten updates over hun eigen specifieke bestellingen ontvangen en tegelijkertijd een openbare feed zien met recent geplaatste bestellingen van iedereen. Welke architectuuraanpak is het meest geschikt voor elk scenario?

Beantwoord dit in de interactieve les

Samenvatting: gegevens pushen beheersen

Je hebt nu de essentiële concepten achter architecturen voor het pushen van realtimegegevens onderzocht:

Het Publisher-Subscriber-model als basis.
Het identificeren van verschillende gegevensbronnen aan de serverkant.
Het implementeren van uitzendingen via onderwerpen en privémeldingen via gebruikersbestemmingen in Spring.
Het begrijpen van de rol van externe gebeurtenisbronnen en strategieën voor het schalen van je pushsysteem.

Met deze kennis kun je robuuste en efficiënte realtimegegevenslevering voor elke applicatie ontwerpen!

Gratis beginnen

Leer WebSockets en realtime systemen met Spring met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Architecturen voor realtime datapush” gratis?

Ja — de volledige tekst van “Architecturen voor realtime datapush” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus WebSockets en realtime systemen met Spring wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus WebSockets en realtime systemen met Spring bevat in totaal 4 lessen.

Wat leer ik in “Architecturen voor realtime datapush”?

Ontwerp architecturen voor het naar verbonden clients pushen van doorlopende gegevensstromen en updates. Je oefent met WebSockets en realtime systemen met Spring door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met WebSockets en realtime systemen met Spring te beginnen?

Ervaring vooraf is niet nodig. WebSockets en realtime systemen met Spring op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Architecturen voor realtime datapush”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over WebSockets en realtime systemen met Spring?

Ja. Elke les over WebSockets en realtime systemen met Spring bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Server-Sent Events (SSE) versus WebSockets
Architecturen voor realtime datapush
Gebruikersmeldingen implementeren
Presence en onlinestatus bijhouden

← Terug naar WebSockets en realtime systemen met Spring