Module net de Node.js

Java FileModules intégrés de Node.js

de Node.jsnetLe module est un module de base utilisé pour créer des serveurs et des clients basés sur TCP ou IPC. Il fournit des capacités de programmation réseau asynchrone et peut être utilisé pour créer diverses applications réseau, telles que des serveurs de chat, des serveurs proxy, etc.

Fonctionnalités principales

  1. Créer des serveurs et des clients TCP
  2. Créer des serveurs et des clients IPC (communication inter-processus)
  3. Gérer les connexions réseau et la transmission de données
  4. Gérer le cycle de vie des connexions réseau

Utilisation de base

Créer un serveur TCP

Exemple

const net = require('net');

// Créer un serveur TCP
const server = net.createServer((socket) => {
  console.log('Client connecté');
 
  // Recevoir les données du client
  socket.on('data', (data) => {
    console.log(`Données reçues: ${data}`);
    socket.write(`Le serveur a reçu: ${data}`); // Envoyer des données au client
  });
 
  // Client déconnecté
  socket.on('end', () => {
    console.log('Client déconnecté');
  });
});

// Écouter sur le port 3000
server.listen(3000, () => {
  console.log('Le serveur écoute sur le port 3000');
});

Créer un client TCP

Exemple

const net = require('net');

// Créer un client et se connecter au serveur
const client = net.createConnection({ port: 3000 }, () => {
  console.log('Connecté au serveur');
  client.write('Bonjour serveur !'); // Envoyer des données au serveur
});

// Recevoir des données du serveur
client.on('data', (data) => {
  console.log(`Données reçues du serveur: ${data}`);
  client.end(); // Se déconnecter
});

client.on('end', () => {
  console.log('Déconnecté du serveur');
});

Détails de l'API principale

net.createServer([options][, connectionListener])

Crée un nouveau serveur TCP ou IPC.

Paramètres :

  • options: Objet de configuration optionnel
    • allowHalfOpen: Indique si les connexions semi-ouvertes doivent être autorisées, vaut false par défaut
    • pauseOnConnect: Indique si le socket doit être mis en pause lors de la connexion, vaut false par défaut
  • connectionListener: Défini automatiquement comme écouteur de l'événement 'connection'

net.createConnection(options[, connectListener])

Crée une connexion TCP vers le port et l'hôte spécifiés.

Options courantes :

  • port: Le port auquel se connecter (requis)
  • host: L'hôte auquel se connecter, vaut 'localhost' par défaut
  • localAddress: L'interface locale utilisée pour lier la connexion réseau
  • family: Famille de protocoles IP (4 ou 6)

Socket réseau (Socket)

net.SocketC'est la classe centrale du module net, représentant une connexion réseau.

Événements courants

  1. connect: Déclenché lorsqu'une connexion est établie avec succès
  2. data: Déclenché lorsque des données sont reçues
  3. end: Déclenché lorsque l'autre extrémité de la connexion envoie un paquet FIN
  4. timeout: Déclenché lorsque la connexion expire en raison de l'inactivité
  5. error: Déclenché lorsqu'une erreur se produit
  6. close: Déclenché lorsque la socket est complètement fermée

Méthodes courantes

  1. write(data[, encoding][, callback]): Envoyer des données sur la socket
  2. end([data][, encoding]): Fermer partiellement la socket
  3. destroy(): S'assurer qu'aucune autre activité d'E/S ne se produise sur cette socket
  4. pause(): Suspendre la lecture des données
  5. resume(): Reprendre la lecture des données

Applications avancées

Gestion de plusieurs connexions client

Exemple

const net = require('net');

const server = net.createServer((socket) => {
  // Définir un identifiant unique pour chaque connexion
  socket.id = Date.now();
 
  console.log(`Client ${socket.id}connecté`);
 
  socket.on('data', (data) => {
    console.log(`Données reçues du client ${socket.id}`: ${data}`);
    // Diffuser un message à tous les clients
    server.getConnections((err, count) => {
      if (count > 1) {
        socket.write(`Il y a ${count-1}autres clients en ligne`);
      }
    });
  });
 
  socket.on('end', () => {
    console.log(`Client ${socket.id}déconnecté`);
  });
});

server.listen(3000);

Gestion des délais d'attente

Exemple

const server = net.createServer((socket) => {
  // Définir le délai d'attente de connexion à 5 minutes
  socket.setTimeout(5 * 60 * 1000);
 
  socket.on('timeout', () => {
    console.log('La connexion a expiré, déconnexion');
    socket.end();
  });
});

Méthodes et propriétés

FonctionDescription
Créer un serveurnet.createServer([options][, connectionListener]): Utilisé pour créer un serveur TCP, peut écouter les demandes de connexion.
Se connecter au serveurnet.connect(options[, connectListener])ounet.createConnection(options[, connectListener]): Utilisé pour se connecter à un serveur spécifié (créer un client).
Objet SocketsocketL'objet représente une connexion à un serveur ou à un client TCP et contient diverses méthodes pour envoyer, recevoir et fermer des connexions.

Méthodes

Non.Méthodes & Description
1net.createServer([options][, connectionListener])
Crée un serveur TCP. Le paramètre connectionListener crée automatiquement un écouteur pour l'événement 'connection'.
2net.connect(options[, connectionListener])
Retourne un nouveau 'net.Socket' et se connecte à l'adresse et au port spécifiés.
Lorsque la socket est établie, l'événement 'connect' sera émis.
3net.createConnection(options[, connectionListener])
Crée une connexion TCP vers le port port et l'hôte host. host vaut par défaut 'localhost'.
4net.connect(port[, host][, connectListener])
Crée une connexion TCP avec le port port et l'hôte host. host vaut par défaut 'localhost'. Le paramètre connectListener sera ajouté comme écouteur pour l'événement 'connect'. Retourne 'net.Socket'.
5net.createConnection(port[, host][, connectListener])
Crée une connexion TCP avec le port port et l'hôte host. host vaut par défaut 'localhost'. Le paramètre connectListener sera ajouté comme écouteur pour l'événement 'connect'. Retourne 'net.Socket'.
6net.connect(path[, connectListener])
Crée un socket Unix connecté à path. Le paramètre connectListener sera ajouté comme écouteur pour l'événement 'connect'. Renvoie 'net.Socket'.
7net.createConnection(path[, connectListener])
Crée un socket Unix connecté à path. Le paramètre connectListener sera ajouté comme écouteur pour l'événement 'connect'. Renvoie 'net.Socket'.
8net.isIP(input)
Vérifie si l'entrée est une adresse IP. Renvoie 4 pour IPV4, 6 pour IPV6, et 0 sinon.
9net.isIPv4(input)
Si l'adresse d'entrée est IPV4, renvoie true, sinon renvoie false.
10net.isIPv6(input)
Si l'adresse d'entrée est IPV6, renvoie true, sinon renvoie false.

net.Server

net.Server est généralement utilisé pour créer un serveur TCP ou local.

Non.Méthodes & Description
1server.listen(port[, host][, backlog][, callback])
Écoute les connexions sur le port port et l'hôte host spécifiés. Par défaut, host accepte les connexions directes depuis n'importe quelle adresse IPv4 (INADDR_ANY). Lorsque port vaut 0, un port aléatoire sera attribué.
2server.listen(path[, callback])
Démarre un serveur de socket local en écoutant sur le chemin spécifié.
3server.listen(handle[, callback])
Se connecte via le handle spécifié.
4server.listen(options[, callback])
Les propriétés de options : port port, host host, et backlog, ainsi que la fonction de rappel optionnelle, appellent ensemble server.listen(port, [host], [backlog], [callback]). De plus, le paramètre path peut être utilisé pour spécifier un socket UNIX.
5server.close([callback])
Le serveur arrête d'accepter de nouvelles connexions et maintient les connexions existantes. C'est une fonction asynchrone. Lorsque toutes les connexions se terminent, le serveur se ferme et l'événement 'close' est émis.
6server.address()
Le système d'exploitation renvoie l'adresse liée, le nom de la famille de protocoles et le port du serveur.
7server.unref()
Si c'est le seul serveur actif dans le système d'événements, l'appel à unref permettra au programme de se terminer.
8server.ref()
Opposé de unref. Si c'est le seul serveur, appeler ref sur un serveur qui a été précédemment unref ne laissera pas le programme se terminer (comportement par défaut). Si le serveur a déjà été ref, appeler ref à nouveau n'a aucun effet.
9server.getConnections(callback)
Obtient de manière asynchrone le nombre de connexions actuellement actives sur le serveur. Ce n'est valide qu'après que la socket a été envoyée au processus enfant ; la fonction de rappel possède 2 paramètres, err et count.

Événements

Non.Événement & Description
1listening
Déclenché lorsque le serveur appelle server.listen pour se lier.
2connexion
Déclenché lorsqu'une nouvelle connexion est créée. socket est une instance de net.Socket.
3close
Déclenché lorsque le serveur est fermé. Remarque : si des connexions existent, cet événement ne sera pas déclenché tant que toutes les connexions ne sont pas fermées.
4error
Déclenché lorsqu'une erreur se produit. L'événement 'close' sera appelé directement par les événements suivants.

net.Socket

L'objet net.Socket est une abstraction d'un socket TCP ou UNIX. Les instances net.Socket implémentent une interface de flux duplex. Elles peuvent être utilisées lorsque l'utilisateur crée un client (à l'aide de connect()), ou elles peuvent être créées par Node et transmises à l'utilisateur via l'événement connection du serveur.

Événements

Les événements net.Socket incluent :

Non.Événement & Description
1lookup
Déclenché après la résolution du nom de domaine mais avant la connexion. Non applicable aux sockets UNIX.
2connect
Déclenché lorsqu'une connexion de socket est établie avec succès.
3data
Déclenché lorsque des données sont reçues.
4end
Déclenché lorsque l'autre extrémité du socket envoie un paquet FIN.
5timeout
Déclenché lorsque le socket expire en raison de l'inactivité. Cela indique uniquement que le socket est devenu inactif. L'utilisateur doit fermer manuellement la connexion.
6drain
Déclenché lorsque le tampon d'écriture devient vide. Peut être utilisé pour contrôler les téléversements.
7error
Déclenché lorsqu'une erreur se produit.
8close
Déclenché lorsque le socket est complètement fermé. Le paramètre had_error est une valeur booléenne indiquant si le socket a été fermé en raison d'une erreur de transmission.

Propriétés

net.Socket fournit de nombreuses propriétés utiles pour contrôler l'interaction avec les sockets :

Non.Propriété & Description
1socket.bufferSize
Cette propriété indique le nombre d'octets à écrire dans le tampon.
2socket.remoteAddress
La chaîne d'adresse IP distante, par ex. '74.125.127.100' ou '2001:4860:a005::68'.
3socket.remoteFamily
La chaîne de famille de protocole IP distante, par ex. 'IPv4' ou 'IPv6'.
4socket.remotePort
Le port distant, représenté sous forme de nombre, par ex. 80 ou 21.
5socket.localAddress
L'interface locale liée à la connexion réseau. L'adresse IP locale à laquelle le client distant se connecte, sous forme de chaîne. Par exemple, si vous écoutez sur '0.0.0.0' et que le client se connecte à '192.168.1.1', la valeur sera '192.168.1.1'.
6socket.localPort
L'adresse de port locale, représentée sous forme de nombre. Par exemple : 80 ou 21.
7socket.bytesRead
Le nombre d'octets reçus.
8socket.bytesWritten
Le nombre d'octets envoyés.

Méthodes

Non.Metode & Deskripsi
1new net.Socket([options])
Construit un nouvel objet socket.
2socket.connect(port[, host][, connectListener])
Crée une connexion socket avec le port et l'hôte spécifiés. Le paramètre hôte vaut localhost par défaut. Normalement, il n'est pas nécessaire d'utiliser net.createConnection pour ouvrir un socket. Il n'est utilisé que lorsque vous implémentez votre propre socket.
3socket.connect(path[, connectListener])
Ouvre un socket Unix au chemin spécifié. Normalement, il n'est pas nécessaire d'utiliser net.createConnection pour ouvrir un socket. Il n'est utilisé que lorsque vous implémentez votre propre socket.
4socket.setEncoding([encoding])
Définit l'encodage.
5socket.write(data[, encoding][, callback])
Envoie des données sur le socket. Le deuxième paramètre spécifie l'encodage de la chaîne, qui est par défaut l'encodage UTF8.
6socket.end([data][, encoding])
Ferme à moitié le socket. Par exemple, il envoie un paquet FIN. Le serveur peut encore envoyer des données.
7socket.destroy()
Garantit qu'il n'y a aucune activité d'E/S sur ce socket. Nécessaire uniquement en cas d'erreur. (pour gérer les erreurs, etc.)
8socket.pause()
Met en pause la lecture des données. C'est-à-dire que l'événement data ne sera plus émis. Très utile pour contrôler les téléversements.
9socket.resume()
Reprend la lecture des données après l'appel à pause().
10socket.setTimeout(timeout[, callback])
Définit le délai d'expiration du socket après qu'il a été inactif pendant plus de timeout millisecondes.
11socket.setNoDelay([noDelay])
Désactive l'algorithme de Nagle. Par défaut, les connexions TCP utilisent l'algorithme de Nagle, qui met les données en mémoire tampon avant l'envoi. Définir noDelay sur true enverra les données immédiatement lors de l'appel à socket.write(). La valeur par défaut de noDelay est true.
12socket.setKeepAlive([enable][, initialDelay])
Désactive/active la fonctionnalité keep-alive, et définit éventuellement un délai initial avant l'envoi de la première sonde keep-alive sur une socket inactive. La valeur par défaut est false. Définissez initialDelay (en millisecondes) pour définir le délai entre le dernier paquet reçu et la première sonde keep-alive. Définir initialDelay sur 0 conservera la valeur par défaut (ou précédente). La valeur par défaut est 0.
13socket.address()
Renvoie l'adresse liée, le nom de la famille de protocoles et le port du serveur tels que rapportés par le système d'exploitation. L'objet renvoyé a 3 propriétés, telles que { port: 12346, family: 'IPv4', address: '127.0.0.1' }.
14socket.unref()
S'il s'agit du seul serveur actif dans le système d'événements, appeler unref permettra au programme de se terminer. Si le serveur a déjà été unref, appeler à nouveau unref n'aura aucun effet.
15socket.ref()
Opposé de unref. S'il s'agit du seul serveur, appeler ref sur un serveur qui a déjà été unref ne laissera pas le programme se terminer (comportement par défaut). Si le serveur a déjà été ref, appeler à nouveau ref n'aura aucun effet.

Exemple

Créez un fichier server.js avec le code suivant :

Exemple

var net = require('net');
var server = net.createServer(function(connection) {
   console.log('client connecté');
   connection.on('end', function() {
      console.log('Le client a fermé la connexion');
   });
   connection.write('Bonjour le monde !'\r\n');
   connection.pipe(connection);
});
server.listen(8080, function() {
  console.log('le serveur écoute');
});

Exécutez le code serveur ci-dessus :

$ node server.js
server is listening   # 服务已创建并监听 8080 端口

Ouvrez une nouvelle fenêtre et créez un fichier client.js avec le code suivant :

Exemple

var net = require('net');
var client = net.connect({port: 8080}, function() {
   console.log('Connecté au serveur !');  
});
client.on('data', function(data) {
   console.log(data.toString());
   client.end();
});
client.on('end', function() {
   console.log('Déconnecté du serveur');
});

Exécutez le code client ci-dessus :

连接到服务器！
Hello World!

断开与服务器的连接

Démonstration d'exemple GIF

Scénarios d'application pratiques

  1. Application de chat: Créer un serveur de chat en temps réel
  2. Serveur de jeu: Gérer une interaction multijoueur en temps réel
  3. Serveur proxy: Transférer les requêtes des clients
  4. Protocole personnalisé: Implémenter des protocoles de couche application spécifiques
  5. Communication avec les appareils IoT: Communiquer avec les appareils embarqués

Bonnes pratiques

  1. Gestion des erreurs: Toujours écouter l'événement 'error'
  2. Gestion des ressources: Fermer en temps voulu les connexions qui ne sont plus utilisées
  3. Considérations de performance: Pour les scénarios à forte concurrence, envisagez d'utiliser un pool de connexions
  4. Sécurité: Mettre en œuvre des mécanismes d'authentification et de chiffrement appropriés
  5. Journalisation: Enregistrer les événements de connexion importants et les données

Exemple

// Exemple : Gestion complète des erreurs
server.on('error', (err) => {
  console.error('Server error:', err);
});

client.on('error', (err) => {
  console.error('Client error:', err);
});

En maîtrisant le module net, vous pouvez créer une variété d'applications réseau puissantes, comprendre les principes sous-jacents de la communication réseau et poser une base solide pour l'apprentissage de frameworks réseau plus avancés.

Java FileModules intégrés de Node.js

Autres extensions