NDJSON 101: Streaming über HTTP-Endpunkte

In der heutigen datengetriebenen Welt ist die effiziente Übertragung großer Datensätze zwischen Systemen entscheidend. Während JSON zum Standardformat für den Datenaustausch geworden ist, stößt es bei der Verarbeitung großer Datenmengen oder Streaming-Szenarien an seine Grenzen. Hier kommt NDJSON (Newline Delimited JSON) ins Spiel – ein einfaches, aber leistungsstarkes Format, das die Art und Weise, wie wir Daten über HTTP-Verbindungen streamen, revolutioniert. In diesem Artikel werden wir untersuchen, was NDJSON ist, wie es sich von Standard-JSON unterscheidet und wie Apidog Ihnen bei der Arbeit mit NDJSON-Streaming-Endpunkten helfen kann.

Was ist NDJSON?

NDJSON (Newline Delimited JSON) ist ein Format, das strukturierte Daten als eine Sequenz von JSON-Objekten speichert, wobei sich jedes Objekt in einer eigenen Zeile befindet, getrennt durch ein Zeilenumbruchzeichen (\n). Es ist in einigen Kontexten auch als JSON Lines (JSONL) bekannt.

Hier ist ein einfaches Beispiel für NDJSON:

{"id": 1, "name": "Alice", "score": 95}
{"id": 2, "name": "Bob", "score": 87}
{"id": 3, "name": "Charlie", "score": 92}

Jede Zeile ist ein gültiges, vollständiges JSON-Objekt, wodurch es einfach ist, einen Datensatz nach dem anderen zu verarbeiten, ohne den gesamten Datensatz in den Speicher laden zu müssen.

NDJSON vs. Traditional JSON: Hauptunterschiede

Traditionelles JSON und NDJSON dienen unterschiedlichen Zwecken und weisen unterschiedliche Eigenschaften auf:

Der Hauptvorteil von NDJSON ist seine Fähigkeit, inkrementell verarbeitet zu werden. Bei traditionellem JSON müssen Sie die gesamte Datei parsen, bevor Sie auf Daten zugreifen können. Mit NDJSON können Sie eine Zeile nach der anderen lesen und verarbeiten, was es perfekt macht für:

• Protokolldateien
• Daten-Streaming
• Große Datensätze
• Echtzeit-Datenverarbeitung

Warum NDJSON für HTTP-Streaming verwenden?

HTTP-Streaming ermöglicht es Servern, Daten inkrementell an Clients zu senden, anstatt darauf zu warten, dass die gesamte Antwort bereit ist. NDJSON eignet sich besonders gut für HTTP-Streaming, da:

1. Einfachheit: Jede Zeile ist ein vollständiges, gültiges JSON-Objekt
2. Kompatibilität: Funktioniert mit vorhandenen JSON-Parsern
3. Inkrementelle Verarbeitung: Clients können Daten verarbeiten, sobald sie eintreffen
4. Speichereffizienz: Es ist nicht erforderlich, die gesamte Antwort zu puffern
5. Menschliche Lesbarkeit: Einfach zu untersuchen und zu debuggen

So streamen Sie NDJSON über HTTP-Endpunkte

Die Implementierung von NDJSON-Streaming über HTTP ist unkompliziert. So funktioniert es sowohl auf der Server- als auch auf der Client-Seite:

Server-seitige Implementierung

So erstellen Sie einen HTTP-Endpunkt, der NDJSON streamt:

Legen Sie die entsprechenden Header fest:

Content-Type: application/x-ndjson
Transfer-Encoding: chunked

Schreiben Sie jedes JSON-Objekt in den Antwort-Stream, gefolgt von einem Zeilenumbruchzeichen:

// Node.js example
app.get('/api/data/stream', (req, res) => {
  res.setHeader('Content-Type', 'application/x-ndjson');
  res.setHeader('Transfer-Encoding', 'chunked');
  
  // Stream data as it becomes available
  dataSource.on('data', (item) => {
    res.write(JSON.stringify(item) + '\n');
  });
  
  dataSource.on('end', () => {
    res.end();
  });
});

Client-seitige Verarbeitung

Auf der Client-Seite müssen Sie Folgendes tun:

1. Stellen Sie eine HTTP-Anfrage an den Streaming-Endpunkt
2. Verarbeiten Sie die Antwort inkrementell, Zeile für Zeile
3. Parsen Sie jede Zeile als JSON-Objekt

Hier ist ein einfaches JavaScript-Beispiel:

async function consumeNdjsonStream(url) {
  const response = await fetch(url);
  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let buffer = '';
  
  while (true) {
    const { value, done } = await reader.read();
    if (done) break;
    
    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split('\n');
    buffer = lines.pop(); // Keep the last incomplete line
    
    for (const line of lines) {
      if (line.trim() === '') continue;
      const jsonObject = JSON.parse(line);
      processData(jsonObject); // Do something with the data
    }
  }
}

Häufige Anwendungsfälle für NDJSON-Streaming

NDJSON-Streaming ist besonders wertvoll in Szenarien wie:

• Echtzeit-Analysen: Streamen Sie Ereignisdaten zur sofortigen Verarbeitung
• Protokollaggregation: Senden Sie kontinuierlich Anwendungsprotokolle an Überwachungssysteme
• Datenexporte: Übertragen Sie große Datensätze ohne Speicherbeschränkungen
• IoT-Anwendungen: Verarbeiten Sie Sensordaten, sobald sie generiert werden
• Aktivitätsfeeds: Liefern Sie Social-Media- oder Anwendungsereignisse in Echtzeit

Testen von NDJSON-Endpunkten mit Apidog

Apidog, die umfassende API-Entwicklungsplattform, bietet integrierte Unterstützung für das Testen und Debuggen von NDJSON-Streaming-Endpunkten. So vereinfacht Apidog die Arbeit mit NDJSON:

1. Echtzeit-Stream-Visualisierung

Die Benutzeroberfläche von Apidog zeigt NDJSON-Antworten in Echtzeit an und zeigt jedes JSON-Objekt an, sobald es vom Server eintrifft. Dies erleichtert die Überwachung von Streaming-Daten, ohne benutzerdefinierten Code schreiben zu müssen.

2. Automatisches Parsen und Formatieren

Apidog parst automatisch jede Zeile von NDJSON, sobald sie eintrifft, und formatiert sie für die Lesbarkeit, während die Streaming-Natur der Antwort erhalten bleibt.

3. Anforderungskonfiguration

Apidog vereinfacht die Konfiguration der erforderlichen Header und Parameter für NDJSON-Streaming-Anforderungen und gewährleistet so die ordnungsgemäße Kommunikation mit Ihren Streaming-Endpunkten.

Schritt-für-Schritt-Anleitung zum Streamen von HTTP-Endpunkten, die NDJSON zurückgeben

So testen Sie einen NDJSON-Streaming-Endpunkt in Apidog:

Schritt 1: Erstellen Sie eine neue HTTP-Anfrage

Schritt 2: Legen Sie die Anforderungsmethode fest

Schritt 3: Geben Sie Ihre Streaming-Endpunkt-URL ein

Schritt 4: Senden Sie die Anfrage

Schritt 5: Zeigen Sie das Testergebnis an

Beobachten Sie, wie Apidog die Streaming-NDJSON-Antwort in Echtzeit anzeigt

Sie können die zurückgegebenen NDJSON-Nachrichten in einer vollständigen Antwort zusammenführen. Erfahren Sie hier mehr.

Fazit

NDJSON bietet eine elegante Lösung für das Streaming strukturierter Daten über HTTP und kombiniert die Flexibilität von JSON mit der Effizienz der zeilenweisen Verarbeitung. Egal, ob Sie Echtzeit-Analysen, Protokollverarbeitungssysteme oder Datenexportfunktionen erstellen, NDJSON bietet einen einfachen, aber leistungsstarken Ansatz für die Verarbeitung von Streaming-Daten.

Mit der Unterstützung von Apidog für NDJSON-Streaming wird das Testen und Debuggen dieser Endpunkte erheblich vereinfacht. Sie können Ihre Streaming-Daten visualisieren, untersuchen und validieren, ohne benutzerdefinierten Code schreiben zu müssen, wodurch Ihr Entwicklungsprozess beschleunigt und sichergestellt wird, dass Ihre Streaming-APIs wie erwartet funktionieren.

Beginnen Sie noch heute mit der Erkundung von NDJSON-Streaming mit Apidog und erleben Sie die Leistungsfähigkeit der Echtzeit-Datenverarbeitung in Ihren Anwendungen!