PricingLoginStart free
WebSockets og realtidssystemer med Spring · Lektion

WebFlux WebSocket-handlere

Implementer reaktive WebSocket-handlere med Spring WebFlux til ikke-blokerende I/O.

Lektion 2 af 411 trin

WebFlux WebSocket-handlere er en gratis WebSockets og realtidssystemer med Spring-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i WebSockets og realtidssystemer med Spring, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. WebSockets og realtidssystemer med Spring-kurset indeholder 4 lektioner i alt.

Reaktive WebSockets med WebFlux

Velkommen! I denne lektion går vi i dybden med implementering af reaktive WebSocket-håndteringer ved hjælp af Spring WebFlux. Denne tilgang er afgørende for at bygge ydeevnerige, ikke-blokerende realtidsapplikationer.

Spring WebFlux udnytter kraften i Project Reactor (Flux og Mono) til at håndtere WebSocket-forbindelser og -meddelelser asynkront, så dine applikationer bliver meget skalerbare og effektive.

Grænsefladen WebSocketHandler

Kernen i WebFlux WebSockets er grænsefladen WebSocketHandler. Det er en funktionel grænseflade, hvilket betyder, at den har én abstrakt metode, som du skal implementere.

Denne metode, handle(WebSocketSession session), kaldes, hver gang der oprettes en ny WebSocket-forbindelse. Den returnerer en Mono<Void>, som signalerer, hvornår håndteringen af sessionen er afsluttet.

import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.WebSocketSession;
import reactor.core.publisher.Mono;

// Simplified interface definition
public interface WebSocketHandler {
  Mono<Void> handle(WebSocketSession session);
}

Implementering af en simpel ekko-håndtering

Lad os oprette en grundlæggende ekko-håndtering. Denne håndtering modtager indgående tekstmeddelelser fra en klient og sender dem straks tilbage. Det er et grundlæggende eksempel, der demonstrerer både modtagelse og afsendelse af reaktive meddelelser.

Bemærk brugen af reaktive operatorer som map og flatMap til at behandle meddelelsesstrømmen.

import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.WebSocketSession;
import reactor.core.publisher.Mono;

public class EchoWebSocketHandler implements WebSocketHandler {

  @Override
  public Mono<Void> handle(WebSocketSession session) {
    // Receive messages, transform them into text messages,
    // then send them back to the client.
    return session.receive()
      .map(WebSocketSession::textMessage)
      .flatMap(session::send)
      .then(); // Signal completion once the receive stream ends
  }
}

Forstå WebSocketSession

Objektet WebSocketSession er afgørende. Det repræsenterer én aktiv WebSocket-forbindelse med en klient. Tænk på det som din direkte linje til den specifikke klient.

Vigtige metoder i WebSocketSession:

  • receive(): Returnerer en Flux<WebSocketMessage> for indgående meddelelser.
  • send(Publisher<WebSocketMessage>): Sender meddelelser til klienten.
  • getId(): Angiver en unik identifikator for sessionen.
  • textMessage(String payload): Hjælpemetode til at oprette en tekstmeddelelse.

Modtag meddelelser reaktivt

Metoden session.receive() er den måde, din håndtering modtager indgående meddelelser på. Den returnerer en Flux<WebSocketMessage>, som er en strøm af meddelelser, der ankommer over tid.

Du kan anvende alle Project Reactors effektive operatorer (som doOnNext, filter og map) til at behandle disse meddelelser på en ikke-blokerende måde.

import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.WebSocketMessage;
import org.springframework.web.reactive.socket.WebSocketSession;
import reactor.core.publisher.Mono;

public class LoggingHandler implements WebSocketHandler {

  @Override
  public Mono<Void> handle(WebSocketSession session) {
    return session.receive()
      .doOnNext(message -> {
        // Log the received message payload
        System.out.println("Received: " + message.getPayloadAsText());
      })
      .then(); // Ensures the Mono completes when the Flux finishes
  }
}

Send meddelelser reaktivt

Hvis du vil sende data tilbage til klienten, bruger du session.send(Publisher<WebSocketMessage> messages). Denne metode tager en udgiver (f.eks. en Flux eller Mono) med de meddelelser, du vil sende.

Du kan oprette WebSocketMessage-objekter ved hjælp af session.textMessage(String payload) til tekst eller session.binaryMessage(DataBuffer payload) til binære data.

import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.WebSocketMessage;
import org.springframework.web.reactive.socket.WebSocketSession;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.Duration;

public class TimeWebSocketHandler implements WebSocketHandler {

  @Override
  public Mono<Void> handle(WebSocketSession session) {
    // Create a Flux that emits a message every second
    Flux<WebSocketMessage> messagesToSend = Flux.interval(Duration.ofSeconds(1))
      .map(tick -> "Current time: " + System.currentTimeMillis())
      .map(session::textMessage); // Convert String to WebSocketMessage

    return session.send(messagesToSend);
  }
}

Konfigurer WebSocket-slutpunkter

Når du har oprettet din WebSocketHandler, skal du registrere den, så Spring WebFlux ved, hvilken URL-sti der skal knyttes til hvilken håndtering. Det gøres typisk i en @Configuration-klasse, der implementerer WebSocketConfigurer.

WebSocketHandlerRegistry giver dig mulighed for at knytte dine håndteringer til bestemte stier og konfigurere oprindelser.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.server.WebSocketConfigurer;
import org.springframework.web.reactive.socket.server.support.WebSocketHandlerRegistry;

@Configuration
public class MyWebSocketConfig implements WebSocketConfigurer {

  @Override
  public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
    // Map the EchoWebSocketHandler to the "/echo" path
    registry.addHandler(echoWebSocketHandler(), "/echo").setAllowedOrigins("*");
  }

  @Bean
  public WebSocketHandler echoWebSocketHandler() {
    return new EchoWebSocketHandler(); // Your handler instance
  }
}

Komplet ekko-app på serversiden

Her er en komplet Spring Boot-applikation, der kan køres, og som kombinerer vores WebSocketHandler med dens konfiguration. Den opretter en funktionel WebSocket-server, der er klar til at sende meddelelser tilbage!

Kør denne applikation, så begynder den at lytte efter WebSocket-forbindelser på stien /echo.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.WebSocketSession;
import org.springframework.web.reactive.socket.server.WebSocketConfigurer;
import org.springframework.web.reactive.socket.server.support.WebSocketHandlerAdapter;
import org.springframework.web.reactive.socket.server.support.WebSocketHandlerRegistry;
import reactor.core.publisher.Mono;

@SpringBootApplication
public class WebFluxEchoServerApplication {

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

  @Configuration
  static class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
      registry.addHandler(echoWebSocketHandler(), "/echo").setAllowedOrigins("*");
    }

    @Bean
    public WebSocketHandler echoWebSocketHandler() {
      // Inline implementation for simplicity in full example
      return new WebSocketHandler() {
        @Override
        public Mono<Void> handle(WebSocketSession session) {
          return session.receive()
            .map(WebSocketSession::textMessage)
            .flatMap(session::send)
            .then();
        }
      };
    }

    // Required for WebSocket handling in WebFlux
    @Bean
    public WebSocketHandlerAdapter handlerAdapter() {
      return new WebSocketHandlerAdapter();
    }
  }
}

Opret forbindelse med en JavaScript-klient

Hvis du vil teste din server, kan du bruge en simpel JavaScript-klient i en webbrowsers udviklerkonsol. Denne kode opretter forbindelse til dit /echo-slutpunkt, sender en meddelelse og logger svaret.

Sørg for, at din Spring Boot-applikation kører, før du forsøger at oprette forbindelse!

const socket = new WebSocket('ws://localhost:8080/echo');

socket.onopen = (event) => {
  console.log('WebSocket connection opened:', event);
  socket.send('Hello from the client!');
};

socket.onmessage = (event) => {
  console.log('Received from server:', event.data);
};

socket.onclose = (event) => {
  console.log('WebSocket connection closed:', event);
};

socket.onerror = (error) => {
  console.error('WebSocket error:', error);
};

Tjek af WebFlux-håndtering

Du har lært om kernekomponenterne i WebFlux WebSocket-håndteringer. Lad os teste din forståelse af den vigtigste metode, der starter håndteringen af sessionen.

Besvar den i den interaktive lektion

Opsummering: WebFlux WebSocket-håndteringer

Fremragende arbejde! Du har med succes undersøgt, hvordan man implementerer reaktive WebSocket-håndteringer ved hjælp af Spring WebFlux.

  • WebSocketHandler: Den centrale grænseflade til at definere, hvordan nye forbindelser skal håndteres.
  • WebSocketSession: Repræsenterer en enkelt klientforbindelse og leverer metoder til at receive() og send() meddelelser.
  • Reaktivt flow: Meddelelser håndteres ved hjælp af Project Reactors Flux<WebSocketMessage> til indgående strømme og Publisher<WebSocketMessage> til udgående strømme.
  • Konfiguration: Du registrerer dine håndteringer på bestemte URL-stier ved hjælp af en WebSocketConfigurer.

Denne reaktive tilgang sikrer, at dine realtidsapplikationer er skalerbare, effektive og robuste!

Gratis at komme i gang

Lær WebSockets og realtidssystemer med Spring med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
12
Lektioner
48
Start gratisSe hele kurset

Ofte stillede spørgsmål

Er lektionen “WebFlux WebSocket-handlere” gratis?

Ja — hele teksten til “WebFlux WebSocket-handlere” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af WebSockets og realtidssystemer med Spring-kurset, skal du opgradere til CoddyKit PRO. WebSockets og realtidssystemer med Spring-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “WebFlux WebSocket-handlere”?

Implementer reaktive WebSocket-handlere med Spring WebFlux til ikke-blokerende I/O. Du øver dig i WebSockets og realtidssystemer med Spring med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på WebSockets og realtidssystemer med Spring?

Der kræves ingen tidligere erfaring. WebSockets og realtidssystemer med Spring på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “WebFlux WebSocket-handlere”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne WebSockets og realtidssystemer med Spring-lektion?

Ja. Alle WebSockets og realtidssystemer med Spring-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Introduktion til reaktiv programmering
  2. WebFlux WebSocket-handlere
  3. Opbygning af reaktive realtidstjenester
  4. Håndtering af backpressure i reaktive streams
← Tilbage til WebSockets og realtidssystemer med Spring