An in-depth analysis of the net module in Nodejs

This article will take you through the net module inNode, I hope it will be helpful to you!

This is the first article in theNodejsseries. When I watched tutorials before, many of them started from IO, buffer, path, event, Let’s start with the fs, process, and node event loop mechanisms. These are indeed the development dependencies that node development mainly depends on. But I am more anxious. From learning about node, it means that node can do the backend, but the first half of these courses are To talk about the capabilities it has, it is the introduction of the module on how to communicate with the client at the end.

I feel very uncomfortable, so when I write my own summary, I must write the module that communicates between the server and the client first. It is comfortable. Even if the knowledge points of event module and fs module are involved in the process, you can put it aside temporarily and only understand how thenetmodule implements communication as a whole.

1. OSI seven-layer protocol model

If you want to learn the communication module, you have to understand the network communication model. If you want to remember the network communication model, you have to practice it to assist memory. This is for the interview Key points. There is a lot of content in this section. I want to understand it in depth, and it also requires systematic study. Here is just a brief mention.

Send this old picture:

For our front-end, we need to remember the system results of the TCP/IP protocol cluster.

• ##Application layer: http (port 80), FTP (21 ), SMTP (send mail), POP (receive mail), DNS

• Transport layer: TCP/ UDP

• Internet layer: IP, ICMP (is an accessory protocol of the IP layer)

• Data link layer: PPP, SLIP

• Physical layer: The network has twisted pair, Coaxial cable, optical fiber and other transmission methods follow the ISO2110 specification

From the

ICMPprotocol that is attached to the IP protocol, we can know that there is no need for layering of network protocols. Too competitive.ICMPObviously needs the IP protocol as the basis, but it is also planned as the network layer. Our correct understanding of the OSI model, I think, should be to use the OSI model to analyze problems rather than using it. The so-called layering of protocols is more meaningful.

TCP/IP protocol cluster does not just refer to TCP and IP protocols, but because these two protocols are too out of the circle, TCP/IP is used. IP collectively refers to the collection of protocols related to the Internet. There is another way of saying it, the collective name for the protocol family used in the process of using the TCP/IP protocol.

And the client and server The transmission flow is as follows

If the roles become

senderandrecipient, the transmission flow is as follows:

It can be seen that during the transmission process, starting from the sending end, the required header information will be added without going through a layer of protocol. Layers of checks and layers of coding. Then it comes to the receiving end When it comes to the end, just do the opposite, peeling off the corresponding header after each layer. Just wait until the last HTTP data is obtained.

The above picture is from "Illustrated HTTP"

The above is the general network protocol model.

Doubt: Why in books and many places after merging the OSI system results into the TCP/IP five-layer protocol, the name of the network layer will become the Internet layer What?

2. TCP connection

First handshake: The client sends the SYN flag to the server (the sequence number is J), and enters the SYN_SENT state (waiting for the server to confirm the state)

Second handshake: The server receives the SYN J from the client, the server will confirm that the data packet has been received and send the ACK flag (the serial number is J 1) and the SYN flag (the serial number is K), and then enters the SYN_REVD state (request acceptance and waiting for client confirmation status)

The third handshake: After the client enters the connection establishment state, The server sends the ACK flag bit (K 1) to confirm that the client has received the established connection. After the server receives the ACK flag, the server enters the connection established state.

J and K are both for Establish who is requesting. There is no difference in the structure of SYN and ACK, but the objects sent are different.

3. net module

net moduleis the specific implementation of the above TCP connection.

First of all, to learn the API, it is still recommended to go directly to theofficial documentation. TheChinese documentationcontent will not be the latest version

When learning, Whenever I have time to read English documents, I try to read English documents. I have insisted on this for half a year. I couldn't stand it at the beginning, but now I can endure the discomfort and read it. The progress has been obvious in half a year. And this kind of Discomfort is a good thing, it means that this is not your comfort zone. After all, the courage to cross your comfort zone is the source of progress

Next, let’s get to the point. Since you want to learn communication, then We need two objects to simulate the client and server. Create two filesclient.jsandservice.jsrespectively. Create them through the command line:

touch client.js && touch service.js

3.1 service.js part

Introduces thenetmodule, and puts the server into theLISTENTstate, and configures the port number and HOST address (manually Skip the DNS resolution process) and wait for the client's call

const net = require("net"); const post = 3306; const host = "127.0.0.1"; const server = net.createServer(); server.listen(post, host);

At this time, the server corresponds to the TCP connection serverLISTENstatus.

Then monitor some necessary events, and It is the hook provided by the server. (Belongs to event-related knowledge)

server.on("listening", () => { console.log("服务器已经可以连接啦"); }); server.on("connection", (socket) => { console.log("有客户端来访咯"); }); server.on("close", () => { console.log("服务器关闭了"); }); server.on("error", (error) => { console.log("服务器出错啦: ", error); // error 有错误的信息 });

The above string of codes involves,

• listening: Events triggered after listening to the port
• connection: The event is triggered when a client visits
• close: The event is triggered when the server is closed
• error: Server error trigger

Forclosewe need to note that the background brother usually directly

ps kill -9 pid

kills the thread.

InconnectionGouzi, the formal parameter is the socket name. Its Chinese translation is a nested word, which is encapsulated into a stream by node. It can be roughly understood as The data sent by the client. This is the data itself has its own method. I processsocketinconnection

server.on("connection", (socket) => { console.log("有客户端来访咯"); socket.on("data", (data) => { console.log(data); // 客户端发送过来的数据 }); });

stream later The article will introduce it.

Since the server can accept the data sent by the client, it can naturally reply to the client. Write insocket.on(of course It can also be written outside):

socket.write("我已经收到你的服务器了哦,客户端");

At this time, if the client has completed accepting the data and then closed the connection. We can also passsocket.on('close')The hook listens to:

socket.on("close", () => { console.log("客户端把另外一头的流给关了"); });

The summary ofsocketevents is put intoclient.js. At this time, all the contents ofservice.jsare as follows:

const net = require("net"); const post = 3306; const host = "127.0.0.1"; const server = net.createServer(); server.listen(post, host); server.on("listening", () => { console.log("服务器已经可以连接啦"); }); server.on("connection", (socket) => { console.log("有客户端来访咯"); socket.on("data", (data) => { console.log(data); // 客户端发送过来的数据 socket.write("我已经收到你的服务器了哦,客户端"); }); socket.on("close", () => { console.log("客户端把另外一头的流给关了"); server.close(); // 客户端已经不要数据了,那么我们就把服务器给关闭了吧 }); }); server.on("close", () => { console.log("服务器关闭了"); }); server.on("error", (error) => { console.log("服务器出错啦: ", error); // error 有错误的信息 });

3.2 client.js part

The client side is much simpler.

const net = require("net"); const post = 3306; const host = "127.0.0.1"; const socket = net.connect(post, host); socket.on("connect", () => { console.log("已经连接到服务器了哦"); }); socket.write("服务器, 我来了"); socket.on("data", (data) => { console.log(data.toString()); socket.end(); }); socket.on("close", () => { console.log("连接已关闭了"); });

Summary of events forsocket

• connect: Triggered by successful connection to the server
• data: Receive parameters sent from the server
• end: Trigger after data reception is completed
• close: Trigger when socket is closed
## The

#service.jsandclient.jsframeworks have been written. Open two terminals and run them:

node service.js node client.js

View the printed results by yourself .

The entire TCP connection framework has been basically completed. Of course, the actual production is far more than that. We also need to deal with sticky packets, unpacking/packaging, heartbeat packets, etc.

This article is reproduced from: https://juejin.cn/post/7084618854801866765

Author: I am Little Orange

For more node-related knowledge, please visit:

nodejs tutorial!

The above is the detailed content of An in-depth analysis of the net module in Nodejs. For more information, please follow other related articles on the PHP Chinese website!