一、npm模块安装与管理
npm模块管理 第三方模块
1.node.js生态里的第三方模块可以通过npm工具来安装使用.
2.npm安装node.js模块:
npm install 本地安装, 运行npm目录/node_modules
也就是你项目目录下的node_modules
npm install -g全局安装 安装到系统的node_modules
全局安装就是要你 install 后面加一个-g 表示全局
3.nodejs第三方模块安装分为两种
(1)本地安装:安装好后第三方模块代码全部打包到本地项目中来
这时候,把这个项目发给别人,别人就不需要再次安装这个模块了.
缺点是:你本地每一个新项目 都要重新安装到项目里才行.
(2)全局安装:安装完了后,以后你所有的项目都可以使用,方便开发.
他的缺点是,因为他是全局的是放在你系统下面,这时候别人使用
你的代码的时候,还需要手动再去安装这个模块.
在全局安装一个websocket模块
安装好会输出版本 和 安装路劲 默认路劲就是这个
我们就可以找到这个模块了,这个目录就是NODE_PATH指定的路劲
装好了之后,就是全局的了,所有的项目都能使用这个模块
本地安装ws模块,本地安装是在运行npm目录/node_modules
比如说我的项目在这个目录下 D:/nodejs/myserver
所以本地安装的话,就会把模块放到这个项目目录下的node_modules
在这个文件夹下面安装shitf+鼠标右键 在此处打开命令窗口
这样我们就能直接在这运行npm了
安装
成功
但是他会提示你一个小错误,就是没有package_json 说明包
他会生成一个类似说明文件的东西.
只需要你 在命令行输入 nmp init 只需要使用一次即可
这时候输入项目名称
版本
描述
入口函数 默认index.js
测试命令 跳过
跳过
关键字
作者
然后这个文件就创建成功了,
当你再次使用npm安装模块的时候,就不会有错误了
4.在项目中导入和使用模块require
(1)require项目文件.js代码.json文本,.node二进制文件必须使用
绝对路劲(/)或者相对路劲(./,../);只有文件才能使用路劲
但是如果你是引入模块,一定不能使用路劲,模块不加路劲.
比如要使用websocket模块. 这样才能正确导入.
var ws = require("ws"); //正确的导入模块
(2)没有写后缀名的require项目文件,依次加载:.js,.json,.node
或者你可以直接使用后缀名 require("abc.js")
(3)如果没有以绝对路劲开头或相对路劲开头的 就是加载模块.
a):系统模块去查找能否找到NODE_PATH,如果有这个模块就用
这个目录下的模块.
b):如果系统没有,再到当前这个项目目录下的./node_modules目录下
查找,
c):如果这里没有,他返回上一级文件夹查找node_modules,
因为你的node_modules放在第一级,而你的代码文件放在第4
级的文件下,所以就需要这中方法去查找.
二、websocket模块的使用
Websocket
1.websocket是一种通讯协议,底层是tcp socket,基于TCP
它加入了字节的协议用来传输数据
2.是h5为了上层方便使用socket而产生的
3.发送数据带着长度信息,避免粘包问题,其底层已经处理了这个过程
4.客户端/服务器向事件驱动一样的编写代码,不用来考虑
底层复杂的事件模型。
握手协议过程
服务器首先解析客户端发送的报文
红色的那个就是客户端发过来的随机Key,就是要得到这个key
解析好之后,就要给客户端回报文
把那个key解析出来之后,要加上一个固定migic字符串
然后通过SHA-A加密,在通过base-64加密发送给客户端,
这时候就完成了握手协议.
接收/发送数据协议.
1.比如你客户端要发送一个HELLO,他发送的时候把这个字符串
每个字符转成ASCLL码, 并且他不是直接发送出去.
(1)固定字节(1000 0001或1000 0010)0x81 0x82
(2)包长度字节,总共8个位,第一位固定是1,剩下7位得到整数(0-127)
125以内直接表示长度,如果126那就后面两个字节表示长度,
127后面8个字节表示数据长度.
(3)mask掩码 是包长后面4个字节
(4)数据 在mask掩码之后的就是需要的数据了.
得到这个数据的方法,就是拿掩码第一个字节和第一个数据做
位异或(xor)运算,第二个掩码字节和第二个数据运算,以此类推
第五个数据字节,又和第一个掩码字节做运算.
WS模块
这个模块已经封装好了底层的这些处理流程,很方便的就可以使用了
服务端的编写:
首先开启websocket服务器
connection事件:有客户连接建立
error事件:监听错误
headers事件:握手协议的时候,回给客户端的字符串
客户端成功完成握手后的事件: 用客户端通讯的sock绑定
message事件:接收到数据
close事件:关闭事件
error事件:错误事件
发送数据:send
//加载模块 var ws = require("ws"); //开启基于websocket的服务器 //监听客户端的连接 var server = new ws.Server({ host: "127.0.0.1", port: 8005, }); //给客户端添加监听事件的函数 function ws_add_listener(c_sock){ //close事件 c_sock.on("close",function(){ console.log("client close"); }); //error c_sock.on("error",function(errs){ console.log("client error",errs); }); //message事件 c_sock.on("message",function(data){ //data是解包好的原始数据 //就是websocket协议解码开来的原始数据 console.log(data); c_sock.send("你好,成功连接啦"); }); } //connection事件:有客户端接入 function on_server_client_comming(client_sock){ console.log("wsClient连接"); //给这个客户端socket绑定事件,就能收到信息啦 ws_add_listener(client_sock); //回给客户端一个信息 } //绑定事件 server.on("connection",on_server_client_comming); //error事件:监听错误 function on_server_listen_error(err){ console.log("错误",err); } server.on("error",on_server_listen_error); //headers事件:拿到握手连接回给客户端的字符 function on_server_headers(data){ //console.log(data); } server.on("headers",on_server_headers);
客户端编写:
open事件:连接握手成功
error事件:当连接发生错误的时候调用
message事件:当有数据进来的时候调用
close事件:当有数据进来的时候调用
message事件:data已经是根据websocket协议解码出来的原始数据,
websocket底层有数据包的封包协议,所以,决定不会出现粘包的情况
每解一个数据包,就会触发一个message事件
//加载模块 var ws = require("ws"); //创建连接 会发生握手过程 //首先创建一个客户端socket,然后让 //这个客户端去连接服务器的socket //url地址 以ws:// 开头 var sock = new ws("ws://127.0.0.1:8005"); //open事件:连接握手成功 function on_client_connimg_success(){ console.log("connect success!!!"); //连接成功就向服务器发送数据 sock.send("HelloWebSocket"); //发送几个就服务器就收到几个不出现粘包现象 //因为你每次发送的时候,底层会进行封包 sock.send("HHno你好是是是sadsa"); } sock.on("open",on_client_connimg_success); //error事件 function on_client_error(err){ console.log("error",err); } sock.on("error",on_client_error); //close关闭事件 function on_client_close(){ console.log("close"); } sock.on("close",on_client_close); //message收到数据的事件 function on_client_recv_message(data){ console.log(data); } sock.on("message",on_client_recv_message);
在浏览器脚本里面使用websocket
三、TCP通讯拆包和封包 以及粘包处理
TCP粘包问题
1在通讯过程中,我们可能有发送很多数据包,数据包A
数据包B,C此时我们期望依次收到数据包A,B,C,但是TCP
底层为了传送性能,可能会把ABC所有的数据一起传过来,
这时候可能收到的就是A+B+C,这时候上层的程序根本就无法
区分A,B,C这个叫做--粘包。
2.产生粘包的原因有两种:1发送方造成 2接收放造成
(1)发送方引起粘包是由TCP协议本身造成的,TCP为了提高传输效率,
发送方往往要收集足够的数据才发送一包数据,若连续几次发送的数据
都很少,通常TCP会根据优化算法把这些数据合成一包后一次发送出去,
这样接收方就收到了粘包的数据
(2)接收方引起粘包是由于接收方用户进程不及时接收数据.从而导致粘包现象,
这是因为接收方先把收到的数据放在系统接收缓冲区,用户进程从缓冲区读取
数据,若下一包数据到达时,前一包数据尚未被用户进程取走,则下一包数据
放到系统接收缓冲区时就接到前一包数据之后,而用户进程再次读取缓冲区数据.
这样就造成一次读取多个包的数据.
3.比如说我要发送3个命令:hello, new ,alloc,使用tcp发送后
收到的数据可能就是hellonewalloc粘在一起了,
包体协议
1.处理粘包的办法:在处理的时候,对所有要发送的数据进行封包,
建立一个封包规则,解包也使用这个规则,比如说:前面两个字节数据长度,
后面是数据, 这时候即使他们粘包了,客户端收到这个数据,
通过拆包,就可以解开所有的包. 客户端收到包只需要得到前面的长度,
就可以知道第一个包有多长, 这样多余的包就是粘住的包了.
2.打入长度信息或者加特定的结尾符都是解决粘包的办法.
size+body, 一般用于二进制数据
body+\r\n结尾符 一般用于Json
3.处理过程中会出现集中情况:
(1)收到的刚好是1一个包或n个完整包
(2)收到1.5个包,也就是还有1半还没收到,那半个包就要保存起来
(3)收到不足一个包,这个包要直接保存起来,等下一次接收.
封包 获取长度 模拟粘包 分包
var netpkg = { //根据封包协议读取包体长度 offset是从哪开始读 read_pkg_size: function(pkgdata,offset){ if(offset > pkgdata.length - 2){ //剩下的长度从开始读位置,都不足两个字节 //没有办法获取长度信息 return -1; } //这里就是读取两个字节的长度 //使用小尾来读取出来 无符号两个字节 var len = pkgdata.readUInt16LE(offset); return len; }, //把要发送的数据封包,两个字节长度+数据 package_string: function(data){ var buf = Buffer.allocUnsafe(2+data.length); //前面小尾法写入两个字节长度 buf.writeInt16LE(2 + data.length, 0); //填充这个buff value string|Buffer|Integer //offset填充buf的位置,默认0 //end结束填充buf的位置,模式buf.length //encoding如果value是字符串,则是字符编码utf8 buf.fill(data,2); //返回封好的包 console.log(buf); return buf; }, //模拟粘包 test_pkg_two_action:function(action1,action2){ //如果有两个命令 var buf = Buffer.allocUnsafe(2 + 2+action1.length+action2.length); buf.writeInt16LE(2+action1.length,0); buf.fill(action1,2); //把第二个包粘在一起 var offset = 2 + action1.length; buf.writeInt16LE(2 + action2.length,offset); buf.fill(action2,offset+2); console.log("模拟粘包",buf); return buf; }, //模拟一个数据包 分两次发送 test_pkg_slice: function(pkg1,pkg2){ var buf1 = Buffer.allocUnsafe(2 + pkg1.length); //写入长度信息 因为他们是同一个包 buf1.writeInt16LE(2+pkg1.length + pkg2.length,0); buf1.fill(pkg1,2); console.log("buf1 = ",buf1); //剩下的包 var buf2 = Buffer.allocUnsafe(pkg2.length); buf2.fill(pkg2,0); //将这两个包作为数组返回 return [buf1,buf2]; } }; module.exports = netpkg;
服务器接收部分
//引入net模块 var net = require("net"); var netpkg = require("./netpak"); //全局变量记录多余的包 var last_pkg = null; var server = net.createServer((client_sock)=>{ console.log("client comming"); }); console.log("开始等待客户端连接"); server.listen({ host: "127.0.0.1", //host: 'localhost', port: 6800, exclusive: true, }); server.on("listening",function(){ console.log("start listening ..."); }); server.on("connection",function(client_sock){ console.log("新的链接建立了"); console.log(client_sock.remoteAddress, client_sock.remotePort); //绑定 客户端socket 关闭 事件 client_sock.on("close",function(){ console.log("客户端关闭连接"); }); client_sock.on("data",function(data){ if(last_pkg != null){ //到这里表示有没处理完的包 //把这个包和收到的包合并 var buf = Buffer.concat([last_pkg,data], last_pkg.length + data.length); last_pkg = buf; }else{ //如果没有要处理的 直接获取data last_pkg = data; } //开始读长度的位置 var offset = 0; //读取长度信息 var pkg_len = netpkg.read_pkg_size(last_pkg,offset); if(pkg_len < 0 ){ //没有读到长度信息 return; } console.log("数据内容:",last_pkg); //可能有多个包,offset是包开始的索引 //如果他加上包读到的长度 小与等于 //说明last_pkg这里面有一个数据包的 //因为你长度是5 数据包长度是10 //这个5就是我们读到一个包的长度,说明他 //就是有一个完整的包,在这就可以读取了 while(offset + pkg_len <= last_pkg.length){ //根据长度信息来读取数据 //假设传过来的是文本数据 //这个包就是offset 到 pkg_len的内容 //申请一段内存 减2 因为他包含了长度信息 var c_buf = Buffer.allocUnsafe(pkg_len - 2); console.log("包长",pkg_len); console.log("收到数据长度",last_pkg.length); //使用copy函数来拷贝到这个c_buf last_pkg.copy(c_buf,0,offset+2,offset+pkg_len); console.log("recv cmd:",c_buf); console.log(c_buf.toString("utf8")); //起始位置跳过这个包 offset += pkg_len; if(offset >= last_pkg.length){ //正好这个包处理完成 console.log("正好处理完成"); break; } //到这里说明还有未处理的包 再次读取长度信息 pkg_len = netpkg.read_pkg_size(last_pkg,offset); console.log("粘包长度",pkg_len); console.log("ofsett:",offset); if(pkg_len < 0) {//没有读到长度信息 break; } } //如果只有半个包左右的数据 if(offset >= last_pkg.length){ //这里表示所有的数据处理完成 console.log("完整包"); last_pkg = null; offset = 0; }else{ //如果没有处理完 //将其实位置 到length的数据 拿到 //也就是offset反正就是一个包的起始位置 console.log(">>>>>>>>>不足一个包,等待下次接收"); console.log(last_pkg); var buf = Buffer.allocUnsafe(last_pkg.length- offset); //把剩余的数据从offset开始复制到buf,长度是所有 last_pkg.copy(buf,0,offset,last_pkg.length); last_pkg = buf; } }); //监听错误事件 通讯可能会出错 client_sock.on("error",function(e){ console.log("error",e); }); }); //绑定错误事件 server.on("error",function(){ console.log("listener err"); }); //绑定关闭事件 server.on("close",function(){ //服务器关闭 如果还有链接存在,直到所有连接关闭 //这个事件才会被触发 console.log("server stop listener"); });
测试客户端
//引入net模块 var net = require("net"); var netpkg = require("./netpak"); var c_sock = net.connect({ port:6800, host:"127.0.0.1", },()=>{ console.log("connected to server!"); }); c_sock.on("connect",function(){ console.log("connect success!"); //发送3个包 c_sock.write(netpkg.package_string("Hello")); c_sock.write(netpkg.package_string("starte")); c_sock.write(netpkg.package_string("end")); c_sock.write(netpkg.package_string("starte")); c_sock.write(netpkg.package_string("end")); //发送一个粘包数据 模拟粘包 c_sock.write(netpkg.test_pkg_two_action("AAAA","BBBB")); var buf_set = netpkg.test_pkg_slice("ABC","DEF"); console.log("模拟分包",buf_set); //发送一半 c_sock.write(buf_set[0]); //间隔一点时间 5秒后再次发送 剩余的包 setTimeout(function(){ c_sock.write(buf_set[1]); },5000); }); //绑定错误事件 c_sock.on("error",function(err){ console.log("错误"+err); }); //绑定关闭事件 c_sock.on("close",function(){ console.log("关闭socket"); }); c_sock.setEncoding("utf-8"); //接受数据的事件 c_sock.on("data",function(data){ console.log("收到数据",data); });
转载于:https://blog.51cto.com/12158490/2068658