如何避免Socket消息被截断？解析parseMessage函数实现

Ah, the classic Socket message truncation/sticking problem! The parseMessage function you shared is already using the industry-standard length prefix approach to solve this—let me flesh it out fully and break down how it works, step by step.

Complete Working Code #

First, let's fix and expand the partial code you provided to handle edge cases properly:

const winston = require('winston'); // Assume winston is already configured for logging

function parseMessage(buff) {
  const parsedMessages = [];
  let currentOffset = 0;
  const lengthPrefixSize = 4; // 4 bytes for UInt32 (supports messages up to ~4GB)
  let doneProcessing = false;

  while (!doneProcessing) {
    // Check if we have enough bytes left to read the length prefix
    if (currentOffset + lengthPrefixSize > buff.length) {
      doneProcessing = true;
      break;
    }

    // Read the message length (using Big-Endian for cross-platform compatibility)
    const messageLength = buff.readUIntBE(currentOffset, lengthPrefixSize);

    // Check if we have enough bytes left to read the full message body
    if (currentOffset + lengthPrefixSize + messageLength > buff.length) {
      doneProcessing = true;
      break;
    }

    // Extract and parse the message body
    const messageBuffer = buff.slice(
      currentOffset + lengthPrefixSize,
      currentOffset + lengthPrefixSize + messageLength
    );
    const messageString = messageBuffer.toString('utf8');
    currentOffset += lengthPrefixSize + messageLength;

    try {
      const parsedMsg = JSON.parse(messageString);
      if (parsedMsg && typeof parsedMsg === 'object') {
        parsedMessages.push(parsedMsg);
      }
    } catch (err) {
      winston.error('Failed to parse message:', err);
      winston.error('Raw problematic message:', messageString);
    }

    // Exit loop if we've processed all bytes in the buffer
    if (currentOffset >= buff.length) {
      doneProcessing = true;
    }
  }

  // Return parsed messages + unprocessed buffer (for next data chunk)
  return {
    parsedMessages,
    remainingBuffer: buff.slice(currentOffset)
  };
}

How This Solves Truncation/Sticking #

The core idea here is prefixing every message with its exact byte length—this lets the receiver know exactly how many bytes to read for a complete message, eliminating guesswork that causes truncation or merging of messages.

Key Implementation Details #

• Buffer State Tracking: We use currentOffset to track where we are in the input buffer, and return remainingBuffer to hold any incomplete message data (e.g., we only got the length prefix but not the full message body). This gets combined with the next incoming data chunk for reprocessing.
• Cross-Platform Compatibility: readUIntBE (Big-Endian) ensures the length is parsed correctly regardless of the sender's system architecture.
• Boundary Checks: We always verify we have enough bytes left before reading the length prefix or message body—this prevents buffer overrun errors.
• Graceful Error Handling: If a message fails JSON parsing, we log the issue without breaking the entire parsing loop.

How to Use This in Your Socket Receiver #

You need to maintain a persistent buffer across data events to handle incomplete messages:

// Persistent buffer to hold incomplete message data between data events
let leftoverBuffer = Buffer.alloc(0);

socket.on('data', (newDataChunk) => {
  // Combine new data with any leftover from last time
  const fullBuffer = Buffer.concat([leftoverBuffer, newDataChunk]);
  
  // Parse the combined buffer
  const { parsedMessages, remainingBuffer } = parseMessage(fullBuffer);
  leftoverBuffer = remainingBuffer;

  // Process your valid parsed messages here
  parsedMessages.forEach((msg) => {
    console.log('Received valid message:', msg);
    // Add your business logic here
  });
});

Critical Sender-Side Matching #

This approach only works if your sender also follows the length-prefix rule. Here's a quick sender example to match:

function sendSocketMessage(socket, messageObj) {
  const messageString = JSON.stringify(messageObj);
  const messageBuffer = Buffer.from(messageString, 'utf8');
  
  // Create 4-byte length prefix
  const lengthBuffer = Buffer.alloc(4);
  lengthBuffer.writeUIntBE(messageBuffer.length, 0, 4);
  
  // Combine prefix and message, then send
  socket.write(Buffer.concat([lengthBuffer, messageBuffer]));
}

Quick Notes #

• Length Prefix Size: We used 4 bytes here (supports up to ~4GB messages). If you're working with smaller messages, you can use 2 bytes (UInt16, max 65535 bytes)—just make sure sender and receiver use the same size!
• Logging: Keep an eye on those parse error logs—they usually point to malformed messages from the sender or corrupted network data.

内容的提问来源于stack exchange，提问作者als9xd