WebSockets og sanntidssystemer med Spring · leksjon

Private meldinger med STOMP

Lær å implementere direkte, private samtaler mellom to brukere ved hjelp av STOMP sine brukerdestinasjoner.

Leksjon 3 av 411 trinn

Private meldinger med STOMP er en gratis leksjon i WebSockets og sanntidssystemer med Spring på CoddyKit. Dette er leksjon 3 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.

Det viktigste om private chatter

Velkommen! I denne leksjonen skal vi lære hvordan vi bygger funksjonalitet for private meldinger inn i chatapplikasjonen vår ved hjelp av WebSockets og STOMP.

I motsetning til offentlige chatterom, der alle mottar meldingene, sendes private meldinger (for eksempel direktemeldinger eller DM-er) spesifikt fra én bruker til en annen. Dette krever en måte å rute meldinger direkte til en bestemt brukers unike sesjon på.

STOMP-brukerdestinasjoner

STOMP tilbyr et spesielt destinasjonsprefiks: /user. Når en klient abonnerer på en destinasjon som /user/queue/private-messages, oversetter STOMP-megleren (og Spring) dette automatisk til en unik, sesjonsspesifikk kø for den aktuelle autentiserte brukeren.

/user-prefiks: Angir en brukerspesifikk destinasjon.
Unik per bruker: Hver bruker får sin egen «innboks» for private meldinger.
Abstrahert ruting: De trenger ikke å kjenne den faktiske sesjons-ID-en.

Spring og brukerruter

Springs WebSocket- og STOMP-integrasjon fungerer sammen med /user-prefikset. Når De konfigurerer meldingsmegleren, angir De at Spring skal aktivere brukerdestinasjoner:

config.setUserDestinationPrefix("/user");

Denne innstillingen sørger for at meldinger adressert til /user/{username}/queue/{destination} rutes riktig av Spring til WebSocket-sesjonen(e) som er knyttet til {username}.

Serversiden: Sende private meldinger

På serveren tilbyr Spring SimpMessagingTemplate. Dette kraftige verktøyet lar Dem sende meldinger til ulike STOMP-destinasjoner, inkludert brukerspesifikke destinasjoner.

Den viktigste metoden for private meldinger er convertAndSendToUser(). Den tar tre hovedargumenter:

username: Identifikatoren til mottakerbrukeren.
destination: Den bestemte køen i brukerens private område (for eksempel /queue/private-messages).
payload: Det faktiske meldingsinnholdet.

Eksempel på sending av private meldinger fra serveren

Prøv å kjøre denne forenklede Spring Boot-applikasjonen. Den viser en kontrollermetode som sender en privat melding ved hjelp av SimpMessagingTemplate. Husk at mottakerens brukernavn i en ekte app ville kommet fra klientens meldingsdata eller en annen kontekst.

package com.coddykit;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.stereotype.Controller;
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.security.Principal;

@SpringBootApplication
@EnableWebSocketMessageBroker
public class PrivateChatApp {

    public static void main(String[] args) {
        SpringApplication.run(PrivateChatApp.class, args);
    }

    @Configuration
    static class WsConfig implements WebSocketMessageBrokerConfigurer {
        @Override
        public void configureMessageBroker(MessageBrokerRegistry cfg) {
            cfg.enableSimpleBroker("/topic", "/queue");
            cfg.setApplicationDestinationPrefixes("/app");
            cfg.setUserDestinationPrefix("/user"); // Crucial for private messages
        }
        @Override
        public void registerStompEndpoints(StompEndpointRegistry reg) {
            reg.addEndpoint("/ws").withSockJS();
        }
    }

    @Controller
    static class PrivateMsgController {
        private final SimpMessagingTemplate template;

        public PrivateMsgController(SimpMessagingTemplate t) {
            this.template = t;
        }

        @MessageMapping("/sendPrivate") // Client sends to /app/sendPrivate
        public void sendPrivateMsg(String msg, Principal p) {
            String sender = p != null ? p.getName() : "anon";
            String recipient = "targetUser"; // In real app, from msg payload

            // Send to a specific user's private queue
            template.convertAndSendToUser(
                recipient,
                "/queue/private-messages", // Client subscribes here
                "From " + sender + ": " + msg
            );
            System.out.println("Sent private msg to " + recipient + " from " + sender);
        }
    }
}

Klientens private innboks

På klientsiden må en bruker abonnere på sin egen private destinasjon for å motta meldinger. Hvis en brukers principal-navn er «alice», abonnerer brukeren på:

/user/queue/private-messages

Spring tilordner dette automatisk internt til /queue/private-messages-user{sessionId}, slik at bare «alice» mottar meldinger som sendes til henne.

Abonnement på klientsiden

Med et STOMP-klientbibliotek (som Stomp.js) er abonnementsprosessen enkel:

stompClient.subscribe('/user/queue/private-messages', function(message) {
    // Handle the private message
    console.log("Received private message: " + message.body);
});

Dette sørger for at alle meldinger som sendes til den nåværende autentiserte brukerens /queue/private-messages-destinasjon, mottas av denne klienten.

Modell for private meldinger

For en robust privat chat bør meldingsdataene inneholde strukturerte data. En typisk modell for en privat melding kan inneholde:

senderId: ID-en til brukeren som sendte meldingen.
recipientId: ID-en til brukeren meldingen er ment for.
content: Det faktiske tekst- eller datainnholdet i meldingen.
timestamp: Tidspunktet da meldingen ble sendt.

Dette gjør det mulig for klientene å vise meldinger riktig og identifisere hvem som sendte hva til hvem.

Brukeridentitet og STOMP

Hvordan vet Spring hvilken bruker som er «alice» for /user-destinasjonen? Spring baserer seg på Principal-objektet, som vanligvis fylles ut av Spring Security eller en annen autentiseringsmekanisme.

Når en WebSocket-tilkobling opprettes, knytter Spring en Principal til sesjonen. Metoden convertAndSendToUser() bruker getName() fra denne Principal-en til å identifisere målbrukeren.

Test om private meldinger

De har lært hvordan Spring og STOMP håndterer private meldinger. La oss teste forståelsen Deres av hvordan de sendes.

Besvar den i den interaktive leksjonen

Sammendrag av private chatter

Godt jobbet! De har lært det grunnleggende om å implementere private meldinger med STOMP og Spring.

/user-destinasjonsprefikset ruter meldinger til individuelle brukere.
Springs SimpMessagingTemplate.convertAndSendToUser() sender meldinger til bestemte brukerdestinasjoner.
Klienter abonnerer på /user/queue/{your-private-destination} for å motta DM-er.
Brukeridentitet (Principal) er avgjørende for riktig ruting.

Med denne kunnskapen kan De bygge avanserte, personaliserte sanntidsinteraksjoner i applikasjonene Deres!

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 «Private meldinger med STOMP» gratis?

Ja – hele teksten i «Private meldinger med STOMP» 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 «Private meldinger med STOMP»?

Lær å implementere direkte, private samtaler mellom to brukere ved hjelp av STOMP sine brukerdestinasjoner. 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 3 av 4.

Hvor lang tid tar leksjonen «Private meldinger med STOMP»?

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

Utforming av en modell for chatmeldinger
Implementering av offentlige chatterom
Private meldinger med STOMP
Skriveindikatorer og tilstedeværelse på nett

← Tilbake til WebSockets og sanntidssystemer med Spring