单工通信

一方只是发送，一方只是接收

  1. const net = require('net');
  3. const socket = new net.Socket({});
  5. socket.connect({
  6.     host: '127.0.0.1',
  7.     port: 4000
  8. })
  10. socket.write('good morning geekbang');
  1. const net = require('net');
  3. const server = net.createServer((socket)=> {
  4.     socket.on('data', function(buffer) {
  5.         console.log(buffer, buffer.toString())
  6.     })
  7. });
  9. server.listen(4000);

半双工通信

既可以发送也可以接收，但是同一时刻通信中只有一种行为

  1. const net = require('net');
  3. // 创建socket
  4. const socket = new net.Socket({});
  6. // 连接服务器
  7. socket.connect({
  8.     host: '127.0.0.1',
  9.     port: 4000
  10. });
  13. const lessonids = [
  14.     "136797",
  15.     "136798",
  16.     "136799",
  17.     "136800"
  18. ]
  20. let id = Math.floor(Math.random() * lessonids.length);
  22. // 往服务器传数据
  23. socket.write(encode(id));
  25. socket.on('data', (buffer) => {
  26.     console.log(buffer.toString())
  28.     // 接收到数据之后，按照半双工通信的逻辑，马上开始下一次请求
  29.     id = Math.floor(Math.random() * lessonids.length);
  30.     socket.write(encode(id));
  31. })
  33. // 把编码请求包的逻辑封装为一个函数
  34. function encode(index) {
  35.     buffer = Buffer.alloc(4);
  36.     buffer.writeInt32BE(
  37.         lessonids[index]
  38.     );
  39.     return buffer;
  40. }
  1. const net = require('net');
  3. // 创建tcp服务器
  4. const server = net.createServer((socket) => {
  6.     socket.on('data', function(buffer) {
  7.         // 从传来的buffer里读出一个int32
  8.         const lessonid = buffer.readInt32BE();
  10.         // 50毫秒后回写数据
  11.         setTimeout(()=> {
  12.             socket.write(
  13.                 Buffer.from(data[lessonid])
  14.             );
  15.         }, 50)
  16.     })
  18. });
  20. // 监听端口启动服务
  21. server.listen(4000);
  23. const data = {
  24.     136797: "01 | 课程介绍",
  25.     136798: "02 | 内容综述",
  26.     136799: "03 | Node.js是什么？",
  27.     136800: "04 | Node.js可以用来做什么？",
  29. }

全双工通信

同时发送和接收

  1. const net = require('net');
  3. const socket = new net.Socket({});
  5. socket.connect({
  6.     host: '127.0.0.1',
  7.     port: 4000
  8. });
  10. let id = Math.floor(Math.random() * LESSON_IDS.length);
  12. let oldBuffer = null;
  13. socket.on('data', (buffer) => {
  14.     // 把上一次data事件使用残余的buffer接上来
  15.     if (oldBuffer) {
  16.         buffer = Buffer.concat([oldBuffer, buffer]);
  17.     }
  18.     let completeLength = 0;
  20.     // 只要还存在可以解成完整包的包长
  21.     while (completeLength = checkComplete(buffer)) {
  22.         const package = buffer.slice(0, completeLength);
  23.         buffer = buffer.slice(completeLength);
  25.         // 把这个包解成数据和seq
  26.         const result = decode(package);
  27.         console.log(`包${result.seq}，返回值是${result.data}`);
  28.     }
  30.     // 把残余的buffer记下来
  31.     oldBuffer = buffer;
  32. })
  35. let seq = 0;
  36. /**
  37.  * 二进制包编码函数
  38.  * 在一段rpc调用里，客户端需要经常编码rpc调用时，业务数据的请求包
  39.  */
  40. function encode(data) {
  41.     // 正常情况下，这里应该是使用 protobuf 来encode一段代表业务数据的数据包
  42.     // 为了不要混淆重点，这个例子比较简单，就直接把课程id转buffer发送
  43.     const body = Buffer.alloc(4);
  44.     body.writeInt32BE(LESSON_IDS[data.id]);
  46.     // 一般来说，一个rpc调用的数据包会分为定长的包头和不定长的包体两部分
  47.     // 包头的作用就是用来记载包的序号和包的长度，以实现全双工通信
  48.     const header = Buffer.alloc(6);
  49.     header.writeInt16BE(seq)
  50.     header.writeInt32BE(body.length, 2);
  52.     // 包头和包体拼起来发送
  53.     const buffer = Buffer.concat([header, body])
  55.     console.log(`包${seq}传输的课程id为${LESSON_IDS[data.id]}`);
  56.     seq++;
  57.     return buffer;
  58. }
  60. /**
  61.  * 二进制包解码函数
  62.  * 在一段rpc调用里，客户端需要经常解码rpc调用时，业务数据的返回包
  63.  */
  64. function decode(buffer) {
  65.     const header = buffer.slice(0, 6);
  66.     const seq = header.readInt16BE();
  68.     const body = buffer.slice(6)
  70.     return {
  71.         seq,
  72.         data: body.toString()
  73.     }
  74. }
  76. /**
  77.  * 检查一段buffer是不是一个完整的数据包。
  78.  * 具体逻辑是：判断header的bodyLength字段，看看这段buffer是不是长于header和body的总长
  79.  * 如果是，则返回这个包长，意味着这个请求包是完整的。
  80.  * 如果不是，则返回0，意味着包还没接收完
  81.  * @param {} buffer 
  82.  */
  83. function checkComplete(buffer) {
  84.     if (buffer.length < 6) {
  85.         return 0;
  86.     }
  87.     const bodyLength = buffer.readInt32BE(2);
  88.     return 6 + bodyLength
  89. }
  92. for (let k = 0; k < 100; k++) {
  93.     id = Math.floor(Math.random() * LESSON_IDS.length);
  94.     socket.write(encode({ id }));
  95. }
  98. const LESSON_IDS = [
  99.     "136797",
  100.     "136798",
  101.     "136799",
  102.     "136800",
  103.     "136801",
  104.     "136803",
  105.     "136804",
  106.     "136806",
  107.     "136807",
  108.     "136808",
  109.     "136809",
  110.     "141994",
  111.     "143517",
  112.     "143557",
  113.     "143564",
  114.     "143644",
  115.     "146470",
  116.     "146569",
  117.     "146582"
  118. ]
  1. const net = require('net');
  3. const server = net.createServer((socket) => {
  5.     let oldBuffer = null;
  6.     socket.on('data', function (buffer) {
  7.         // 把上一次data事件使用残余的buffer接上来
  8.         if (oldBuffer) {
  9.             buffer = Buffer.concat([oldBuffer, buffer]);
  10.         }
  12.         let packageLength = 0;
  13.         // 只要还存在可以解成完整包的包长
  14.         while (packageLength = checkComplete(buffer)) {
  15.             const package = buffer.slice(0, packageLength);
  16.             buffer = buffer.slice(packageLength);
  18.             // 把这个包解成数据和seq
  19.             const result = decode(package);
  21.             // 计算得到要返回的结果，并write返回
  22.             socket.write(
  23.                 encode(LESSON_DATA[result.data], result.seq)
  24.             );
  25.         }
  27.         // 把残余的buffer记下来
  28.         oldBuffer = buffer;
  29.     })
  31. });
  33. server.listen(4000);
  35. /**
  36.  * 二进制包编码函数
  37.  * 在一段rpc调用里，服务端需要经常编码rpc调用时，业务数据的返回包
  38.  */
  39. function encode(data, seq) {
  40.     // 正常情况下，这里应该是使用 protobuf 来encode一段代表业务数据的数据包
  41.     // 为了不要混淆重点，这个例子比较简单，就直接把课程标题转buffer返回
  42.     const body = Buffer.from(data)
  44.     // 一般来说，一个rpc调用的数据包会分为定长的包头和不定长的包体两部分
  45.     // 包头的作用就是用来记载包的序号和包的长度，以实现全双工通信
  46.     const header = Buffer.alloc(6);
  47.     header.writeInt16BE(seq)
  48.     header.writeInt32BE(body.length, 2);
  50.     const buffer = Buffer.concat([header, body])
  52.     return buffer;
  53. }
  55. /**
  56.  * 二进制包解码函数
  57.  * 在一段rpc调用里，服务端需要经常解码rpc调用时，业务数据的请求包
  58.  */
  59. function decode(buffer) {
  60.     const header = buffer.slice(0, 6);
  61.     const seq = header.readInt16BE();
  63.     // 正常情况下，这里应该是使用 protobuf 来decode一段代表业务数据的数据包
  64.     // 为了不要混淆重点，这个例子比较简单，就直接读一个Int32即可
  65.     const body = buffer.slice(6).readInt32BE()
  67.     // 这里把seq和数据返回出去
  68.     return {
  69.         seq,
  70.         data: body
  71.     }
  72. }
  74. /**
  75.  * 检查一段buffer是不是一个完整的数据包。
  76.  * 具体逻辑是：判断header的bodyLength字段，看看这段buffer是不是长于header和body的总长
  77.  * 如果是，则返回这个包长，意味着这个请求包是完整的。
  78.  * 如果不是，则返回0，意味着包还没接收完
  79.  * @param {} buffer 
  80.  */
  81. function checkComplete(buffer) {
  82.     if (buffer.length < 6) {
  83.         return 0;
  84.     }
  85.     const bodyLength = buffer.readInt32BE(2);
  86.     return 6 + bodyLength
  87. }
  89. // 假数据
  90. const LESSON_DATA = {
  91.     136797: "01 | 课程介绍",
  92.     136798: "02 | 内容综述",
  93.     136799: "03 | Node.js是什么？",
  94.     136800: "04 | Node.js可以用来做什么？",
  95.     136801: "05 | 课程实战项目介绍",
  96.     136803: "06 | 什么是技术预研？",
  97.     136804: "07 | Node.js开发环境安装",
  98.     136806: "08 | 第一个Node.js程序：石头剪刀布游戏",
  99.     136807: "09 | 模块：CommonJS规范",
  100.     136808: "10 | 模块：使用模块规范改造石头剪刀布游戏",
  101.     136809: "11 | 模块：npm",
  102.     141994: "12 | 模块：Node.js内置模块",
  103.     143517: "13 | 异步：非阻塞I/O",
  104.     143557: "14 | 异步：异步编程之callback",
  105.     143564: "15 | 异步：事件循环",
  106.     143644: "16 | 异步：异步编程之Promise",
  107.     146470: "17 | 异步：异步编程之async/await",
  108.     146569: "18 | HTTP：什么是HTTP服务器？",
  109.     146582: "19 | HTTP：简单实现一个HTTP服务器"
  110. }