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》