Node.js服务器与PHP应用间高效通信策略：WebSocket的实践与优势

// server.js (Node.js)
const WebSocket = require('ws');

// 创建WebSocket服务器，监听指定端口
const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', ws => {
    console.log('PHP Client connected');

    ws.on('message', message => {
        try {
            const requestData = JSON.parse(message);
            console.log('Received from PHP:', requestData);

            // 模拟处理请求并生成响应
            let responseData = { status: 'success', data: 'Processed: ' + requestData.action };
            if (requestData.action === 'getData') {
                responseData.payload = { id: 1, name: 'Example Item', value: Math.random() };
            }

            // 发送JSON响应给PHP客户端
            ws.send(JSON.stringify(responseData));
        } catch (error) {
            console.error('Error parsing message or processing request:', error);
            ws.send(JSON.stringify({ status: 'error', message: 'Invalid JSON or server error' }));
        }
    });

    ws.on('close', () => {
        console.log('PHP Client disconnected');
    });

    ws.on('error', error => {
        console.error('WebSocket error:', error);
    });
});

console.log('Node.js WebSocket server started on port 8080');

// client.php (PHP)
<?php

class NodeJsClient
{
    private $host;
    private $port;

    public function __construct($host = 'localhost', $port = 8080)
    {
        $this->host = $host;
        $this->port = $port;
    }

    public function request(array $data)
    {
        $address = "tcp://{$this->host}:{$this->port}";
        $timeout = 5; // seconds

        // 尝试连接WebSocket服务器
        $socket = @stream_socket_client($address, $errno, $errstr, $timeout);

        if (!$socket) {
            error_log("Failed to connect to Node.js server: $errstr ($errno)");
            return ['status' => 'error', 'message' => "Connection failed: $errstr"];
        }

        // WebSocket握手（简化版，实际应用中可能需要更完整的握手协议）
        // 对于本地服务器间通信，通常不需要完整的HTTP握手，直接发送数据即可
        // 但如果Node.js服务器严格遵循WebSocket协议，则需要发送握手请求
        // 简化示例，直接发送数据，假设Node.js服务器能直接处理裸数据或简单封装

        $jsonData = json_encode($data);
        if ($jsonData === false) {
            fclose($socket);
            return ['status' => 'error', 'message' => 'Failed to encode JSON data.'];
        }

        // 封装WebSocket数据帧（opcode 0x1表示文本帧）
        $frame = $this->encodeWebSocketFrame($jsonData);
        fwrite($socket, $frame);

        // 读取响应
        $response = stream_get_contents($socket);
        fclose($socket);

        if ($response === false) {
            return ['status' => 'error', 'message' => 'Failed to read response from server.'];
        }

        // 解封装WebSocket数据帧
        $decodedResponse = $this->decodeWebSocketFrame($response);
        if ($decodedResponse === false) {
             return ['status' => 'error', 'message' => 'Failed to decode WebSocket frame.'];
        }

        return json_decode($decodedResponse, true);
    }

    /**
     * 简单WebSocket帧编码 (文本帧)
     * 仅支持单帧发送，不处理分片和掩码（本地通信通常不需要掩码）
     */
    private function encodeWebSocketFrame($payload)
    {
        $length = strlen($payload);
        $header = chr(0x81); // FIN bit + Text opcode

        if ($length <= 125) {
            $header .= chr($length);
        } elseif ($length > 125 && $length < 65536) {
            $header .= chr(126) . pack("n", $length);
        } else {
            $header .= chr(127) . pack("J", $length);
        }

        return $header . $payload;
    }

    /**
     * 简单WebSocket帧解码
     * 仅支持单帧接收，不处理分片和掩码
     */
    private function decodeWebSocketFrame($data)
    {
        $offset = 0;
        $firstByte = ord($data[$offset++]);
        $fin = ($firstByte >> 7) & 0x1;
        $opcode = $firstByte & 0xF;

        if ($opcode !== 0x1) { // 期望文本帧
            error_log("Received non-text WebSocket frame (opcode: $opcode)");
            return false;
        }

        $secondByte = ord($data[$offset++]);
        $masked = ($secondByte >> 7) & 0x1;
        $payloadLength = $secondByte & 0x7F;

        if ($payloadLength === 126) {
            $payloadLength = unpack("n", substr($data, $offset, 2))[1];
            $offset += 2;
        } elseif ($payloadLength === 127) {
            $payloadLength = unpack("J", substr($data, $offset, 8))[1];
            $offset += 8;
        }

        if ($masked) {
            // 本地通信通常不使用掩码，如果Node.js服务器发送了掩码帧，需要处理
            // 这里为了简化，假设Node.js服务器未发送掩码帧
            error_log("Received masked WebSocket frame, which is not handled in this simple decoder.");
            return false;
        }

        $payload = substr($data, $offset, $payloadLength);
        return $payload;
    }
}

// 示例用法
$client = new NodeJsClient();
$requestData = ['action' => 'getData', 'params' => ['userId' => 123]];
$response = $client->request($requestData);

if ($response && $response['status'] === 'success') {
    echo "Node.js Response:\n";
    print_r($response);
} else {
    echo "Error communicating with Node.js:\n";
    print_r($response);
}

// 另一个请求
$requestData2 = ['action' => 'saveData', 'params' => ['item' => 'New Item', 'value' => 42]];
$response2 = $client->request($requestData2);
echo "\nNode.js Response 2:\n";
print_r($response2);

?>