NodeJS Websocket how to reconnect when server restarts

When developing real-time applications with Node.js, maintaining the stability of WebSocket connections is crucial. WebSocket connections may be disconnected due to server restarts or network issues. To address disconnections caused by server restarts, we can implement an automatic reconnection mechanism on the client side. Below are the steps and examples to achieve this mechanism:

1. Client-side Handling of Disconnection Events

First, on the client side, we need to properly handle the WebSocket close event. When the WebSocket connection is closed, this event is triggered.

javascript
let ws;

function connect() {
    ws = new WebSocket('ws://example.com/socket');

    ws.onclose = function() {
        console.log('WebSocket connection closed');
        reconnect();
    };
}

2. Implementing the Reconnection Mechanism

Within the onclose callback function, we can implement the logic for reconnection. Typically, this includes a delayed reconnection strategy to avoid initiating numerous reconnection attempts in a short period.

javascript
function reconnect() {
    setTimeout(() => {
        console.log('Reconnecting...');
        connect();
    }, 5000); // Attempt reconnection after 5 seconds
}

3. Handling Connection Errors

Errors may occur during the connection process, and we also need to handle the error event on the client side. This helps us understand the reasons for reconnection failures and allows for appropriate handling when necessary.

javascript
ws.onerror = function(err) {
    console.error('WebSocket encountered error: ', err.message, 'Closing socket');
    ws.close();
};

4. Optimizing the Reconnection Strategy

To handle reconnections more intelligently, we can introduce algorithms such as the exponential backoff strategy to control the interval between reconnection attempts. This helps effectively rebuild the connection without affecting server performance.

javascript
let attempt = 1;

function reconnect() {
    let timeout = Math.min(5000 * attempt, 30000); // Interval increases each attempt, max 30 seconds
    setTimeout(() => {
        attempt++;
        console.log(`Reconnecting attempt ${attempt}...`);
        connect();
    }, timeout);
}

5. Server-side Considerations

On the server side, it is also necessary to ensure that the WebSocket service can recover immediately after restart, allowing clients to reconnect. This typically means including the WebSocket service's startup script in your server application's startup script or using process management tools (such as PM2) to manage the Node.js application.

Summary

By following these steps, we can implement an automatic reconnection mechanism for WebSocket on the client side, thereby improving the stability and user experience of real-time applications. This mechanism is particularly important for applications requiring continuous connections, such as real-time communication or gaming.