Gestion du cycle de vie des connexions
Gérez le cycle de vie des connexions WebSocket, notamment leur ouverture, leur fermeture et les déconnexions inattendues.
Gestion du cycle de vie des connexions 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.
WebSocket Connection Lifecycle
Every WebSocket connection goes through a lifecycle: it opens, stays active for messaging, and eventually closes. Managing these stages is crucial for building robust real-time applications.
Proper lifecycle management helps ensure resources are used efficiently and that your application responds gracefully to various connection events.
The Initial Handshake
Before a WebSocket connection is established, an initial HTTP handshake occurs. The client sends an HTTP request with an Upgrade header, asking to switch protocols.
If the server agrees, it responds with a 101 Switching Protocols status, and the connection transitions from HTTP to WebSocket.
Client-Side Connection
On the client side, typically in a web browser, you initiate a WebSocket connection using JavaScript. The WebSocket constructor creates a new connection to the specified URL.
This example shows how to connect and log messages when the connection opens or encounters an error.
const socket = new WebSocket("ws://localhost:8080/lifecycle");
socket.onopen = () => {
console.log("WebSocket Connected!");
};
socket.onerror = (error) => {
console.error("WebSocket Error:", error);
};Server-Side: Handling New Connections
In Spring, you can use the @OnOpen annotation to define a method that executes when a new WebSocket connection is established. This is your entry point for handling new clients.
The Session object provides details about the client connection.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;
@SpringBootApplication
public class WebSocketLifecycleApp {
public static void main(String[] args) {
SpringApplication.run(WebSocketLifecycleApp.class, args);
}
@Bean
public ServerEndpointExporter serverEndpointExporter() {
return new ServerEndpointExporter();
}
}
@ServerEndpoint("/lifecycle")
@Component
class LifecycleHandler {
@OnOpen
public void onOpen(Session session) {
System.out.println("Client connected: " + session.getId());
}
}Gracefully Closing Connections
A connection can be closed intentionally by either the client or the server. This is called a 'graceful' closure. It's important to close connections properly to release server resources and inform clients.
A close message usually includes a status code and a reason for closure, helping both ends understand why the connection ended.
Client-Side Disconnect
Clients can close a WebSocket connection using the close() method. You can optionally provide a status code and a reason message.
The onclose event listener is triggered when the connection is closed, allowing you to perform cleanup or UI updates.
socket.onclose = (event) => {
if (event.wasClean) {
console.log(`Closed cleanly, code=${event.code}, reason=${event.reason}`);
} else {
console.log('Connection died unexpectedly');
}
};
// To close the connection explicitly:
socket.close(1000, "Client leaving");Server-Side: Handling Disconnections
The @OnClose annotation in Spring allows you to define a method that executes when a WebSocket connection is closed. This is where you can clean up resources associated with that session.
The CloseReason parameter provides details about why the connection was terminated.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
import javax.websocket.OnOpen;
import javax.websocket.OnClose;
import javax.websocket.Session;
import javax.websocket.CloseReason;
import javax.websocket.server.ServerEndpoint;
@SpringBootApplication
public class WebSocketLifecycleApp {
public static void main(String[] args) {
SpringApplication.run(WebSocketLifecycleApp.class, args);
}
@Bean
public ServerEndpointExporter serverEndpointExporter() {
return new ServerEndpointExporter();
}
}
@ServerEndpoint("/lifecycle")
@Component
class LifecycleHandler {
@OnOpen
public void onOpen(Session session) {
System.out.println("Client connected: " + session.getId());
}
@OnClose
public void onClose(Session session, CloseReason reason) {
System.out.println("Client disconnected: " + session.getId() + " - Reason: " + reason.getReasonPhrase());
}
}Handling Unexpected Disconnections & Errors
Sometimes connections don't close gracefully. Network issues, client crashes, or server errors can lead to abrupt disconnections. These are 'unclean' closures.
It's vital to have mechanisms to detect and respond to these unexpected events to maintain application stability and user experience.
Server-Side: Error Handling
The @OnError annotation handles exceptions that occur during a WebSocket session. This could be due to issues like message processing errors or underlying network problems.
Implementing an @OnError handler ensures your server can log errors and potentially close the affected session gracefully, preventing resource leaks.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
import javax.websocket.OnOpen;
import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.Session;
import javax.websocket.CloseReason;
import javax.websocket.server.ServerEndpoint;
@SpringBootApplication
public class WebSocketLifecycleApp {
public static void main(String[] args) {
SpringApplication.run(WebSocketLifecycleApp.class, args);
}
@Bean
public ServerEndpointExporter serverEndpointExporter() {
return new ServerEndpointExporter();
}
}
@ServerEndpoint("/lifecycle")
@Component
class LifecycleHandler {
@OnOpen
public void onOpen(Session session) {
System.out.println("Client connected: " + session.getId());
}
@OnClose
public void onClose(Session session, CloseReason reason) {
System.out.println("Client disconnected: " + session.getId() + " - Reason: " + reason.getReasonPhrase());
}
@OnError
public void onError(Session session, Throwable throwable) {
System.err.println("Error on session " + session.getId() + ": " + throwable.getMessage());
}
}Detecting Liveness with Heartbeats
When a connection drops unexpectedly (e.g., network cable pulled), neither side might immediately know. Heartbeat mechanisms, often using WebSocket ping/pong frames, help detect unresponsive peers.
By sending periodic pings and expecting pongs, you can determine if a connection is still alive and close it if no response is received.
Lifecycle Management Check
Managing the various stages of a WebSocket connection is key to building reliable real-time applications. Let's test your understanding of Spring's lifecycle annotations.
Recap: Connection Management
In this lesson, you've learned about the crucial aspects of WebSocket connection lifecycle management. We covered:
- The initial HTTP handshake.
- How clients and servers open connections (
@OnOpen). - Graceful client and server disconnections (
@OnClose). - Handling unexpected errors during a session (
@OnError). - The role of heartbeats in detecting unresponsive connections.
Mastering these concepts is fundamental for developing robust and resilient real-time applications with WebSockets and Spring.
Questions Fréquemment Posées
La leçon « Gestion du cycle de vie des connexions » est-elle gratuite ?
Oui — le texte complet de « Gestion du cycle de vie des connexions » 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 « Gestion du cycle de vie des connexions » ?
Gérez le cycle de vie des connexions WebSocket, notamment leur ouverture, leur fermeture et les déconnexions inattendues. 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 « Gestion du cycle de vie des connexions » ?
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
- Gestion élégante des erreurs WebSocket
- Gestion du cycle de vie des connexions
- Nouvelles tentatives et solutions de secours
- Pulsations et maintien en vie Ping/Pong