Grunnleggende meldingsutveksling mellom klient og server
Implementer enkel sending av meldinger fra klient til server og omvendt, og demonstrer grunnleggende interaksjon i sanntid.
Grunnleggende meldingsutveksling mellom klient og server 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.
Grunnleggende om meldinger
I tidligere leksjoner satte De opp Spring WebSocket-applikasjonen og konfigurerte endepunktene. Nå skal vi få den til å snakke!
Sanntidskommunikasjon handler om å sende meldinger frem og tilbake mellom klienter (for eksempel nettlesere) og serveren. I denne leksjonen lærer De det grunnleggende om hvordan denne samhandlingen fungerer.
Klienten sender til serveren
Den vanligste samhandlingen begynner med at en klient sender en melding til serveren. Meldingen kan være en brukerhandling, en chatmelding eller en kommando.
- Klienten oppretter en WebSocket-tilkobling.
- Deretter sender den data til en bestemt «destinasjon» på serveren.
- Spring håndterer mottaket av denne meldingen på serversiden.
Mottaker på serversiden (Spring)
Spring bruker annotasjoner for å gjøre det enkelt å håndtere innkommende meldinger. Annotasjonen @MessageMapping knytter en metode til en bestemt destinasjonssti, på samme måte som @GetMapping for HTTP.
Når en klient sender en melding til for eksempel /app/hello, blir metoden som er annotert med @MessageMapping("/hello"), kalt.
Implementere mottakeren på serveren
La oss se på en enkel metode på serversiden som mottar en melding. Legg merke til hvordan innmeldingen kan knyttes direkte til et Java-objekt (for eksempel 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;
}
}Serveren sender til klienten
Etter at serveren har behandlet en melding fra en klient, må den ofte sende et svar eller kringkaste oppdateringer til klientene. Det er slik samhandling i sanntid virkelig oppstår.
Spring tilbyr praktiske måter å sende meldinger tilbake til klientene på, ofte ved hjelp av en meldingsmegler.
Implementere senderen på serveren
Hvis De vil sende et umiddelbart svar til klienten som sendte meldingen, kan De bruke annotasjonen @SendTo. Den ruter returverdien fra @MessageMapping-metoden til et bestemt emne.
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;
}
}Sending fra klientsiden (JavaScript)
På klientsiden, vanligvis i en nettleser, bruker De JavaScript til å samhandle med WebSocket-endepunktet. Biblioteker som SockJS og STOMP.js gjør denne prosessen enklere.
- Koble til WebSocket-endepunktet.
- Send meldinger til serverens
@MessageMapping-destinasjoner. - Abonner på serverens «emne»-destinasjoner for å motta meldinger.
Enkel JavaScript-klient
Slik sender en enkel JavaScript-klient en melding. Den bruker en STOMP-klient til å koble til serveren og sende data til serverens destinasjon /app/hello.
// 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!");
});Fullstendig ekkoeksempel (server)
La oss sette alt sammen! Denne Spring Boot-serveren mottar en melding, skriver den ut og sender deretter en hilsen tilbake til et offentlig emne. De kan kjøre dette som en Spring Boot-applikasjon.
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 + "!";
}
}Kontroll av meldingsflyt
Tenk på en Spring WebSocket-applikasjon der en klient sender en melding til /app/chat, og serveren svarer på /topic/updates. Hvilke av de følgende påstandene om denne samhandlingen er riktige?
Oppsummering: Grunnleggende meldinger
Godt jobbet! De har lært det grunnleggende om meldinger mellom klient og server i Spring WebSockets:
- Klienter sender meldinger til serverdestinasjoner ved hjelp av STOMP-biblioteker på klientsiden.
- Servere mottar meldinger ved hjelp av
@MessageMapping. - Servere kan svare umiddelbart ved hjelp av
@SendTofor å kringkaste til emner.
Dette danner grunnlaget for all samhandling i sanntid. Deretter skal vi se nærmere på STOMP-protokollen for mer strukturert meldingsutveksling!
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
Ofte stilte spørsmål
Er leksjonen «Grunnleggende meldingsutveksling mellom klient og server» gratis?
Ja – hele teksten i «Grunnleggende meldingsutveksling mellom klient og server» 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 «Grunnleggende meldingsutveksling mellom klient og server»?
Implementer enkel sending av meldinger fra klient til server og omvendt, og demonstrer grunnleggende interaksjon i sanntid. 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 «Grunnleggende meldingsutveksling mellom klient og server»?
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
- Spring Boot for WebSockets
- Konfigurering av WebSocket-endepunkter
- Grunnleggende meldingsutveksling mellom klient og server
- Håndtering av WebSocket-livssyklushendelser i Spring