So senden Sie Daten in Echtzeit in NodeJS

Mit der Entwicklung moderner Webanwendungen wird der Bedarf an Echtzeitdaten immer höher. Node.js ist ein auf der V8-Engine basierendes JavaScript-Backend-Framework, das eine effiziente und stabile Plattform für die Verarbeitung von Echtzeitdaten bietet.

In Node.js werden mehrere Technologien verwendet, um eine Echtzeit-Datenübertragung zu erreichen. Einige davon werden im Folgenden vorgestellt.

1. WebSocket

WebSocket ist ein Protokoll, das einen bidirektionalen Kommunikationskanal zur Übertragung von Echtzeitdaten zwischen einem Client und einem Server bereitstellt. Im Gegensatz zu HTTP sind WebSocket-Verbindungen persistent, das heißt, sobald eine Verbindung hergestellt ist, können Daten vom Server empfangen und Daten an den Server gesendet werden, während die Verbindung aufrechterhalten wird.

In Node.js kann WebSocket mithilfe von Modulen wie ws oder socket.io implementiert werden. Diese Module bieten alle benutzerfreundliche APIs zum Erstellen von WebSocket-Servern, zum Verwalten von Verbindungen und Nachrichtenübertragungen sowie zum Verwalten von Verbindungen.

Das Folgende ist ein Beispielcode, der das ws-Modul verwendet, um einen WebSocket-Server zu implementieren:

const WebSocket = require('ws');

const wsServer = new WebSocket.Server({ port: 8080 });

wsServer.on('connection', (ws) => {
  console.log('New client connected');

  // send a welcome message to the client
  ws.send('Welcome to the WebSocket server!');

  // handle messages from the client
  ws.on('message', (message) => {
    console.log(`Received message: ${message}`);

    // echo the message back to the client
    ws.send(`You sent: ${message}`);
  });
});

2. Vom Server gesendete Ereignisse

Server-Sent Events (SSE) ist eine Technologie, die das HTTP-Protokoll verwendet, um Echtzeitereignisse an Clients zu senden. Im Gegensatz zu WebSocket ist SSE unidirektional und kann nur Daten vom Server an den Client senden. Es handelt sich jedoch immer noch um eine Technologie, die sich sehr gut für die Übertragung von Echtzeitdaten eignet.

In Node.js können Sie Module wie sse oder express-sse verwenden, um SSE zu implementieren. Diese Module bieten auch einige praktische APIs zum Senden von Ereignissen und zum Aufrechterhalten von Verbindungen.

Das Folgende ist ein Beispielcode zum Implementieren eines SSE-Servers mit dem Express-SSE-Modul:

const express = require('express');
const sse = require('express-sse');

const app = express();
app.use(express.static('public'));

const sseServer = new sse();

// send an initial message to the client when the connection is established
sseServer.send('Connected');

// handle SSE requests from the client
app.get('/sse', sseServer.init);

// send a message to all connected clients
sseServer.send('A new message has arrived!');

// close the connection to all connected clients
sseServer.close();

app.listen(8080, () => {
  console.log('SSE server started on port 8080');
});

3. Long-Polling

# 🎜🎜 #Long-Polling ist eine Technik zur Simulation der Echtzeit-Datenübertragung, die eine bidirektionale Kommunikation über das HTTP-Protokoll simuliert. Im Gegensatz zu WebSocket und SSE simuliert Long-Polling die Datenübertragung in Echtzeit, indem es HTTP-Anfragen auf dem Server offen hält.

In Node.js kann Long-Polling mithilfe von Frameworks wie Polka oder Express implementiert werden. Diese Frameworks unterstützen die asynchrone Verarbeitung von Anfragen und können die Verbindung offen halten, bis die Anfrage verarbeitet wird.

Das Folgende ist ein Beispielcode, der das Polka-Framework zum Implementieren von Long-Polling verwendet:

const polka = require('polka');

polka()
  .get('/long-polling', async (req, res) => {
    // wait for some event to happen
    const data = await waitForData();

    // send the data back to the client
    res.end(data);
  })
  .listen(8080, () => {
    console.log('Long-Polling server started on port 8080');
  });

Zusammenfassung:

Das Obige ist Node.js Um eine Echtzeit-Datenübertragung zu implementieren, gibt es mehrere Technologien, von denen jede ihre Vorteile und anwendbaren Szenarien hat. WebSocket ist ein weit verbreitetes Protokoll für Anwendungen, die eine bidirektionale Kommunikation erfordern. SSE ist eine einfache Implementierung, die für Szenarien geeignet ist, in denen nur Daten vom Server an den Client gesendet werden müssen für Situationen, in denen WebSocket oder SSE nicht verwendet werden können.

Das obige ist der detaillierte Inhalt vonSo senden Sie Daten in Echtzeit in NodeJS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!