RPC调用
和ajax相同点
第一个相同点：总之都是两个设备之间到调用
1. ajax是浏览器到服务器
2. rpc是服务器到服务器
第二个相同点：需要双方约定一种数据格式
和ajax不同点
第一点：
1. ajax使用dns做为寻址服务到
2. rpc一般是在内网寻址
第二点：
1. ajax应用层使用http（html/json）
2. rpc通信到时候一般会使用二进制协议，性能优势
第三点
rcp是基于tcp或udp协议通信
寻址/负载均衡
ajax寻址过程是拿域名去dns进行解析，然后在发起真正请求
rpc发起网络请求之前也是需要进行寻址到，因为不一定会使用ip进行请求，
可能会使用id（l5，vip）之类的统一标识符，拿这个id去寻址服务器解析，然后通过返回的ip发起真正的请求
TCP通信
单工通信：
永远只能是一端往另一端发送数据（client -- server）
半双工通信：
双方都可以发数据，但同一时间内只有一端可以发送数据，也可以理解为‘轮番单工通信’
全双工通信：
在client发送数据的时候，server也可以发送数据
二进制协议
. 更小的数据包体积
. 更快的编码速度
rpc [0001 0000 1111 0101]
Node.js Buffer编解码二进制数据包
buffer模块介绍
创建buffer的三种方式：
1. Buffer.alloc
2. Buffer.from
3. Buffer.allocUnsafe
// from方法表示通过现有的数据结构创建一个buffer
const buffer1 = Buffer.from('test');
const buffer2 = Buffer.from([1, 2, 3]);
// alloc方法表示通过指定长度创建一个buffer·
const buffer3 = Buffer.alloc(10);
console.log(buffer1); // <Buffer 74 65 73 74>
console.log(buffer2); // <Buffer 01 02 03>
console.log(buffer3); // <Buffer 00 00 00 00 00 00 00 00 00 00>
Buffer.allocUnsafe:该方法会涉及buffer模块的内存管理机制
buffer写入的方法：
const buffer2 = Buffer.from([1, 2, 3]);
buffer2.writeInt8(12, 0)
console.log(buffer2); // <Buffer 0c 02 03>
buffer2.writeInt16BE(512, 1)
console.log(buffer2);
// <Buffer 0c 02 00> BE/LE的区别是 高位和地位的排布顺序，请仔细观察该行和下面的结果区别
buffer2.writeInt16LE(512, 1)
console.log(buffer2); // <Buffer 0c 00 02> 00 02 和上面 02 00
使用BE/LE的原因在于不同设备会使用不同标准，具体要使用什么参数需要跟后台协商
可以达到类似JSON.stringfly这样简单的操作，不需要像上面那样麻烦的写二进制
https://github.com/protocolbuffers/protobuf
这个兼容了前端情况，所以没有上面那个好
// test.proto
message Test {
required float num = 1;
required string payload = 2;
}
// index.js
const fs = require('fs');
const protobuf = require('protocol-buffers');
const schema = protobuf(fs.readFileSync(__dirname + '/test.proto', 'utf-8'));
console.log(schema)
// Messages {
// Test: {
// type: 2,
// message: true,
// name: 'Test',
// buffer: true,
// encode: [Function: encode] { bytes: 0 },
// decode: [Function: decode] { bytes: 0 },
// encodingLength: [Function: encodingLength],
// dependencies: [ [Object], [Object] ]
// }
// }
const buffer = schema.Test.encode({
num: 2,
payload: 'test'
})
console.log(buffer) // <Buffer 0d 00 00 00 40 12 04 74 65 73 74>
console.log(schema.Test.decode(buffer)) // { num: 2, payload: 'test' }
Node.js net建立多路复用的rpc通道
net模块
net模块类似http模块、比较简单
既然是通道，就会有两端，这里我们用clinet和server来代表
单工通信案例
半双工通信案例
全双工通信
- server.js
const net = require('net');
const server = net.createServer((socket) => {
let oldBuffer = null;
socket.on('data', function (buffer) {
// 把上一次data事件使用残余的buffer接上来
if (oldBuffer) {
buffer = Buffer.concat([oldBuffer, buffer]);
}
let packageLength = 0;
// 只要还存在可以解成完整包的包长
while (packageLength = checkComplete(buffer)) {
const package = buffer.slice(0, packageLength);
buffer = buffer.slice(packageLength);
// 把这个包解成数据和seq
const result = decode(package);
// 计算得到要返回的结果，并write返回
socket.write(
encode(LESSON_DATA[result.data], result.seq)
);
}
// 把残余的buffer记下来
oldBuffer = buffer;
})
});
server.listen(4000);
/**
* 二进制包编码函数
* 在一段rpc调用里，服务端需要经常编码rpc调用时，业务数据的返回包
*/
function encode(data, seq) {
// 正常情况下，这里应该是使用 protobuf 来encode一段代表业务数据的数据包
// 为了不要混淆重点，这个例子比较简单，就直接把课程标题转buffer返回
const body = Buffer.from(data)
// 一般来说，一个rpc调用的数据包会分为定长的包头和不定长的包体两部分
// 包头的作用就是用来记载包的序号和包的长度，以实现全双工通信
const header = Buffer.alloc(6);
header.writeInt16BE(seq)
header.writeInt32BE(body.length, 2);
const buffer = Buffer.concat([header, body])
return buffer;
}
/**
* 二进制包解码函数
* 在一段rpc调用里，服务端需要经常解码rpc调用时，业务数据的请求包
*/
function decode(buffer) {
const header = buffer.slice(0, 6);
const seq = header.readInt16BE();
// 正常情况下，这里应该是使用 protobuf 来decode一段代表业务数据的数据包
// 为了不要混淆重点，这个例子比较简单，就直接读一个Int32即可
const body = buffer.slice(6).readInt32BE()
// 这里把seq和数据返回出去
return {
seq,
data: body
}
}
/**
* 检查一段buffer是不是一个完整的数据包。
* 具体逻辑是：判断header的bodyLength字段，看看这段buffer是不是长于header和body的总长
* 如果是，则返回这个包长，意味着这个请求包是完整的。
* 如果不是，则返回0，意味着包还没接收完
* @param {} buffer
*/
function checkComplete(buffer) {
if (buffer.length < 6) {
return 0;
}
const bodyLength = buffer.readInt32BE(2);
return 6 + bodyLength
}
// 假数据
const LESSON_DATA = {
136797: "01 | 课程介绍",
136798: "02 | 内容综述",
136799: "03 | Node.js是什么？",
136800: "04 | Node.js可以用来做什么？",
136801: "05 | 课程实战项目介绍",
136803: "06 | 什么是技术预研？",
136804: "07 | Node.js开发环境安装",
136806: "08 | 第一个Node.js程序：石头剪刀布游戏",
136807: "09 | 模块：CommonJS规范",
136808: "10 | 模块：使用模块规范改造石头剪刀布游戏",
136809: "11 | 模块：npm",
141994: "12 | 模块：Node.js内置模块",
143517: "13 | 异步：非阻塞I/O",
143557: "14 | 异步：异步编程之callback",
143564: "15 | 异步：事件循环",
143644: "16 | 异步：异步编程之Promise",
146470: "17 | 异步：异步编程之async/await",
146569: "18 | HTTP：什么是HTTP服务器？",
146582: "19 | HTTP：简单实现一个HTTP服务器"
}
- client.js
const net = require('net');
const socket = new net.Socket({});
socket.connect({
host: '127.0.0.1',
port: 4000
});
const LESSON_IDS = [
"136797",
"136798",
"136799",
"136800",
"136801",
"136803",
"136804",
"136806",
"136807",
"136808",
"136809",
"141994",
"143517",
"143557",
"143564",
"143644",
"146470",
"146569",
"146582"
]
let id = Math.floor(Math.random() * LESSON_IDS.length);
let oldBuffer = null;
socket.on('data', (buffer) => {
// 把上一次data事件使用残余的buffer接上来
if (oldBuffer) {
buffer = Buffer.concat([oldBuffer, buffer]);
}
let completeLength = 0;
// 只要还存在可以解成完整包的包长
while (completeLength = checkComplete(buffer)) {
const package = buffer.slice(0, completeLength);
buffer = buffer.slice(completeLength);
// 把这个包解成数据和seq
const result = decode(package);
console.log(`包${result.seq}，返回值是${result.data}`);
}
// 把残余的buffer记下来
oldBuffer = buffer;
})
let seq = 0;
/**
* 二进制包编码函数
* 在一段rpc调用里，客户端需要经常编码rpc调用时，业务数据的请求包
*/
function encode(data) {
// 正常情况下，这里应该是使用 protobuf 来encode一段代表业务数据的数据包
// 为了不要混淆重点，这个例子比较简单，就直接把课程id转buffer发送
const body = Buffer.alloc(4);
body.writeInt32BE(LESSON_IDS[data.id]);
// 一般来说，一个rpc调用的数据包会分为定长的包头和不定长的包体两部分
// 包头的作用就是用来记载包的序号和包的长度，以实现全双工通信
const header = Buffer.alloc(6);
header.writeInt16BE(seq)
header.writeInt32BE(body.length, 2);
// 包头和包体拼起来发送
const buffer = Buffer.concat([header, body])
console.log(`包${seq}传输的课程id为${LESSON_IDS[data.id]}`);
seq++;
return buffer;
}
/**
* 二进制包解码函数
* 在一段rpc调用里，客户端需要经常解码rpc调用时，业务数据的返回包
*/
function decode(buffer) {
const header = buffer.slice(0, 6);
const seq = header.readInt16BE();
const body = buffer.slice(6)
return {
seq,
data: body.toString()
}
}
/**
* 检查一段buffer是不是一个完整的数据包。
* 具体逻辑是：判断header的bodyLength字段，看看这段buffer是不是长于header和body的总长
* 如果是，则返回这个包长，意味着这个请求包是完整的。
* 如果不是，则返回0，意味着包还没接收完
* @param {} buffer
*/
function checkComplete(buffer) {
if (buffer.length < 6) {
return 0;
}
const bodyLength = buffer.readInt32BE(2);
return 6 + bodyLength
}
for (let k = 0; k < 100; k++) {
id = Math.floor(Math.random() * LESSON_IDS.length);
socket.write(encode({ id }));
}
