GraphQL-API:er med Spring Boot · Lektion

Integrera WebSockets med Spring

Konfigurera WebSocket-stöd i er Spring Boot-applikation för att möjliggöra bestående klient-serveranslutningar för prenumerationer.

Lektion 3 av 411 steg

Integrera WebSockets med Spring är en gratis lektion i GraphQL-API:er med Spring Boot 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 GraphQL-API:er med Spring Boot, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i GraphQL-API:er med Spring Boot innehåller totalt 4 lektioner.

WebSockets för data i realtid

Välkommen! I den här lektionen integrerar vi WebSockets med Spring Boot. Det är avgörande för att aktivera realtidsfunktioner som GraphQL-prenumerationer.

WebSockets tillhandahåller en beständig, tvåvägskommunikationskanal mellan en klient och en server över en enda långlivad TCP-anslutning.

Varför WebSockets för prenumerationer?

Till skillnad från traditionella HTTP-begäranden, som är kortvariga, kräver GraphQL-prenumerationer en kontinuerlig anslutning för att skicka datauppdateringar till klienterna när de inträffar.

WebSockets passar perfekt eftersom de upprätthåller en öppen anslutning, så att servern kan skicka data till klienten när som helst utan en ny begäran.

Lägga till beroendet

Först måste vi lägga till Spring Boot WebSocket-starterberoendet i projektet. Det tar med alla bibliotek som behövs för att aktivera WebSocket-stöd.

För Gradle lägger du till detta i din build.gradle:

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-websocket'
}

Aktivera WebSocket-meddelandebroker

I Spring använder vi annoteringar för att aktivera specifika funktioner. För WebSockets med en meddelandebroker använder vi @EnableWebSocketMessageBroker.

Den här annoteringen aktiverar en STOMP-meddelandebroker över WebSocket, vilket är ett kraftfullt sätt att hantera meddelanden.

Konfigurera WebSocket-slutpunkter

Vi behöver en konfigurationsklass som utökar WebSocketMessageBrokerConfigurer. Den här klassen gör det möjligt för oss att anpassa vår WebSocket-konfiguration.

Metoden registerStompEndpoints() används för att definiera den URL-slutpunkt som klienterna ansluter till för WebSocket-kommunikation.

Lägga till SockJS-reservlösning

När vi registrerar en slutpunkt lägger vi ofta till .withSockJS(). SockJS är ett JavaScript-bibliotek som tillhandahåller ett WebSocket-liknande API.

Det erbjuder reservlösningar, till exempel HTTP-strömning eller lång polling, för webbläsare som inte har fullständigt stöd för WebSockets eller i miljöer med proxyservrar som stör.

Konfigurera meddelandebrokern

Metoden configureMessageBroker() konfigurerar själva meddelandebrokern. Den definierar hur meddelanden dirigeras mellan klienterna och applikationen.

enableSimpleBroker("/topic"): Aktiverar en minnesbaserad meddelandebroker för destinationer med prefixet /topic. Klienterna prenumererar på dessa ämnen.
setApplicationDestinationPrefixes("/app"): Definierar prefix för meddelanden som är avsedda för metoder annoterade med @MessageMapping i vår applikation.

Komplett WebSocket-konfiguration

Här är en minimal Spring Boot-applikation som demonstrerar WebSocket-konfigurationen. Försök köra den för att se Spring initiera WebSocket-servern!

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
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 Main {
  public static void main(String[] args) {
    SpringApplication.run(Main.class, args);
    System.out.println("WebSocket server ready on port 8080!");
    System.out.println("Connect at ws://localhost:8080/ws-connect");
  }

  @Configuration
  @EnableWebSocketMessageBroker
  static class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

      @Override
      public void registerStompEndpoints(StompEndpointRegistry registry) {
          registry.addEndpoint("/ws-connect")
                  .withSockJS(); 
      }

      @Override
      public void configureMessageBroker(MessageBrokerRegistry config) {
          config.enableSimpleBroker("/topic");
          config.setApplicationDestinationPrefixes("/app");
      }
  }
}

Koppla till GraphQL-prenumerationer

Med denna WebSocket-infrastruktur kan våra GraphQL-prenumerationsresolverare från den föregående lektionen nu publicera händelser.

När en resolverare publicerar en händelse ser Springs meddelandebroker till att alla klienter som prenumererar på relevant /topic omedelbart meddelas via sin öppna WebSocket-anslutning.

Snabbkontroll: WebSocket-konfiguration

Fundera på följande rad från vår WebSocket-konfiguration:

config.enableSimpleBroker("/topic");

Vad är det huvudsakliga syftet med prefixet /topic i detta sammanhang?

Besvara frågan i den interaktiva lektionen

Sammanfattning: WebSockets i Spring

Bra jobbat! Du har lärt dig att integrera WebSockets med Spring Boot för att tillhandahålla ett robust lager för realtidskommunikation.

Vi lade till WebSocket-starter-beroendet.
Vi använde @EnableWebSocketMessageBroker och WebSocketMessageBrokerConfigurer.
Vi konfigurerade STOMP-slutpunkter, till exempel /ws-connect med SockJS.
Vi konfigurerade en meddelandebroker med prefix som /topic för prenumerationer och /app för programspecifika meddelanden.

Denna konfiguration utgör grunden för att leverera GraphQL-prenumerationer i realtid!

Gratis att börja

Lär dig GraphQL-API:er med Spring Boot 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 ”Integrera WebSockets med Spring” gratis?

Ja – hela texten till ”Integrera WebSockets med Spring” 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 GraphQL-API:er med Spring Boot, kan Ni uppgradera till CoddyKit PRO. Kursen i GraphQL-API:er med Spring Boot innehåller totalt 4 lektioner.

Vad lär jag mig i ”Integrera WebSockets med Spring”?

Konfigurera WebSocket-stöd i er Spring Boot-applikation för att möjliggöra bestående klient-serveranslutningar för prenumerationer. Ni övar på GraphQL-API:er med Spring Boot 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 GraphQL-API:er med Spring Boot?

Du behöver inga förkunskaper. Utbildningen i GraphQL-API:er med Spring Boot 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 ”Integrera WebSockets med Spring”?

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 GraphQL-API:er med Spring Boot-lektionen?

Ja. Varje GraphQL-API:er med Spring Boot-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

← Tillbaka till GraphQL-API:er med Spring Boot