Vous apprendre étape par étape à utiliser Node.js pour la communication réseau TCP (Pratique)

Comment utiliser Node.js pour la communication réseau TCP ? L'article suivant vous aidera à comprendre comment utiliser Node.js pour la communication réseau TCP. J'espère qu'il vous sera utile !

Résumé : Le réseau est la base de la communication et de l'interconnexion. Node.js fournit des modules tels que net, http et dgram, qui sont utilisés respectivement pour implémenter la communication TCP, HTTP et UDP. Communication TCP utilisant Node.js Quelques enregistrements de pratique. [Apprentissage recommandé : "Tutoriel Nodejs"]

1. Construire un serveur TCP

1.1.1.1.1.1. un serveur TCP, vous devez d'abord appeler require('net') pour charger le module net, puis appeler la méthode createServer du module net pour créer facilement un serveur TCP. Le format de syntaxe est le suivant :

net.createServer([options][, connectionListener])
options是一个对象参数值，有两个布尔类型的属性allowHalfOpen和pauseOnConnect。这两个属性默认都是false；
connectionListener是一个当客户端与服务端建立连接时的回调函数，这个回调函数以socket端口对象作为参数。

1.2. . Surveiller les connexions client

Utiliser le serveur TCP La méthode d'écoute peut commencer à surveiller la connexion du client. Le format de syntaxe est le suivant :

server.listen(port[, host][, backlog][, callback]);
port：为需要监听的端口号，参数值为0的时候将随机分配一个端口号；
host：服务器地址；
backlog：连接等待队列的最大长度；
callback：回调函数。

Le code suivant peut créer un serveur TCP et écouter le port 8001 :

//引入net模块
const net = require('net');
//创建TCP服务器
const server = net.createServer(function (socket) {
    console.log('有新的客户端接入');
});
//设置监听端口
server.listen(8001, function () {
    console.log('服务正在监听中。。。')
});

Exécuter. ce code, vous pouvez voir la fonction de rappel qui exécute la méthode d'écoute sur la console, comme indiqué dans l'image :

Vous pouvez utiliser le client TCP ou l'outil de débogage correspondant pour vous connecter à ce serveur TCP créé. Par exemple, si vous souhaitez utiliser Windows Telnet, vous pouvez utiliser la commande suivante pour vous connecter :

telnet localhost 8001

Une fois la connexion réussie, vous pouvez voir que la console imprime les mots « Nouvel accès client », indiquant que la fonction de rappel de la méthode createServer a été exécutée, indiquant qu'elle a été connectée avec succès au serveur TCP créé. La méthode

server.listen() déclenche en fait l'événement d'écoute sous le serveur, vous pouvez donc également surveiller manuellement l'événement d'écoute. Le code est le suivant :

//设置监听端口
server.listen(8001);
//设置监听时的回调函数
server.on('listening', function () {
    console.log("服务正在监听中。。。")
});

En plus de l'événement d'écoute, le serveur TCP également. prend en charge les événements suivants :

connection：当有新的链接创建时触发，回调函数的参数为socket连接对象。
close：TCP服务器关闭的时候触发，回调函数没有参数。
error：TCP服务器发生错误的时候触发，回调函数的参数为error对象。

Le code suivant utilise la classe net.Server pour créer un serveur TCP et ajouter les événements ci-dessus :

//引入net模块
const net = require('net');
//实例化一个服务器对象
const server = new net.Server();
//监听connection事件
server.on('connection', function (socket) {
    console.log('有新的客户端接入');
});
//设置监听端口
server.listen(8001);
//设置监听时的回调函数
server.on('listening', function () {
    console.log('服务正在监听中。。。');
});
//设置关闭时的回调函数
server.on('close', function () {
    console.log('服务已关闭');
});
//设置出错时的回调函数
server.on('error', function (err) {
    console.log('服务运行异常', err);
});

1.3. Vérifiez l'adresse que le serveur écoute

Après la création. un serveur TCP, vous pouvez utiliser la méthode server.address(). Vérifiez l'adresse surveillée par le serveur TCP et renvoyez un objet JSON. Étant donné que cette méthode renvoie les informations d'adresse surveillées par le serveur TCP, elle doit être appelée lorsque le serveur. La méthode Listen() est appelée ou la fonction de rappel en cas d'écoute est liée à la méthode. Les attributs de cet objet sont :

port：TCP服务器监听的端口号；
family：说明TCP服务器监听的地址是IPv6还是IPv4；
address：TCP服务器监听的地址。

Le code est le suivant :

//引入net模块
const net = require('net');
//创建TCP服务器
const server = net.createServer(function (socket) {
    console.log('有新的客户端接入');
});
//设置监听端口
server.listen(8001);
//设置监听时的回调函数
server.on('listening', function () {
    //获取地址信息
    let address = server.address();
    //获取地址详细信息
    console.log("服务器监听的端口是：" + address.port);
    console.log("服务器监听的地址是：" + address.address);
    console.log("服务器监听的地址类型是：" + address.family);
});

Le résultat d'exécution est le suivant :

1.4. Le nombre de clients connectés au serveur

Après avoir créé un Serveur TCP, vous pouvez utiliser la méthode server.getConnections () pour obtenir le nombre de clients connectés à ce serveur TCP. Cette méthode est une méthode asynchrone. La fonction de rappel a deux paramètres :

第一个参数为error对象。
第二个参数为连接TCP服务器的客户端数量。

En plus d'obtenir le nombre de connexions, vous pouvez également définir le nombre maximum de connexions pour ce serveur TCP en définissant l'attribut maxConnections du serveur TCP. Lorsque le nombre de connexions dépasse le nombre maximum de connexions, le serveur rejettera les nouvelles connexions. Le code suivant définit le nombre maximum de connexions pour ce serveur TCP à 3.

//引入net模块
const net = require('net');
//创建TCP服务器
const server = net.createServer(function (socket) {
    console.log('有新的客户端接入');
    //设置最大连接数量
    server.maxConnections = 3;
    server.getConnections(function (err, count) {
        console.log("当前连接的客户端个数为：" + count);
    });
});
//设置监听端口
server.listen(8001, function () {
    console.log("服务正在监听中。。。")
});

Exécutez ce code et essayez de vous connecter avec plusieurs clients. On constate que lorsque le nombre de connexions client dépasse 3, les nouveaux clients ne peuvent pas se connecter au serveur, comme le montre la figure :

1.5 Récupérer les données envoyées par le client

méthode createServer. Le paramètre de la fonction de rappel est un objet net.Socket (l'objet port sur lequel le serveur écoute). Cet objet possède également une méthode adresse(), qui est utilisée pour obtenir l'adresse liée au serveur TCP. Il renvoie également un objet contenant. les attributs de port, de famille et d'adresse. Les données de flux envoyées par le client peuvent être obtenues via l'objet socket. L'événement data est déclenché à chaque réception de données. En écoutant cet événement, les données envoyées par le client peuvent être obtenues dans la fonction de rappel. suit :

//引入net模块
const net = require('net');
//创建TCP服务器
const server = net.createServer(function (socket) {
    //监听data事件
    socket.on("data", function (data) {
        //打印数据
        console.log("接收到数据：" + data.toString());
    });
});
//设置监听端口
server.listen(8001, function () {
    console.log("服务正在监听中。。。")
});

Les résultats du test sont les suivants :

En plus des événements de données, l'objet socket a également des événements de connexion, de fin, d'erreur, de délai d'attente et d'autres événements.

1.6. Envoyer des données au client

调用socket.write()可以使TCP服务器发送数据，这个方法只有一个必需参数，就是需要发送的数据；第二个参数为编码格式，可选。同时，可以为这个方法设置一个回调函数。当有用户连接TCP服务器的时候，将发送数据给客户端，代码如下：

//引入net模块
const net = require('net');
//创建TCP服务器
const server = net.createServer(function (socket) {
    //设置消息内容
    const message = "Hello Client......";
    //发送数据
    socket.write(message, function () {
        const writeSize = socket.bytesWritten;
        console.log("数据发送成功，数据长度为：" + writeSize);
    });

    //监听data事件
    socket.on("data", function (data) {
        const readSize = socket.bytesRead;
        //打印数据
        console.log("接收到数据为：" + data.toString(), "；接收的数据长度为：" + readSize);
    });
});
//设置监听端口
server.listen(8001, function () {
    console.log("服务正在监听中。。。")
});

测试结果如下：

在上面这段代码中还用到了socket对象的bytesWritten和bytesRead属性，这两个属性分别代表着发送数据的字节数和接收数据的字节数。除了上面这两个属性外，socket对象还有以下属性：

socket.localPort：本地端口的地址;
socket.localAddress：本地IP地址;
socket.remotePort：进程端口地址;
socket.remoteFamily：进程IP协议族;
socket.remoteAddress：进程IP地址。

2、构建TCP客户端

Node.js在创建一个TCP客户端的时候同样使用的是net（网络）模块。

2.1、使用Node.js创建TCP客户端

为了使用Node.js创建TCP客户端，首先要调用require(‘net’)来加载net模块。创建一个TCP客户端只需要创建一个连接TCP客户端的socket对象即可：

//引入net模块
const net = require('net');
//创建TCP客户端
const client = new net.Socket();

创建一个socket对象的时候可以传入一个json对象。这个对象有以下属性：

fd：指定一个存在的文件描述符，默认值为null；
readable：是否允许在这个socket上读，默认值为false；
writeable：是否允许在这个socket上写，默认值为false；
allowHalfOpen：该属性为false时，TCP服务器接收到客户端发送的一个FIN包后，将会回发一个FIN包；该属性为true时，TCP服务器接收到客户端发送的一个FIN包后不会回发FIN包。

2.2、连接TCP服务器

创建了一个socket对象后，调用socket对象的connect()方法就可以连接一个TCP服务器，代码如下：

//引入net模块
const net = require('net');
//创建TCP客户端
const client = new net.Socket();
//设置连接的服务器
client.connect(8001, '127.0.0.1', function () {
    console.log("连接服务器成功");
});

连接成功如下图所示：

2.3、获取从TCP服务器发送的数据

socket对象有data、error、close、end等事件，因可以通过监听data事件来获取从TCP服务器发送的数据，代码如下：

//引入net模块
const net = require('net');
//创建TCP客户端
const client = new net.Socket();
//设置连接的服务器
client.connect(8001, '127.0.0.1', function () {
    console.log("连接服务器成功");
});
//监听data事件
client.on("data", function (data) {
    //打印数据
    console.log("接收到数据为：" + data.toString());
});

先启动TCP服务端，再运行上面客户端，可以发现命令行中已经输出了来自服务端的数据，说明此时已经实现了服务端和客户端之间的通信：

2.4、向TCP服务器发送数据

因为TCP客户端是一个socket对象，所以可以使用以下代码来向TCP服务器发送数据：

//引入net模块
const net = require('net');
//创建TCP客户端
const client = new net.Socket();
//设置连接的服务器
client.connect(8001, '127.0.0.1', function () {
    console.log("连接服务器成功");
    //给服务端发送数据
    client.write("Hello Server......");
});
//监听data事件
client.on("data", function (data) {
    //打印数据
    console.log("接收到数据为：" + data.toString());
});
//监听end事件
client.on("end", function () {
    console.log("客户端发送数据结束")
});

客户端控制台输出：

服务端控制台输出：

至此使用Node.js进行TCP网络通信完成，如有不对的地方欢迎指正。

原文地址：https://bbs.huaweicloud.com/blogs/300544?utm_source=juejin&utm_medium=bbs-ex&utm_campaign=other&utm_content=content

作者：lwq1228

更多编程相关知识，请访问：编程视频！！

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!