nodejs的TCP相關的一些筆記

• TCP協議
• 基於nodejs建立TCP服務端
• TCP服務的事件
• TCP報文解析與粘包解決方案

 一、TCP協議

1.1TCP協議原理部分參考： 無連線運輸的UDP、可靠資料傳輸原理、面向連線運輸的TCP

1.2圖解七層協議、TCP三次握手、TCP四次揮手：

 

 二、基於nodejs建立TCP服務端

 2.1建立nodejs的TCP服務例項(server.js)：

const net = require('net');
//建立服務例項
const server = net.createServer();
const PORT = 12306;
const HOST = 'localhost';
//服務啟動對網路資源的監聽
server.listen(PORT, HOST);
//當服務啟動時觸發的事件
server.on('listening', ()=>{
    console.log(`服務已開啟在 ${HOST}: ${PORT}`);
});
//接收訊息，響應訊息
server.on('connection', (socker) => {
    //通過Socket上的data事件接收訊息
    socker.on('data', (chunk) => {//通過Socket上的writer方法回寫響應資料
        const msg = chunk.toString();
        console.log(msg);
        //通過Socket上的writer方法回寫響應資料
        socker.write('您好' + msg);
    });
});
server.on('close', ()=>{
    console.log('服務端關閉了');
});
server.on('error', (err) =>{
    if(err.code === 'EADDRINUSE'){
        console.log('地址正在被使用');
    }else{
        console.log(err);
    }
});

2.2建立nodejs的TCP客戶端例項(client.js)：

const net = require('net');
//建立客戶例項,並與服務端建立連線
const client = net.createConnection({
    port:12306,
    host:'127.0.0.1'
});
//當套位元組與服務端連線成功時觸發connect事件
client.on('connect', () =>{
    client.write('他鄉踏雪');//向服務端傳送資料
});
//使用data事件監聽服務端響應過來的資料
client.on('data', (chunk) => {
    console.log(chunk.toString());
});
client.on('error', (err)=>{
    console.log(err);
});
client.on('close', ()=>{
    console.log('客戶端斷開連線');
});

然後使用nodemon工具啟動服務(如果沒有安裝nodemon工具可以使用npm以管理員身份安裝)，當然也可以直接使用node指令啟動，使用nodemon的好處就是當你修改程式碼儲存後它會監聽檔案的變化自動重啟服務：

nodemon .\server.js

[nodemon] 2.0.15
[nodemon] to restart at any time, enter `rs`
[nodemon] watching path(s): *.*
[nodemon] watching extensions: js,mjs,json
[nodemon] starting `node .\server.js`
服務已開啟在 localhost: 12306

然後接著使用nodemon工具啟動客戶端程式，建立客戶端例項連線伺服器併傳送TCP訊息：

nodemon .\client.js

[nodemon] 2.0.15
[nodemon] to restart at any time, enter `rs`
[nodemon] watching path(s): *.*
[nodemon] watching extensions: js,mjs,json
[nodemon] starting `node .\client.js`
您好他鄉踏雪

服務端接收到訊息以後並在訊息前新增“您好”後返回該訊息，服務端的控制檯會先列印一下內容：

他鄉踏雪

以上就是一個簡單的TCP服務與客戶端的互動示例，除了使用nodemon啟動服務和客戶端以外，還可以使用系統的telnet工具在控制檯上測試連線服務，你的系統可能預設沒有啟動這個程式，telnet相關使用可以參考這裡：https://baijiahao.baidu.com/s?id=1723367561977342393&wfr=spider&for=pc

2.3TCP服務的事件：

在前面的示例程式碼中已經有了TCP事件相關API的應用程式碼，這裡針對這些事件做一些概念性的介紹：

通過net.createServer()建立的服務，它是一個EventEmitter例項，這個示例負責啟動nodejs底層TCP模組對網路資源的監聽。在這個例項內部還會管理一個Socket例項，它是一個雙工流(關於雙工流點選參考)例項，Socket例項負責接收和響應具體的TCP資料。

net.createServer()上的事件：

listening:呼叫server.listen()繫結埠或者Domain Socket後觸發。
connection:每個客戶端套位元組連線到伺服器時觸發，其回撥函式會接收到一個Socket例項作為引數。
close:當伺服器關閉時觸發，在呼叫server.close()後，伺服器將停止接收新的套位元組連線，但保持當前存在的連線，等待所有連線斷開後，會觸發該事件。
error:當伺服器發生異常時，將會觸發該事件。

連線事件，也就是Socket例項上的事件，這個事件對應tream例項上的事件，因為Socket本身就是基於雙工流構造的。

data:當一端呼叫write()方法傳送資料時，另一端會觸發data事件，事件傳遞的資料即是write()傳送的資料。
end:當連線中的任意一段傳送了FIN資料時，將會觸發該事件。
connect:該事件用於客戶端，當套位元組與伺服器連線成功後會觸發。
drain:當任意一端呼叫write()傳送資料時，當前端會觸發該事件。
error:當異常發生時，觸發該事件。
close:當套位元組完全關閉時，觸發該事件。
timeout:當一定事件後連線不在活躍時，該事件將會觸發，通知使用者當前連線已經被閒置。

 三、TCP報文解析與粘包解決方案

由於TCP針對網路中小資料包有一定的優化策略：Nagle演算法。

如果每次傳送一個很小的資料包，比如一個位元組內容的資料包而不優化，就會導致網路中只有極少數有效資料的資料包，這會導致浪費大量的網路資源。Nagle演算法針對這種情況，要求快取區的資料達到一定資料量或者一定時間後才將其發出，所以資料包將會被Nagle演算法合併，以此來優化網路。這種優化雖然提高了網路頻寬的效率，但有的資料可能會被延遲傳送。

在Nodejs中，由於TCP預設啟動Nagle演算法，可以呼叫socket.setNoDelay(ture)去掉Nagle演算法，使得write()可以立即傳送資料到網路中。但需要注意的是，儘管在網路的一端呼叫write()會觸發另一端的data事件，但是並不是每次write()都會觸發另一端的data事件，再關閉Nagle演算法後，接收端可能會將接收到的多個小資料包合併，然後只觸發一次data事件。也就是說socket.setNoDelay(ture)只能解決一端的資料粘包問題。

使用第二節中的client.js示例程式碼來測試資料粘包問題：

//在客戶端的connect事件回撥中通過多個write()傳送資料，它可能會將多次write()寫入的資料一次發出
client.on('connect', () =>{
    client.write('他鄉踏雪');//向服務端傳送資料
    client.write('他鄉踏雪1');
    client.write('他鄉踏雪2');
    client.write('他鄉踏雪3');
});

我的測試結果是在服務端和客戶端都出現了粘包問題：

3.1解決粘包問題的簡單粗暴的方案：

將多次write()傳送的資料，通過定時器延時傳送，這個延時超過Nagle演算法優化合並的時間就可以解決粘包的問題。比如上面的示例程式碼可以修改成下面這樣：

let dataArr = ["他鄉踏雪","他鄉踏雪","他鄉踏雪"];
//當套位元組與服務端連線成功時觸發connect事件
client.on('connect', () =>{
    client.write('他鄉踏雪');//向服務端傳送資料
    for(let i = 0; i< dataArr.length; i++){
        (function(data, index){
            setTimeout(()=>{
                client.write(data);
            },1000 * i);
        })(dataArr[i], i);
    }
});

上面這種方案會導致網路連線的資源長時間被佔用，使用者體驗上也會大打折扣，這顯然不是一個合理的方案。

3.2通過拆包封包的方式解決資料粘包的問題分析：

通過前面的示例和對TCP資料傳輸機制雙工流的可以瞭解，TCP粘包的問題就是資料的可寫流因為Nagle演算法的優化，不會按照傳送端的write()的寫入對應觸發接收端的data事件，它可能導致資料傳輸出現以下兩種情況：

傳送端多次write()的資料可能被打包成一個資料包傳送到接收端。
傳送端通過write()一次寫入的資料可能因為Nagle演算法的優化被截斷到兩個資料包中。

TCP的資料傳輸雖然可能會出現以上兩種問題，但由於它是基於流的傳輸機制，那麼它的資料順序在傳輸過程中是確定的先進先出原則。所以，可以通過在每次write()在資料頭部新增一些標識，將每次write()傳輸的資料間隔開，然後在接收端基於這些間隔資料的標識將資料拆分或合併。

基於定長的訊息頭頭和不定長的訊息體，封包拆包實現資料在流中的標識：

訊息頭：也就是間隔資料的標識，採用定長的方式就可以實現有規律的獲取這些資料標識。訊息頭中包括訊息系列號、訊息長度。
訊息體：要傳輸的資料本身。

封包與拆包的工具模組具體實現(MyTransform.js)：

class MyTransformCode{
    constructor(){
        this.packageHeaderLen = 4;  //設定定長的訊息頭位元組長度
        this.serialNum = 0;         //訊息序列號
        this.serialLen = 2;         //訊息頭中每個資料佔用的位元組長度（序列號、訊息長度值）
    }
    //編碼
    encode(data, serialNum){    //data:當前write()實際要傳輸的資料； serialNum:當前訊息的編號
        const body = Buffer.from(data);//將要傳輸的資料轉換成二進位制
        //01 先按照指定的長度來申請一片記憶體空間作為訊息頭header來使用
        const headerBuf = Buffer.alloc(this.packageHeaderLen);
        //02寫入包的頭部資料
        headerBuf.writeInt16BE(serialNum || this.serialNum);//將當前訊息編號以16進位制寫入
        headerBuf.writeInt16BE(body.length, this.serialLen);//將當前write()寫入的資料的二進位制長度作為訊息的長度寫入
        if(serialNum === undefined){
            this.serialNum ++;  //如果沒有傳入指定的序列號，表示在最佳寫入，訊息序列號+1
        }
        return Buffer.concat([headerBuf, body]);//將訊息頭和訊息體合併成一個Buffer返回，交給TCP傳送端
    }
    //解碼
    decode(buffer){
        const headerBuf = buffer.slice(0, this.packageHeaderLen);   //獲取訊息頭的二進位制資料
        const bodyBuf = buffer.slice(this.packageHeaderLen);        //獲取訊息體的二進位制資料
        return {
            serialNum:headerBuf.readInt16BE(),
            bodyLength:headerBuf.readInt16BE(this.serialLen),
            body:bodyBuf.toString()
        };
    }
    //獲取資料包長度的方法
    getPackageLen(buffer){
        if(buffer.length < this.packageHeaderLen){
            return 0;   //當資料長度小於資料包頭部的長度時，說明它的資料是不完整的，返回0表示資料還沒有完全傳輸到接收端
        }else{
            return this.packageHeaderLen + buffer.readInt16BE(this.serialLen);  //資料包頭部長度+加上資料包訊息體的長度(從資料包的頭部資料中獲取)，就是資料包的實際長度
        }
    }
}
module.exports = MyTransformCode;

測試自定義封包工具的編碼、解碼：

let tf = new MyTransformCode();
let str = "他鄉踏雪";
let buf = tf.encode(str);       //編碼
console.log(tf.decode(buf));    //解碼
console.log(tf.getPackageLen(buf)); //獲取資料包位元組長度
//測試結果
{ serialNum: 0, bodyLength: 12, body: '他鄉踏雪' }
16

3.3應用封包拆包工具MyTransform實現解決TCP的粘包問題：

服務端示例程式碼：

//應用封包解決TCP粘包問題服務端
const net = require('net');
const MyTransform = require('./myTransform.js');
const server = net.createServer();  //建立服務例項
let overageBuffer = null;           //快取每一次data傳輸過來不完整的資料包，等待一下次data事件觸發時與chunk合併處理
let tsf = new MyTransform();
server.listen('12306', 'localhost');
server.on('listening',()=>{
    console.log('服務端執行在 localhost:12306');
});
server.on('connection', (socket)=>{
    socket.on('data', (chunk)=>{
        if(overageBuffer && overageBuffer.length > 0){
            chunk = Buffer.concat([overageBuffer, chunk]);  //如果上一次data有未不完成的資料包的資料片段，合併到這次chunk前面一起處理
        }
        while(tsf.getPackageLen(chunk) && tsf.getPackageLen(chunk) <= chunk.length){   //如果接收到的資料中第一個資料包是完整的，進入迴圈體對資料進行拆包處理
            let packageLen = tsf.getPackageLen(chunk);  //用於快取接收到的資料中第一個包的位元組長度
            const packageCon = chunk.slice(0, packageLen);  //擷取接收到的資料的第一個資料包的資料
            chunk = chunk.slice(packageLen);    //擷取除第一個資料包剩餘的資料，用於下一輪迴圈或下一次data事件處理
            const ret = tsf.decode(packageCon); //解碼當前資料中第一個資料包
            console.log(ret);
            socket.write(tsf.encode(ret.body, ret.serialNum));  //講解碼的資料包再次封包傳送回客戶端
        };
        overageBuffer = chunk;  //快取不完整的資料包，等待下一次data事件接收到資料後一起處理
    });
});

客戶端示例程式碼：

//應用封包解決TCP粘包問題客戶端
const net = require('net');
const MyTransform = require('./myTransform.js');
let overageBuffer = null;
let tsf = new MyTransform();
const client = net.createConnection({
    host:'localhost',
    port:12306
});
client.write(tsf.encode("他鄉踏雪1"));
client.write(tsf.encode("他鄉踏雪2"));
client.write(tsf.encode("他鄉踏雪3"));
client.write(tsf.encode("他鄉踏雪4"));
client.on('data', (chunk)=>{
    if(overageBuffer && overageBuffer.length > 0){
        chunk = Buffer.concat([overageBuffer, chunk]);  ////如果上一次data有未不完成的資料包的資料片段，合併到這次chunk前面一起處理
    }
    while(tsf.getPackageLen(chunk) && tsf.getPackageLen(chunk) <= chunk.length){    //如果接收到的資料中第一個資料包是完整的，進入迴圈體對資料進行拆包處理
        let packageLen = tsf.getPackageLen(chunk);  //用於快取接收到的資料中第一個包的位元組長度
        const packageCon = chunk.slice(0, packageLen); //擷取接收到的資料的第一個資料包的資料
        chunk = chunk.slice(packageLen);    //擷取除第一個資料包剩餘的資料，用於下一輪迴圈或下一次data事件處理
        const ret = tsf.decode(packageCon); //解碼當前資料中第一個資料包
        console.log(ret);
    };
    overageBuffer = chunk;  //快取不完整的資料包，等待下一次data事件接收到資料後一起處理
});

測試效果：

基於流的資料傳輸總是先進先出的佇列傳輸原則，所以每一次資料的前面固定幾個位元組的資料都是資料中的第一個包的頭部資料，所以就可以通過MyTransform工具中的getPackageLen(buffer)獲取到第一個資料包的資料長度，基於這樣一個原則就可以準確的判斷出當前的資料中是否有完整的資料包，如果有就將這個資料包拆分出來，迴圈這一操作就可以將所有資料全部完整的實現資料拆分，解決TCP的Nagle演算法導致到粘包和不完整資料包的問題。