Grundläggande klient-server-meddelanden
Implementera enkel meddelandeöverföring från klient till server och vice versa för att demonstrera grundläggande interaktion i realtid.
Grundläggande klient-server-meddelanden ä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.
Grunderna i meddelandehantering
I tidigare lektioner konfigurerade du din Spring WebSocket-applikation och dess slutpunkter. Nu ska vi få den att kommunicera!
Realtidskommunikation handlar om att skicka meddelanden fram och tillbaka mellan klienter (till exempel webbläsare) och servern. I den här lektionen får du lära dig grunderna i hur detta samspel fungerar.
Klienten skickar till servern
Det vanligaste samspelet börjar med att en klient skickar ett meddelande till servern. Meddelandet kan vara en användaråtgärd, ett chattmeddelande eller ett kommando.
- Klienten upprättar en WebSocket-anslutning.
- Därefter skickar den data till en specifik "destination" på servern.
- Spring hanterar mottagandet av meddelandet på serversidan.
Mottagare på serversidan (Spring)
Spring använder annoteringar för att förenkla hanteringen av inkommande meddelanden. Annoteringen @MessageMapping mappar en metod till en specifik destinationssökväg, på ungefär samma sätt som @GetMapping gör för HTTP.
När en klient skickar ett meddelande till exempelvis /app/hello anropas metoden som har annoteringen @MessageMapping("/hello").
Implementera mottagaren på serversidan
Vi tittar på en enkel metod på serversidan som tar emot ett meddelande. Lägg märke till hur det inkommande meddelandet direkt kan mappas till ett Java-objekt (till exempel en String).
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.stereotype.Controller;
@Controller
public class GreetingController {
@MessageMapping("/hello")
public String handleHello(String message) {
System.out.println("Received from client: " + message);
return "Server received: " + message;
}
}Servern skickar till klienten
När servern har bearbetat klientens meddelande behöver den ofta skicka ett svar eller sända uppdateringar till klienterna. Det är så interaktion i realtid verkligen fungerar.
Spring erbjuder smidiga sätt att skicka meddelanden tillbaka till klienterna, ofta med hjälp av en meddelandeförmedlare.
Implementera sändaren på serversidan
Om du vill skicka ett omedelbart svar till klienten som skickade meddelandet kan du använda annoteringen @SendTo. Den dirigerar returvärdet från din @MessageMapping-metod till ett specifikt ämne.
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;
@Controller
public class GreetingController {
@MessageMapping("/hello")
@SendTo("/topic/greetings")
public String handleHello(String message) {
System.out.println("Received: " + message);
return "Hello from Server: " + message;
}
}Skicka från klientsidan (JavaScript)
På klientsidan, vanligtvis i en webbläsare, använder du JavaScript för att kommunicera med WebSocket-slutpunkten. Bibliotek som SockJS och STOMP.js förenklar processen.
- Anslut till WebSocket-slutpunkten.
- Skicka meddelanden till serverns
@MessageMapping-destinationer. - Prenumerera på serverns "topic"-destinationer för att ta emot meddelanden.
Enkel JavaScript-klient
Så här skickar en grundläggande JavaScript-klient ett meddelande. Den använder en STOMP-klient för att ansluta och skicka data till serverns /app/hello-destination.
// This assumes SockJS and STOMP.js are loaded
var socket = new SockJS('/ws'); // Your WebSocket endpoint
var stompClient = Stomp.over(socket);
stompClient.connect({}, function (frame) {
console.log('Connected: ' + frame);
// Subscribe to a topic to receive messages
stompClient.subscribe('/topic/greetings', function (greeting) {
console.log("Received from server: " + greeting.body);
});
// Send a message to the server
stompClient.send("/app/hello", {}, "Hello Spring!");
});Fullständigt ekoexempel (server)
Nu sätter vi ihop allt! Den här Spring Boot-servern tar emot ett meddelande, skriver ut det och skickar sedan tillbaka en hälsning till ett offentligt ämne. Du kan köra detta som en Spring Boot-applikation.
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.handler.annotation.SendTo;
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;
@SpringBootApplication
public class WebSocketServerApp {
public static void main(String[] args) {
SpringApplication.run(WebSocketServerApp.class, args);
}
}
@Configuration
@EnableWebSocketMessageBroker
class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/ws").withSockJS(); // WebSocket endpoint
}
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
config.enableSimpleBroker("/topic"); // Enable a simple broker for /topic destinations
config.setApplicationDestinationPrefixes("/app"); // Client messages for @MessageMapping
}
}
@Controller
class GreetingController {
@MessageMapping("/hello") // Client sends to /app/hello
@SendTo("/topic/greetings") // Server sends response to /topic/greetings
public String greet(String message) throws Exception {
Thread.sleep(1000); // Simulate processing delay
System.out.println("Server received: " + message);
return "Server says: " + message + "!";
}
}Kontrollera meddelandeflödet
Föreställ dig en Spring WebSocket-applikation där en klient skickar ett meddelande till /app/chat och servern svarar till /topic/updates. Vilka av följande påståenden om detta samspel är sanna?
Sammanfattning: Grundläggande meddelandehantering
Bra jobbat! Du har lärt dig grunderna i meddelandekommunikation mellan klient och server i Spring WebSockets:
- Klienter skickar meddelanden till serverdestinationer med hjälp av STOMP-bibliotek på klientsidan.
- Servrar tar emot meddelanden med
@MessageMapping. - Servrar kan svara omedelbart med
@SendToför att sända meddelanden till ämnen.
Detta utgör grunden för all interaktion i realtid. Härnäst går vi djupare in på STOMP-protokollet för mer strukturerad meddelandehantering!
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 ”Grundläggande klient-server-meddelanden” gratis?
Ja – hela texten till ”Grundläggande klient-server-meddelanden” 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 ”Grundläggande klient-server-meddelanden”?
Implementera enkel meddelandeöverföring från klient till server och vice versa för att demonstrera grundläggande interaktion i realtid. 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 ”Grundläggande klient-server-meddelanden”?
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
- Spring Boot för WebSockets
- Konfiguration av WebSocket-endpoints
- Grundläggande klient-server-meddelanden
- Hantera WebSocket-livscykelhändelser i Spring