let head = new Buffer(4);
let jsonStr = JSON.stringify(json);
let body = new Buffer(jsonStr);
//超過一字節(jié)的大端寫入
head.writeInt32BE(body.byteLength, 0);
let buffer = Buffer.concat([head, body]);

let dataReadStart = 0; //新數據的起始位置
let dataLength = buffer.length; // 要拷貝數據的長度
let availableLen = _bufferLength - _dataLen; // 緩沖區(qū)剩余可用空間

// buffer剩余空間不足夠存儲本次數據
if (availableLen < dataLength) {
 let newLength = Math.ceil((_dataLen + dataLength) / _bufferLength) * _bufferLength;
 let _tempBuffer = Buffer.alloc(newLength);
 
 // 將舊數據復制到新buffer并且修正相關參數
 if (_writePointer < _readPointer) { // 數據存儲在舊buffer的尾部+頭部的順序
  let dataTailLen = _bufferLength - _readPointer;
  _buffer.copy(_tempBuffer, 0, _readPointer, _readPointer + dataTailLen);
  _buffer.copy(_tempBuffer, dataTailLen, 0, _writePointer);
 } else { // 數據是按照順序進行的完整存儲
  _buffer.copy(_tempBuffer, 0, _readPointer, _writePointer);
 }
 _bufferLength = newLength;
 _buffer = _tempBuffer;
 _tempBuffer = null;
 _readPointer = 0;
 _writePointer = _dataLen;

 //存儲新到來的buffer
 buffer.copy(_buffer, _writePointer, dataReadStart, dataReadStart + dataLength);
 _dataLen += dataLength;
 _writePointer += dataLength;

} else if (_writePointer + dataLength > _bufferLength) {
// 空間夠用情況下，但是數據會沖破緩沖區(qū)尾部，部分存到緩沖區(qū)舊數據后，一部分存到緩沖區(qū)開始位置
 // 緩沖區(qū)尾部剩余空間的長度
 let bufferTailLength = _bufferLength - _writePointer;

 // 數據尾部位置
 let dataEndPosition = dataReadStart + bufferTailLength;
 buffer.copy(_buffer, _writePointer, dataReadStart, dataEndPosition);

 // data剩余未拷貝進緩存的長度
 let restDataLen = dataLength - bufferTailLength;
 buffer.copy(_buffer, 0, dataEndPosition, dataLength);

 _dataLen = _dataLen + dataLength;
 _writePointer = restDataLen

} else { // 剩余空間足夠存儲數據，直接拷貝數據到緩沖區(qū)
 buffer.copy(_buffer, _writePointer, dataReadStart, dataReadStart + dataLength);
 _dataLen = _dataLen + dataLength;
 _writePointer = _writePointer + dataLength
}

let _dataHeadLen = 4;
timer && clearInterval(timer);
timer = setInterval(()=>{
 // 緩沖區(qū)數據不夠解析出包頭
 if (_dataLen < _dataHeadLen) {
  console.log('數據長度小于包頭規(guī)定長度，等待數據......')
  clearInterval(timer);
 }
 // 解析包頭長度
 // 尾部最后剩余可讀字節(jié)長度
 let restDataLen = _bufferLength - _readPointer;
 let dataLen = 0;
 let headBuffer = Buffer.alloc(_dataHeadLen);
 // 數據包為分段存儲，不能直接解析出包頭，先拼接
 if (restDataLen < _dataHeadLen) {
  // 取出第一部分頭部字節(jié)
  _buffer.copy(headBuffer, 0, _readPointer, _bufferLength)
  // 取出第二部分頭部字節(jié)
  let unReadHeadLen = _dataHeadLen - restDataLen;
  _buffer.copy(headBuffer, restDataLen, 0, unReadHeadLen)
  dataLen = headBuffer.readUInt32BE(0);

 } else {
  _buffer.copy(headBuffer, 0, _readPointer, _readPointer + _dataHeadLen);
  dataLen = headBuffer.readUInt32BE(0);;
 }

 // 數據長度不夠讀取，直接返回
 if (_dataLen - _dataHeadLen < dataLen) {
  log.info("緩沖區(qū)已有body數據長度小于包頭定義body的長度，等待數據......")
  clearInterval(timer);

 } else { // 數據夠讀，讀取數據包 
  let package = Buffer.alloc(dataLen);
  // 數據是分段存儲，需要分兩次讀取
  if (_bufferLength - _readPointer < dataLen) {
   let firstPartLen = _bufferLength - _readPointer;
   // 讀取第一部分，直接到字符尾部的數據
   _buffer.copy(package, 0, _readPointer, firstPartLen + _readPointer);
   // 讀取第二部分，存儲在開頭的數據
   let secondPartLen = dataLen - firstPartLen;
   _buffer.copy(package, firstPartLen, 0, secondPartLen);
   _readPointer = secondPartLen; //更新可讀起點

  } else { // 直接讀取數據
   _buffer.copy(package, 0, _readPointer, _readPointer + dataLen);
   _readPointer += dataLen; //更新可讀起點
  }

  _dataLen -= readData.length; //更新數據長度
  // 已經讀取完所有數據
  if (_readPointer === _writePointer) {
   clearInterval(timer)
  }

  //開始解包
  callback(package);
   
 }
}, 50);

let headBytes = 4;
let head = new Buffer(headBytes);
buffer.copy(head, 0, 0, headBytes);
let dataLen = head.readUInt32BE();
const body = new Buffer(dataLen);
buffer.copy(body, 0, headBytes, headBytes + dataLen)

let content = null;
try {
 const str = body.toString('utf-8');
 if(str === ''){
  content = null;
 }else{
  content = JSON.parse(body);
 }
} catch (e) {
 log.error('head指定body長度有問題')
}
//傳遞給業(yè)務層
callback(content);