Node學習記錄：網絡編程

筆記 | Linux網絡基礎

網絡分層

而在實際操做系統中，只有應用層、傳輸層、網絡層，鏈路層。

Node提供了net、dgram、http、https四個模塊，分別處理TCP、UDP、HTTP、HTTPS.適用於服務器和客戶端。

TCP

httpcode

code	說明
200	請求被成功處理
301/302	永久性重定向/臨時性重定向
403	沒有權限訪問
404	表示沒有對應資源
401（未受權）	請求要求身份驗證。對於登陸後請求的網頁，服務器可能返回此響應(如知乎這種須要登陸才能查看的)
500	服務器錯誤
503	服務器停機或正在維護

傳輸控制協議
在OSI模型（物理層、數據鏈結層、網絡層、傳輸層、會話層、表示層、應用層）中屬於傳輸層協議
TCP是面向鏈接的協議，在傳輸以前須要三次握手造成會話。

戳這裏看詳解

建立TCP服務器

var net = require('net');

var server = net.createServer( function (socket) {
  

  //新的鏈接
  socket.on('data', function (data) {
    socket.write("您好")
  });
  
  socket.on('end', function () {
    console.log('鏈接斷開')
  });

  socket.write("實例: \n");
});

server.listen(8124, function () {
  console.log('server bound');
});

經過net模塊自行構造客戶端進行會話，測試上面構建的TCP服務的代碼以下:

var net = require('net');
var client = net.connect({port:8124}, function () {
  //'connect' listener
  console.log('client connected');
  client.write('world !\r\n');
});

client.on('data'， function (data) {
console.log(data.String());
client.end();
});

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

以上客戶端代碼存爲client.js並執行

$ node client.js

client connected

實例：

您好
client disconnected

UDP

用戶數據包協議，與TCP同樣同屬於網絡傳輸層。UDP不是面向鏈接的。DNS服務基於它實現。

建立UDP服務端

var dgram = require ('dgram');
var server = dgram.createSocket("udp4");

server.on ("message", function (msg, rinfo) {
  console.log("server got:" + msg + "from" + rinfo.address + ":" + rinfo.port);
});

server.on("listening", function () {
  var address =server.address();
  console.log("server listening" + address.address + ":" + address.port);
});

server.bind(41234);

建立UDP客戶端

var dgram = require('dgram');
var message = new Buffer ("Node.js")
var client = dgram.createSocket("udp4");

client.send(message, 0, message.length, 41234, "localhost", function (err, bytes) {
  client.close();
});

保存爲client.js並執行，服務器端的命令行將會以下輸出

$ node client.js
server listening 0.0.0.0:41234
server got: Node.js from 127.0.0.1:58682

與TCP套接字的Write()相比，send()方法的參數列表相對複雜，可是它更靈活的地方在於能夠隨意發送數據到網絡中的服務器端，而TCP若是要發送數據給另外一個服務器端，則須要從新經過套接字構造新的鏈接。

HTTP

TCP與UDP都是屬於網絡傳輸層協議，若是要構建高效的網絡應用，就應該從傳輸層進行着手。
Node提供了基本的http和https模塊用於HTTP和HTTPS的封裝，對於其餘應用層協議（SMTP、IMAP等等）也能從社區找到實現。
實現HTTP服務器：

var http = require('http');
http.createServer( function (req, res) {
  res.wirteHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
}).listen(1337,'127.0.0.1');
console.log("Server running at http://127.0.0.1:1337/ ")

儘管這個小服務器只能回覆Hello World,可是它能維持併發量和QPS都是可觀的。

HTTP報文

HTTP全稱超文本傳輸協議，它構建在TCP之上屬於應用層協議，HTTP的兩端是服務器和瀏覽器（B/S模式）

http模塊

關於http模塊的一些實例 能夠戳這裏

Serving HTML Page

var http = require('http');
var fs = require('fs');

var server = http.createServer(function(req, res) {
    console.log('request was made: ' + req.url);
    res.writeHead(200,{'Content-Type': 'text/html'});
    var myReadStream = fs.createReadStream(__dirname + '/index.html','utf8');
    myReadStream.pipe(res);
});

server.listen(3000,'127.0.0.1');
console.log('now listening to port 3000');

Serving JSON data

ar http = require('http');
var fs = require('fs');

var server = http.createServer(function(req, res) {
    console.log('request was made: ' + req.url);
    res.writeHead(200,{'Content-Type': 'application/json'});
    var myObj = {
        name: 'AlexZ33',
        job: "Engineer",
        age: '26'
    }
    res.end(JSON.stringify(myObj)); //end()括號內是string 或者buffer，因此咱們不能直接用myObj這個對象，要轉換
});

server.listen(3000,'127.0.0.1');
console.log('now listening to port 3000');

HTTPS 和 HTTP2

HTTP/2

net.Socket

net.Socket 是一個雙工的流（duplex stream）

// net.d.ts

 class Socket extends stream.Duplex {
        constructor(options?: SocketConstructorOpts);

        // Extended base methods
        write(buffer: Buffer | Uint8Array | string, cb?: (err?: Error) => void): boolean;
        write(str: Buffer | Uint8Array | string, encoding?: string, cb?: (err?: Error) => void): boolean;

        connect(options: SocketConnectOpts, connectionListener?: () => void): this;
        connect(port: number, host: string, connectionListener?: () => void): this;
        connect(port: number, connectionListener?: () => void): this;
        connect(path: string, connectionListener?: () => void): this;

        setEncoding(encoding?: string): this;
        pause(): this;
        resume(): this;
        setTimeout(timeout: number, callback?: () => void): this;
        setNoDelay(noDelay?: boolean): this;
        setKeepAlive(enable?: boolean, initialDelay?: number): this;
        address(): AddressInfo | string;
        unref(): void;
        ref(): void;

        readonly bufferSize: number;
        readonly bytesRead: number;
        readonly bytesWritten: number;
        readonly connecting: boolean;
        readonly destroyed: boolean;
        readonly localAddress: string;
        readonly localPort: number;
        readonly remoteAddress?: string;
        readonly remoteFamily?: string;
        readonly remotePort?: number;

        // Extended base methods
        end(cb?: () => void): void;
        end(buffer: Buffer | Uint8Array | string, cb?: () => void): void;
        end(str: Buffer | Uint8Array | string, encoding?: string, cb?: () => void): void;

        /**
         * events.EventEmitter
         *   1. close
         *   2. connect
         *   3. data
         *   4. drain
         *   5. end
         *   6. error
         *   7. lookup
         *   8. timeout
         */
        addListener(event: string, listener: (...args: any[]) => void): this;
        addListener(event: "close", listener: (had_error: boolean) => void): this;
        addListener(event: "connect", listener: () => void): this;
        addListener(event: "data", listener: (data: Buffer) => void): this;
        addListener(event: "drain", listener: () => void): this;
        addListener(event: "end", listener: () => void): this;
        addListener(event: "error", listener: (err: Error) => void): this;
        addListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
        addListener(event: "timeout", listener: () => void): this;

        emit(event: string | symbol, ...args: any[]): boolean;
        emit(event: "close", had_error: boolean): boolean;
        emit(event: "connect"): boolean;
        emit(event: "data", data: Buffer): boolean;
        emit(event: "drain"): boolean;
        emit(event: "end"): boolean;
        emit(event: "error", err: Error): boolean;
        emit(event: "lookup", err: Error, address: string, family: string | number, host: string): boolean;
        emit(event: "timeout"): boolean;

        on(event: string, listener: (...args: any[]) => void): this;
        on(event: "close", listener: (had_error: boolean) => void): this;
        on(event: "connect", listener: () => void): this;
        on(event: "data", listener: (data: Buffer) => void): this;
        on(event: "drain", listener: () => void): this;
        on(event: "end", listener: () => void): this;
        on(event: "error", listener: (err: Error) => void): this;
        on(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
        on(event: "timeout", listener: () => void): this;

        once(event: string, listener: (...args: any[]) => void): this;
        once(event: "close", listener: (had_error: boolean) => void): this;
        once(event: "connect", listener: () => void): this;
        once(event: "data", listener: (data: Buffer) => void): this;
        once(event: "drain", listener: () => void): this;
        once(event: "end", listener: () => void): this;
        once(event: "error", listener: (err: Error) => void): this;
        once(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
        once(event: "timeout", listener: () => void): this;

        prependListener(event: string, listener: (...args: any[]) => void): this;
        prependListener(event: "close", listener: (had_error: boolean) => void): this;
        prependListener(event: "connect", listener: () => void): this;
        prependListener(event: "data", listener: (data: Buffer) => void): this;
        prependListener(event: "drain", listener: () => void): this;
        prependListener(event: "end", listener: () => void): this;
        prependListener(event: "error", listener: (err: Error) => void): this;
        prependListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
        prependListener(event: "timeout", listener: () => void): this;

        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
        prependOnceListener(event: "close", listener: (had_error: boolean) => void): this;
        prependOnceListener(event: "connect", listener: () => void): this;
        prependOnceListener(event: "data", listener: (data: Buffer) => void): this;
        prependOnceListener(event: "drain", listener: () => void): this;
        prependOnceListener(event: "end", listener: () => void): this;
        prependOnceListener(event: "error", listener: (err: Error) => void): this;
        prependOnceListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
        prependOnceListener(event: "timeout", listener: () => void): this;
    }

net.Server

參考

Node.js知識點詳解（二）HTTP模塊與事件模塊
Anatomy of an HTTP Transaction 《nodejs 深刻淺出》 《圖解HTTP》