PYTHON-HILFE

deepstream io (Wie es für Entwickler funktioniert)

Name: IronPDF
Brand: Iron Software
Availability: InStock
Rating: 4.87 (307 reviews)

Aktualisiert:Juni 22, 2025

Ein Echtzeit-Server ist so konzipiert, dass er sofort auf Daten reagiert und bei jeder Benutzerinteraktion oder jedem Systemereignis sofort ansprechbar ist. Im Gegensatz zu herkömmlichen Anfrage-Antwort-Servern, die Verzögerungen einführen, verwenden Echtzeit-[Server](https://en.wikipedia.org/wiki/Server_(computing) Technologien und Protokolle, um einen kontinuierlichen Informationsaustausch und sofortige Updates sicherzustellen. Das liegt daran, dass ein Echtzeit-Server entscheidend für mehrere Anwendungen ist, die Live-Kommunikation erfordern: Messaging-Systeme, Online-Spiele, Finanzhandel-Plattformen und Kollaborationswerkzeuge. In diesem Artikel lernen wir, wie man den offenen Echtzeit-Server deepstream und IronPDF verwendet, um PDFs zu erstellen.

deepstream.io ist ein skalierbarer Echtzeit-Server für Datensynchronisierung und viele-zu-viele Nachrichtenübermittlung. Es kann Daten mühelos verarbeiten und viele Clients mit sehr niedriger Latenz synchronisiert halten und unterstützt den Transfer von binären Daten. deepstream.io ist so konzipiert, dass es hinter anderen Load-Balancern und Balancern platziert werden kann, und bietet eine effiziente Möglichkeit, Daten zu synchronisieren und Ressourcen-Dateien aktuell zu halten, was es perfekt geeignet macht für Anwendungen, die Daten in Echtzeit aktualisieren und nach einer skalierbaren Serverlösung suchen.

deepstream io (Wie es für Entwickler funktioniert): Abbildung 1 - deepstream.io

Die Implementierung von deepstream.io durch Entwickler ermöglicht es, Live-Updates, kollaborative Anwendungen und interaktive Erlebnisse in Echtzeit ohne den Neustart von null zu ermöglichen. Es wurde für hohe Lasten und effizientes Skalieren entworfen, was es zur Software-Wahl für Anwendungen mit hoher gleichzeitiger Nutzung macht. deepstream.io ist flexibel und kann sich als die perfekte Ergänzung zu Ihrem Stack in mehrfacher Hinsicht herausstellen. Es bietet eine Komplettlösung, mit der Benutzer Echtzeit-, reaktionsschnelle und interaktive Web- und Mobile-Apps erstellen können.

Um ein neues Node.js-Verzeichnis zu erstellen, geben Sie in der Konsole die folgenden Befehle ein:

mkdir deepstream-project
cd deepstream-project
npm init -y

mkdir deepstream-project
cd deepstream-project
npm init -y

SHELL

deepstream.io-Paket installieren

Zuerst müssen Sie deepstream.io installieren. Sie können entweder NPM verwenden, um es zu installieren oder die Binärdateien von der offiziellen Webseite herunterladen.

npm install @deepstream/server

npm install @deepstream/server

SHELL

Grundkonfiguration von deepstream.io

const { Deepstream } = require('@deepstream/server');

// Create a new Deepstream server instance
const server = new Deepstream({});

// Start the server to listen for client connections
server.start();

const { Deepstream } = require('@deepstream/server');

// Create a new Deepstream server instance
const server = new Deepstream({});

// Start the server to listen for client connections
server.start();

JAVASCRIPT

Der obige Codeausschnitt zeigt, wie man einen deepstream.io-Server mit dem @deepstream/server-Paket in Node.js einrichtet und startet. Er importiert zunächst die Deepstream-Klasse aus dem Paket und erstellt dann eine neue Instanz. Durch den Aufruf von server.start() wird der Server gestartet und ist bereit, eingehende Verbindungen zur Handhabung von Echtzeit-Datenbindung, Messaging oder Präsenz-Backend-Diensten anzunehmen.

Verbindung von Deepstream mit Client

const { DeepstreamClient } = require('@deepstream/client');

// Connect to a local deepstream server
const client = new DeepstreamClient('127.0.0.1:6020');

// Log in to the server without credentials (suitable for servers without authentication)
client.login(null);

const { DeepstreamClient } = require('@deepstream/client');

// Connect to a local deepstream server
const client = new DeepstreamClient('127.0.0.1:6020');

// Log in to the server without credentials (suitable for servers without authentication)
client.login(null);

JAVASCRIPT

Der obige Code zeigt, wie man sich mit der @deepstream/client-Bibliothek bei deepstream verbindet. Dieses Skript importiert die DeepstreamClient-Klasse, erstellt eine Instanz und verbindet sie mit einem auf IP-Adresse 127.0.0.1 und Port 6020 lokal laufenden deepstream-Server. Es meldet sich ohne Anmeldedaten an, was ausreichend ist, wenn der Server keine Authentifizierung verwendet oder wenn er für Testfälle verwendet wird. Diese Einrichtung initialisiert einen Client, der Echtzeit-Datensynchronisation und Kommunikation bereitstellen kann.

Sobald die Verbindung mit dem Serverknoten hergestellt ist, erscheint im Serverkonsolenfenster eine Nachricht ähnlich der untenstehenden.

deepstream io (Wie es für Entwickler funktioniert): Abbildung 2 - Konsolennachricht

Verwendung des Listeners mit deepstream.io

Unten ist ein Beispielcode, der verwendet werden kann, um Listener zu erstellen, eines der Kernkonzepte von deepstream.

const { DeepstreamClient } = require("@deepstream/client");

// Connect to the Deepstream server
const client = new DeepstreamClient("127.0.0.1:6020");

// Log in to the server
client.login(null, (success, clientData) => {
  if (success) {
    const event = client.event;
    // Publish a custom event
    event.publish("custom-event", { message: "Hello, Deepstream!" });
  }
});

const { DeepstreamClient } = require("@deepstream/client");

// Connect to the Deepstream server
const client = new DeepstreamClient("127.0.0.1:6020");

// Log in to the server
client.login(null, (success, clientData) => {
  if (success) {
    const event = client.event;
    // Publish a custom event
    event.publish("custom-event", { message: "Hello, Deepstream!" });
  }
});

JAVASCRIPT

Im obigen Code meldet sich der Client mit der @deepstream/client-Bibliothek bei einem auf 127.0.0.1:6020 gehosteten deepstream-Server an. Nach erfolgreicher Authentifizierung veröffentlicht es ein benutzerdefiniertes Ereignis namens "custom-event" mit einer Nutzlast { message: "Hello, Deepstream!" }.

Einführung in IronPDF

Verwenden Sie IronPDF, ein unglaublich starkes Node.js-Paket, um PDF-Dokumente zu erstellen, zu bearbeiten, zu konvertieren und zu bearbeiten. Es ist ein Werkzeug, das in den meisten programmierbasierten Prozessen auf PDFs und Backend-Prozessen wie Modifizieren bereits bestehender PDFs und Konvertieren von HTML in PDFs verwendet wird. In Anwendungen, in denen die dynamische Erstellung und Handhabung von PDFs erforderlich ist, wird IronPDF sehr hilfreich. Es bietet eine benutzerfreundliche und flexible Möglichkeit, qualitativ hochwertige PDF-Dokumente zu erstellen.

deepstream io (Wie es für Entwickler funktioniert): Abbildung 3 - IronPDF

Installiere IronPDF-Paket

Verwenden Sie npm, um Pakete herunterzuladen und zu installieren, die Node.js IronPDF-Funktionalität ermöglichen.

npm install @ironsoftware/ironpdf

npm install @ironsoftware/ironpdf

SHELL

PDF-Generierungsfunktion

Erstellen Sie eine Funktion, die IronPDF zur PDF-Erzeugung verwendet:

const IronPdf = require('@ironsoftware/ironpdf');
const { PdfDocument } = IronPdf;

// Set IronPDF configuration, replacing 'YOUR_LICENSE_KEY' with your actual license key
const config = IronPdf.IronPdfGlobalConfig;
config.setConfig({ licenseKey: 'YOUR_LICENSE_KEY' });

async function generatePDF(title, content) {
  try {
    // Generate PDF from HTML content
    const pdf = await PdfDocument.fromHtml(`<html><body><h1>${title}</h1><p>${content}</p></body></html>`);
    return await pdf.saveAsBuffer();
  } catch (error) {
    console.error('Error generating PDF:', error);
    throw error;
  }
}

module.exports = generatePDF;

const IronPdf = require('@ironsoftware/ironpdf');
const { PdfDocument } = IronPdf;

// Set IronPDF configuration, replacing 'YOUR_LICENSE_KEY' with your actual license key
const config = IronPdf.IronPdfGlobalConfig;
config.setConfig({ licenseKey: 'YOUR_LICENSE_KEY' });

async function generatePDF(title, content) {
  try {
    // Generate PDF from HTML content
    const pdf = await PdfDocument.fromHtml(`<html><body><h1>${title}</h1><p>${content}</p></body></html>`);
    return await pdf.saveAsBuffer();
  } catch (error) {
    console.error('Error generating PDF:', error);
    throw error;
  }
}

module.exports = generatePDF;

JAVASCRIPT

Richten Sie den Deepstream-Client ein

Schreiben Sie ein JavaScript-Skript, das Daten in Echtzeit überwacht und PDFs basierend auf diesen Daten generiert:

const { DeepstreamClient } = require('@deepstream/client');
const generatePDF = require('./generatePdf'); // Path to your PDF generation function

// Connect to the Deepstream server
const client = new DeepstreamClient('127.0.0.1:6020');

// Log in to the server
client.login(null, async (success) => {
  if (success) {
    console.log('Deepstream connected successfully');
    // Listen for a custom event to trigger PDF generation
    const event = client.event;
    event.subscribe('generate-pdf', async (data) => {
      const { title, content } = data;
      if (!title || !content) {
        console.error('Missing title or content for PDF generation');
        return;
      }
      try {
        // Generate the PDF
        const pdfBuffer = await generatePDF(title, content);
        // Handle the PDF buffer (e.g., save to file, send over network)
        console.log('PDF generated successfully');
        // Example: Save PDF to a file (optional)
        const fs = require('fs');
        fs.writeFileSync('generated.pdf', pdfBuffer);
      } catch (error) {
        console.error('Error generating PDF:', error);
      }
    });
  } else {
    console.error('Failed to connect to Deepstream');
  }
});

const { DeepstreamClient } = require('@deepstream/client');
const generatePDF = require('./generatePdf'); // Path to your PDF generation function

// Connect to the Deepstream server
const client = new DeepstreamClient('127.0.0.1:6020');

// Log in to the server
client.login(null, async (success) => {
  if (success) {
    console.log('Deepstream connected successfully');
    // Listen for a custom event to trigger PDF generation
    const event = client.event;
    event.subscribe('generate-pdf', async (data) => {
      const { title, content } = data;
      if (!title || !content) {
        console.error('Missing title or content for PDF generation');
        return;
      }
      try {
        // Generate the PDF
        const pdfBuffer = await generatePDF(title, content);
        // Handle the PDF buffer (e.g., save to file, send over network)
        console.log('PDF generated successfully');
        // Example: Save PDF to a file (optional)
        const fs = require('fs');
        fs.writeFileSync('generated.pdf', pdfBuffer);
      } catch (error) {
        console.error('Error generating PDF:', error);
      }
    });
  } else {
    console.error('Failed to connect to Deepstream');
  }
});

JAVASCRIPT

Veröffentlichen von Ereignissen zur Auslösung der PDF-Erzeugung

Ereignisse können veröffentlicht werden, um die PDF-Erzeugung aus einer anderen JavaScript-Datei oder einem Teil Ihrer Anwendung auszulösen:

const { DeepstreamClient } = require('@deepstream/client');

// Connect to the Deepstream server
const client = new DeepstreamClient('127.0.0.1:6020');

// Log in to the server
client.login(null, () => {
  const event = client.event;
  // Publish a custom event with title and content
  event.publish('generate-pdf', {
    title: 'Sample PDF Title',
    content: 'This is the content of the PDF document.'
  });
});

const { DeepstreamClient } = require('@deepstream/client');

// Connect to the Deepstream server
const client = new DeepstreamClient('127.0.0.1:6020');

// Log in to the server
client.login(null, () => {
  const event = client.event;
  // Publish a custom event with title and content
  event.publish('generate-pdf', {
    title: 'Sample PDF Title',
    content: 'This is the content of the PDF document.'
  });
});

JAVASCRIPT

Deepstream.io wird implementiert, indem Echtzeitevents abgehört werden, die die PDF-Generierung auslösen. Die generatePDF-Funktion erstellt ein PDF-Dokument basierend auf Daten aus Deepstream.io-Ereignissen mit IronPDF. Der DeepstreamClient abonniert diese Ereignisse, und wann immer relevante Ereignisse veröffentlicht werden, ruft er die PDF-Erzeugungsfunktion auf. Diese Integration ermöglicht die dynamische Erzeugung von PDFs in Echtzeit basierend auf Ereignisvorkommen, Anfragen oder Datenänderungen.

deepstream io (Wie es für Entwickler funktioniert): Abbildung 4 - PDF-Ausgabe

Lizenzierung

Für den Code, um ohne Wasserzeichen zu kompilieren und zu funktionieren, ist ein Lizenzschlüssel erforderlich. Entwickler, die eine Testlizenz wünschen, können sich hier registrieren. Der Erhalt einer solchen Lizenz erfordert keine Angabe einer Kreditkarte. Man muss sich nur mit seiner E-Mail-Adresse für eine kostenlose Testversion anmelden.

Abschluss

Eine der stärksten Lösungen für die Verarbeitung von Echtzeitdaten und die dynamische Dokumentenerzeugung wird durch eine Kombination aus deepstream.io und IronPDF erreicht. deepstream.io synchronisiert Änderungen und zeichnet alle Ereignisse in Echtzeit auf, sodass es sofort auf jede Datenänderung reagieren kann. IronPDF bietet einen robusten Mechanismus zur Erstellung professioneller Dokumente im Handumdrehen. Diese Integration ermöglicht es Ihren Anwendungen, PDF-Dokumente automatisch zu erstellen und zu verarbeiten, nicht nur wenn sich Live-Daten ändern, sondern auch immer dann, wenn ein Benutzer mit Ihrer Anwendung interagiert.

Ob es sich um Berichtserstellung, Rechnungen oder eine andere Art von Dokument handelt, die Integration von deepstream.io mit IronPDF ermöglicht Vereinfachung von Arbeitsabläufen, reaktionsschnelle Dokumentenerstellung und hält Ihre Anwendung schlank und aktuell mit Echtzeitinformationen. Dieses Paar eignet sich am besten für agile, datengetriebene und reaktionsfreudige Anwendungen, die Unterstützung für Echtzeit-Dokumentenerstellung und -verwaltung erfordern.

Die von Iron Software bereitgestellten Bibliotheken ermöglichen es uns, Programme schnell und einfach für eine Vielzahl von Betriebssystemen, Browsern und Plattformen zu erstellen, einschließlich Windows, Android, MAC, Linux usw.

Curtis Chau

Jetzt mit dem Ingenieurteam chatten

Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...