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 Echtzeitserver ist so konzipiert, dass er sofort auf Daten reagiert und somit jede Benutzerinteraktion oder jedes Systemereignis sofort verarbeitet. Im Gegensatz zu herkömmlichen Anfrage-Antwort-Servern, die Verzögerungen verursachen, verwenden Echtzeit-Server Technologien und Protokolle, um einen kontinuierlichen Informationsaustausch und sofortige Aktualisierungen zu gewährleisten. Denn ein Echtzeitserver ist für mehrere Anwendungen, die Live-Kommunikation erfordern, von entscheidender Bedeutung: Messaging-Systeme, Online-Spiele, Finanzhandelsplattformen und Tools für die Zusammenarbeit. In diesem Artikel lernen wir, wie man den offenen Echtzeitserver Deepstream und IronPDF zur Erstellung von PDFs verwendet.

deepstream.io ist ein skalierbarer Echtzeit-Server für Datensynchronisation und Many-to-Many-Messaging. Es kann Daten mit Leichtigkeit handhaben und viele Clients mit wirklich geringer Latenz synchronisieren und unterstützt binäre Datenübertragungen. deepstream.io ist so konzipiert, dass es hinter anderen Load Balancing- und Balancersystemen platziert werden kann. Es bietet eine effiziente Möglichkeit, Daten zu synchronisieren und Ressourcendateien auf dem neuesten Stand zu halten, wodurch es sich perfekt für Anwendungen eignet, die Daten in Echtzeit aktualisieren und auf der Suche nach einer skalierbaren Serverlösung sind.

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

die Implementierung von deepstream.io durch Entwickler kann problemlos Live-Updates, kollaborative Anwendungen und interaktive Erlebnisse in Echtzeit ermöglichen, ohne bei Null anfangen zu müssen. Die Software wurde für hohe Lasten und effiziente Skalierung konzipiert und ist daher die erste Wahl für Anwendungen mit hoher Parallelität. deepstream.io ist flexibel und kann sich in vielerlei Hinsicht als die perfekte Ergänzung für Ihren Stack erweisen. Es handelt sich um eine Komplettlösung, mit der Benutzer reaktionsfähige und interaktive Web- und Mobilanwendungen in Echtzeit erstellen können.

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

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

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

SHELL

Installieren Sie das deepstream.io-Paket

Zunächst einmal müssen Sie deepstream.io installieren. Sie können entweder NPM zur Installation verwenden oder die Binärdateien von der offiziellen Website herunterladen.

npm install @deepstream/server

npm install @deepstream/server

SHELL

Grundlegende Konfiguration 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 Paket @deepstream/server in Node.js einrichtet und startet. Zunächst wird die Klasse Deepstream aus dem Paket importiert und dann eine neue Instanz erstellt. Durch den Aufruf von server.start() wird der Server gestartet und ist bereit, eingehende Verbindungen für die Verarbeitung von Echtzeit-Datenbindung, Messaging oder Präsenz-Backend-Diensten zu akzeptieren.

Verbinden von Deepstream mit dem 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 mit Deepstream verbindet. Dieses Skript importiert die Klasse DeepstreamClient, erstellt eine Instanz und verbindet sie mit einem Deepstream-Server, der lokal unter der IP-Adresse 127.0.0.1 an Port 6020 läuft. Es meldet sich ohne Anmeldeinformationen an, was ausreicht, wenn der Server keine Authentifizierung verwendet oder wenn er für Testfälle verwendet wird. Mit dieser Einrichtung wird ein Client initialisiert, der Daten in Echtzeit synchronisieren und kommunizieren kann.

Sobald die Verbindung mit dem Serverknoten hergestellt ist, wird in der Serverkonsole eine Meldung ähnlich der folgenden angezeigt.

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

Verwendung von Listener mit deepstream.io

Im Folgenden finden Sie einen Beispielcode, der zur Erstellung von Listenern, einem der Kernkonzepte von Deepstream, verwendet werden kann.

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 bei einem Deepstream-Server an, der auf 127.0.0.1:6020 gehostet wird und die Bibliothek @deepstream/client verwendet. Nach erfolgreicher Authentifizierung wird ein benutzerdefiniertes Ereignis mit dem Namen "custom-event" mit einer Nutzlast { message: "Hallo, 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 handelt sich um ein Werkzeug, das bei den meisten programmierbasierten Prozessen für PDFs und Backend-Prozessen wie der Modifizierung bereits vorhandener PDFs und der Konvertierung von HTML in PDFs verwendet wird. In Anwendungen, in denen die dynamische Erstellung und Handhabung von PDFs erforderlich ist, ist IronPDF sehr hilfreich. Sie bietet eine benutzerfreundliche und flexible Möglichkeit, hochwertige PDF-Dokumente zu erstellen.

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

IronPDF-Paket installieren

Verwenden Sie npm, um Pakete herunterzuladen und zu installieren, die die IronPDF-Fähigkeit von Node.js aktivieren.

npm install @ironsoftware/ironpdf

npm install @ironsoftware/ironpdf

SHELL

PDF-Erzeugungsfunktion

Erstellen Sie eine Funktion, die IronPDF verwendet, um PDFs zu erzeugen:

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

Deepstream-Client einrichten

Schreiben Sie ein JavaScript-Skript, das Daten in Echtzeit abfragt und PDFs auf der Grundlage dieser 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öffentlichungsereignisse zum Auslösen 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 durch das Abhören von Echtzeit-Ereignissen implementiert, die die PDF-Erzeugung auslösen werden. Die Funktion generatePDF erstellt ein PDF-Dokument auf der Grundlage von Daten aus Deepstream.io-Ereignissen mit IronPDF. Der DeepstreamClient abonniert diese Ereignisse und ruft die PDF-Erzeugungsfunktion auf, sobald relevante Ereignisse veröffentlicht werden. Eine solche Integration ermöglicht die dynamische Generierung von PDFs in Echtzeit auf der Grundlage von Ereignissen, Anfragen oder Datenänderungen.

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

Lizenzierung

Damit der Code kompiliert werden kann und ohne Wasserzeichen funktioniert, ist ein Lizenzschlüssel erforderlich. Entwickler, die eine Testlizenz erwerben möchten, können sich hier registrieren. Um eine solche Übersetzung zu erhalten, muss keine Kreditkarte vorgelegt werden. Um sich für eine kostenlose Testversion anzumelden, müssen Sie nur Ihre E-Mail-Adresse eingeben.

Abschluss

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

Ganz gleich, ob es sich um die Erstellung von Berichten, Rechnungen oder anderen Dokumenten handelt, die Integration von deepstream.io mit IronPDF ermöglicht eine Vereinfachung der Arbeitsabläufe, eine reaktionsschnelle Dokumentenerstellung und sorgt dafür, dass Ihre Anwendung mit Echtzeitinformationen schlank und aktuell bleibt. Diese Paarung eignet sich am besten für agile, datengesteuerte und reaktionsschnelle Anwendungen, die Unterstützung bei der Dokumentenerstellung und -verwaltung in Echtzeit erfordern.

Die von Iron Software bereitgestellten Bibliotheken ermöglichen es uns, schnell und einfach Programme für eine Vielzahl von Betriebssystemen, Browsern und Plattformen zu erstellen, darunter 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 ...