WebSockets & Real-Time Systems with Spring · Leçon

Configuration des points de terminaison WebSocket

Configurez les points de terminaison WebSocket dans Spring, en définissant les chemins et en gérant les connexions initiales.

Configuration des points de terminaison WebSocket est une leçon WebSockets & Real-Time Systems with Spring gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage WebSockets & Real-Time Systems with Spring, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours WebSockets & Real-Time Systems with Spring comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

What are WebSocket Endpoints?

Imagine a special doorway for real-time communication. In Spring, this doorway is called a WebSocket endpoint.

It's a specific URL path, like /ws or /chat, that your clients (e.g., web browsers) connect to for WebSocket communication. Without it, your server wouldn't know where to listen for real-time requests!

Spring Boot App Entry Point

Before configuring WebSockets, let's recall our Spring Boot application's main entry point. This is where your application starts running.

The @SpringBootApplication annotation simplifies setup by bundling common Spring annotations.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

Enabling WebSocket Support

To tell Spring Boot that you want to use WebSockets, you need to enable it. This is done with a simple annotation on a configuration class.

Add @Configuration to mark the class as a Spring configuration.
Use @EnableWebSocket to activate Spring's WebSocket module.

This sets the stage for defining your endpoints.

The WebSocketConfigurer Interface

To customize how WebSockets are handled, Spring provides the WebSocketConfigurer interface. You'll implement this interface in your configuration class.

It gives you a method to override where you can register your specific WebSocket handlers and their paths.

Registering Your First Endpoint

Inside your WebSocketConfigurer implementation, you'll override the registerWebSocketHandlers method. This method takes a WebSocketHandlerRegistry object.

The registry is used to add your WebSocketHandler instances and map them to specific URL paths.

Defining the Endpoint Path

The core of endpoint configuration is the addHandler() method. It takes two main arguments:

Your WebSocketHandler instance (what handles messages).
The URL path where clients will connect (e.g., /mywebsocket).

Example: registry.addHandler(myHandler(), "/mywebsocket");

CORS and SockJS Fallback

You might need to allow connections from different domains (CORS) or support older browsers. The addHandler() method offers fluent options:

.setAllowedOrigins("*"): Allows connections from any domain. For production, specify exact domains.
.withSockJS(): Enables SockJS fallback, providing an alternative transport for browsers that don't fully support WebSockets.

Example: WebSocketConfig Class

Here's how your full configuration class might look. Notice how we implement WebSocketConfigurer and register a handler for the /ws path.

The myHandler() method creates an instance of our custom handler (defined next).

import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import org.springframework.context.annotation.Bean;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

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

  @Bean
  public MyWebSocketHandler myHandler() {
    return new MyWebSocketHandler();
  }
}

Example: Basic WebSocket Handler

This is a very simple MyWebSocketHandler. It extends TextWebSocketHandler and just logs when a connection is established or closed. We'll dive deeper into handling messages in the next lesson!

import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;

public class MyWebSocketHandler extends TextWebSocketHandler {

  @Override
  public void afterConnectionEstablished(WebSocketSession session) throws Exception {
    System.out.println("Connection established: " + session.getId());
  }

  @Override
  public void afterConnectionClosed(WebSocketSession session, 
                                    org.springframework.web.socket.CloseStatus status) 
                                    throws Exception {
    System.out.println("Connection closed: " + session.getId() + " - " + status.getReason());
  }

  // Message handling will go here in a later lesson
  @Override
  protected void handleTextMessage(WebSocketSession session, TextMessage message) {
    // For now, we just acknowledge. Message processing is next lesson.
    System.out.println("Received message (not processed yet): " + message.getPayload());
  }
}

Endpoint Config Check

You want to set up a WebSocket endpoint at the path /chat that allows connections from any origin and uses SockJS fallback. Which configuration snippet is correct?

Recap: WebSocket Endpoints

Great job! You've learned how to configure WebSocket endpoints in Spring Boot:

You use @EnableWebSocket on a @Configuration class.
You implement WebSocketConfigurer and override registerWebSocketHandlers.
Inside, you use registry.addHandler() to map a WebSocketHandler to a URL path.
Options like setAllowedOrigins() and withSockJS() enhance compatibility.

Next, we'll dive into how to send and receive messages using these handlers!

Questions Fréquemment Posées

La leçon « Configuration des points de terminaison WebSocket » est-elle gratuite ?

Oui — le texte complet de « Configuration des points de terminaison WebSocket » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours WebSockets & Real-Time Systems with Spring, passe à CoddyKit PRO. Le cours WebSockets & Real-Time Systems with Spring comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Configuration des points de terminaison WebSocket » ?

Configurez les points de terminaison WebSocket dans Spring, en définissant les chemins et en gérant les connexions initiales. Tu pratiques WebSockets & Real-Time Systems with Spring avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer WebSockets & Real-Time Systems with Spring ?

Aucune expérience préalable n'est requise. WebSockets & Real-Time Systems with Spring sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Configuration des points de terminaison WebSocket » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon WebSockets & Real-Time Systems with Spring ?

Oui. Chaque leçon WebSockets & Real-Time Systems with Spring inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Spring Boot pour WebSockets
Configuration des points de terminaison WebSocket
Messagerie client-serveur élémentaire
Gérer les événements du cycle de vie WebSocket dans Spring

← Retour à WebSockets & Real-Time Systems with Spring