珠峰培训架构2期

1.TCP #

在Node.js中,net模块实现了基于TCP的数据通信

1.1 创建TCP服务器 #

let net = require('net');
function connectionListener(socket){
    console.log('客户端已经链接')
}
net.createServer(options,connectionListener);
--------------或者---------------
server.on('connection',connectionListener);
server.listen(8080,'hostname',function(){
    console.log('服务器开始监听')
});

option.allowHalfOpen默认为false,如果改为true，当TCP服务器接收到客户端发送一个FIN包时不会回发FIN包
connectionListener参数用于指定当客户端与服务器建立连接时所要调用的回调函数，回调中有一个参数socket,指的是TCP服务器监听的socket端口对象

1.2 服务器参数 #

1.2.1 address #

server.address();

port 端口号
address TCP服务器监听的地址
family 协议的版本

1.2.2 connections #

设置最大链接数以及监听客户端的链接数量

server.getConnections((err,count)=>{
    console.log('已经链接'+count+'个用户')
});
server.maxConnections = 2;

1.2.3 close #

使用close方法可以显式拒绝所有的客户端的连接请求,当所有已连接的客户端关闭后服务器会自动关闭,并触发服务器的close事件,只有close方法才会触发close事件

server.close();
server.on('close',callback);

1.2.4 unref&ref #

unref方法指定发客户端连接被全部关闭时退出应用程序

server.unref();

1.3 socket对象 #

net.Socket代表一个socket端口对象，他是一个双工流

1.3.1 address #

获取客户端地址

let net = require('net');
let server = net.createServer(function(socket){
   console.log(socket.address())
});
server.listen(8080);

1.3.2 读取数据 #

let net = require('net');
let server = net.createServer({allowHalfOpen:true},function(socket){
  socket.setEncoding('utf8');
  socket.on('data',function(data){
    console.log(data);
  })
  socket.on('end',function(){
      console.log('客户都按关闭')
  })
});
server.listen(8080)

1.3.3 pipe&unpipe #

pipe方法可以将客户端发送的数据写到文件或其它目标中。

socket.pipe(destinatin,[options]);

options.end 设置为false时当客户端结束写操作或关闭后并不会关闭目标对象，还可以继续写入数据

let net = require('net');
let path = require('path');
let ws = require('fs').createWriteStream(path.resolve(__dirname, 'msg.txt'));
let server = net.createServer(function (socket) {
  socket.on('data', function (data) {
      console.log(data);
  });
  socket.pipe(ws, { end: false });
  socket.on('end', function () {
      ws.end('over', function () {
          socket.unpipe(ws);
      });
  });
});

1.3.4 write #

像客户端写数据

socket.write(data,[encoding],[callback]);

1.3.5 bufferSize #

write的返回值和bufferSize属性值

let net = require('net');
let fs = require('fs');
let path = require('path');
let server = net.createServer({ allowHalfOpen: true }, function (socket) {
    console.log("客户端已经连接");
    socket.setEncoding('utf8');
    let rs = fs.createReadStream(path.resolve(__dirname, '1.txt'), { highWaterMark: 2 });
    rs.on('data', function (data) {
        let flag = socket.write(data);
        console.log("flag:", flag);
        console.log('缓存字节:' + socket.bufferSize);
        console.log('已发送字节:' + socket.bytesWritten);
    })
    socket.on('data', function (data) {
        console.log('data', data);
    });
    socket.on('drain', function (err) {
        console.log("缓存区已全部发送")
    });
});
server.listen('8080')

1.3.6 setTimeout #

let net = require('net');
let path = require('path');
let ws = require('fs').createWriteStream(path.resolve(__dirname, 'msg.txt'));
let server = net.createServer(function (socket) {
    socket.setTimeout(5 * 1000);
    socket.on('timeout', function () {
        socket.end(); // 超时关闭
    });
    //socket.setTimeout(0);取消超时时间的设置
});
server.listen(8080);

1.3.7 pause&&resume #

pause可以暂停data事件触发，服务器会把客户端发送的数据暂存在缓存区里

const net = require('net');
const path = require('path');
let file = require('fs').createWriteStream(path.join(__dirname, 'msg.txt'));
let server = net.createServer(function (socket) {
    socket.pause();
    setTimeout(function () {
        socket.resume();
        socket.pipe(file);
    }, 10 * 1000);
});
server.listen(8080);

1.3.8 keepAlive #

当服务器和客户端建立连接后，当一方主机突然断电、重启、系统崩溃等意外情况时，将来不及向另一方发送FIN包，这样另一方将永远处于连接状态。可以使用setKeepAlive方法来解决这一个问题

socket.setKeepAlive([enaable],[initialDelay]);

enable 是否启用嗅探，为true时会不但向对方发送探测包，没有响应则认为对方已经关闭连接，自己则关闭连接
initialDelay 多久发送一次探测包，单位是毫秒

1.4 TCP客户端 #

1.4.1 创建TCP客户端 #

let socket = new net.Socket(options);
socket.connect(port, host, callback);
----------或者-----------
socket.on('connect', callback);

write表示向服务器写入数据
end 用于结束连接
error 连接发生错误
destroy 销毁流
close 表示连接关闭成功，hasError=true代表有可能有错误

1.5 聊天室1.0 #

let net = require('net');
let clients = {}
let server = net.createServer(function (socket) {
    server.getConnections((err, count) => {
        socket.write(`欢迎你来到聊天室最多容纳${server.maxConnections}人 当前${count}人,请输入用户名\r\n`);
    });
    socket.setEncoding('utf8');
    let nickname;
    socket.on('data', function (data) {
        data = data.replace(/\r\n/,'')
        if(nickname){
            broadcast(nickname,`${nickname}:${data}`);
        }else{
            nickname = data;
            clients[nickname] = socket;
            broadcast(nickname,`欢迎${data}参加聊天室\r\n`)
        }
    });
    socket.on('end', function () {
        console.log('离开聊天室');
        socket.destroy();
        delete clients[nickname]
    });

});
function broadcast(username,content){
    for(let key in  clients){
        if(key !== username){
            clients[key].write(content+'\r\n');
        }
    }
}
server.listen(8080);

1.6 聊天室2.0 #

// 当输入l:时 显示在线用户列表
// n:灰灰
// s:灰灰:内容
// b:群发
// 瞎写 提时命令不存在
let net = require('net');
let clients = {}
let server = net.createServer(function (socket) {
    let key = socket.remoteAddress + socket.remotePort;
    clients[key] = { nickname: '匿名', socket };
    server.getConnections((err, count) => {
        socket.write(`欢迎你来到聊天室最多容纳${server.maxConnections}人 当前${count}人,请输入用户名\r\n`);
    });
    socket.setEncoding('utf8');
    let nickname;
    socket.on('data', function (data) {
        data = data.replace(/\r\n/, '');
        let type = data.split(':')[0];
        console.log(type)
        switch (type) {
            case 'l':
                list(socket);
                break;
            case 'n':
                rename(key, data.split(':')[1])
                break;
            case 's':
                private(data.split(':')[1], data.split(':')[2])
                break;
            case 'b':
                broadcast(key, data.split(':')[1])
                break;
            default:
                socket.write('输入有误\r\n')
        }

    });
    socket.on('end', function () {
        console.log('服务端关闭');
        clients[key].socket.destroy();
        delete clients[key];
    });

});
function list(socket) {
    let users = [];
    Object.keys(clients).forEach(key => {
        users.push(clients[key].nickname);
    });
    socket.write('当前用户列表\r\n:' + users.join('\r\n') + '\r\n');
}
function rename(key, name) {
    clients[key].nickname = name
}
function broadcast(key, content) {
    for (let k in clients) {
        if (key !== k) {
            clients[k].socket.write(content + '\r\n');
        }
    }
}
function private(nickname, content) {
    let socket;
    for (let key in clients) {
        if (clients[key].nickname === nickname) {
            socket = clients[key].socket;
        }
    }
    if (socket) {
        socket.write(content + '\r\n')
    }
}

server.listen(8080);

2.UDP #

2.1 UDP服务端 #

let dgram = require('dgram');
let socket = dgram.createSocket('udp4');
socket.on('message',function(msg,rinfo){
    console.log(msg.toString());
    socket.send('你好',rinfo.port,rinfo.address)
});
socket.bind(41234,'localhost');

2.2 UDP客户端 #

let dgram = require('dgram');
let socket = dgram.createSocket('udp4');
socket.send('珠峰',41234,'localhost',function(err,bytes){
    console.log('send');
});
socket.on('message',function(data){
    console.log(data.toString());
})

附录 #

软件 #

putty https://www.putty.org/
window用户装科来网络分析系统 http://www.colasoft.com.cn/
mac用户装 wireshark https://www.wireshark.org/download.html

telnet #

FF FB 1F FF FB 20 FF FB 18 FF FB 27 FF FD 01 FF FB 03 FF FD 03
FF FB 1F window size
FF FB 20 terminal speed
FF FB 18 terminal type
FF FB 27 Telnet Environment Option
FF FD 01 echo
FF FB 03 suppress go ahead
FF FD 03 suppress go ahead
如果不需要這些, 改用RAW模式就可以了

打开telnet功能 #

打开telnet功能