Comment implémenter une longue connexion nodejs

Node.js est un environnement d'exécution JavaScript côté serveur très populaire. Il excelle dans la programmation réseau, notamment dans la mise en œuvre de connexions de longue durée.

Dans la programmation réseau, une connexion longue fait référence à un état dans lequel le client et le serveur maintiennent une activité de battement de cœur et ne ferment pas la connexion. Par rapport au modèle requête-réponse HTTP traditionnel, les connexions longues peuvent améliorer l’efficacité du réseau et les performances du système. Par exemple, lors de l'envoi et de la réception de données via une longue connexion entre le client et le serveur, la surcharge d'établissement et de déconnexion de la connexion peut être réduite, et le retard du réseau et le gaspillage des ressources système qui en résultent peuvent être évités.

Alors, comment implémenter des connexions longues dans Node.js ?

1. Utilisez WebSocket

WebSocket est un protocole construit sur le protocole TCP pour réaliser une communication en duplex intégral. Il fournit un moyen d'établir une longue connexion entre le client et le serveur, permettant une communication bidirectionnelle au lieu d'une simple réponse client-serveur.

Dans Node.js, vous pouvez utiliser la bibliothèque ws pour implémenter des connexions WebSocket. Voici un exemple WebSocket simple :

<code>const WebSocket = require('ws');

const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', function connection(ws) {
  console.log('client connected');

  ws.on('message', function incoming(message) {
    console.log('received: %s', message);
  });

  ws.on('close', function close() {
    console.log('client disconnected');
  });
});</code>

Dans cet exemple, nous créons un serveur WebSocket en écoute sur le port 8080. Lorsqu'un client se connecte au serveur, le serveur WebSocket appellera la fonction de rappel de connexion via le gestionnaire d'événements. Dans cette fonction de rappel, nous pouvons enregistrer un gestionnaire d'événements de message pour recevoir les messages envoyés par le client. Et nous avons également enregistré un gestionnaire d'événements de fermeture à gérer lorsque le client se déconnecte.

2. Utiliser TCP Socket

TCP Socket est un module de base de Node.js, utilisé pour implémenter la communication socket du protocole TCP. Dans Node.js, vous pouvez utiliser le module net pour faire fonctionner TCP Socket.

Ce qui suit est un exemple simple de socket TCP :

<code>const net = require('net');

const server = net.createServer(function(socket) {
  console.log('client connected');

  socket.on('data', function(data) {
    console.log('received: ' + data);
  });

  socket.on('end', function() {
    console.log('client disconnected');
  });
});

server.listen(8080, function() {
  console.log('server started');
});</code>

Dans cet exemple, nous créons un serveur TCP Socket écoutant sur le port 8080. Lorsque le client se connecte au serveur, nous générons un journal, puis enregistrons le gestionnaire d'événements de données pour recevoir les données envoyées par le client. Lorsque la connexion se termine, nous générons un autre journal.

3. Utiliser l'interrogation longue HTTP

L'interrogation longue HTTP est une technologie qui établit des connexions longues dans les applications Web. Il est implémenté via le mécanisme de connexion longue du protocole HTTP, qui permet au serveur de transmettre des données au client.

Dans Node.js, nous pouvons implémenter nous-mêmes des connexions HTTP à interrogation longue. Voici un exemple simple d'interrogation longue HTTP :

<code>const http = require('http');
const messages = [];

http.createServer(function(req, res) {
  console.log('client connected');

  if (req.method === 'POST') {
    let chunks = '';

    req.on('data', function(chunk) {
      chunks += chunk;
    });

    req.on('end', function() {
      messages.push(chunks);
      console.log('message received: ' + chunks);
    });
  } else if (req.method === 'GET') {
    res.writeHead(200, { 'Content-Type': 'text/plain', 'Connection': 'keep-alive', 'Cache-Control': 'no-cache' });

    let lastMessageIndex = 0;

    function checkForNewMessages() {
      if (lastMessageIndex < messages.length) {
        res.write(messages.slice(lastMessageIndex).join('\n') + '\n');
        lastMessageIndex = messages.length;
      }
    }

    setInterval(checkForNewMessages, 1000);
    checkForNewMessages();
  }
}).listen(8080);</code>

Dans cet exemple, nous créons un serveur HTTP en écoute sur le port 8080. En vérifiant la méthode de la requête (GET ou POST), nous pouvons convertir la requête en un mécanisme d'interrogation long. Dans une requête d'interrogation longue, nous envoyons un code de réponse 200, un en-tête de connexion et un en-tête Cache-Control au client pour indiquer que nous maintiendrons la connexion active. Ensuite, nous utilisons la fonction setInterval et la fonction checkForNewMessages pour vérifier en permanence les derniers messages et, s'il y a de nouveaux messages, les envoyer au client.

Résumé

Dans Node.js, les connexions longues peuvent être implémentées à l'aide de diverses technologies telles que WebSocket, TCP Socket et HTTP long polling. Le choix spécifique dépend des besoins de l'application et de la conception. Bien entendu, il existe d'autres technologies plus avancées, telles que Socket.IO, etc., qui peuvent offrir plus de fonctions et de flexibilité.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!