NODE-HILFE

sockjs NPM (Wie es für Entwickler funktioniert)

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

Aktualisiert:Juni 22, 2025

SockJS und IronPDF spielen unterschiedliche, aber sich ergänzende Rollen beim Aufbau von Online-Anwendungen. Ein JavaScript-Paket namens SockJS bietet eine bidirektionale HTTP-API für die Client-Server-Kommunikation, die WebSockets ähnelt. Es ermöglicht es Webbrowsern und Servern, in Echtzeit und über Ereignisse zu kommunizieren, wodurch die Nutzung von Apps wie Chatrooms, Live-Nachrichten und Zusammenarbeitstools ermöglicht wird. In Node.js-Umgebungen ist IronPDF jedoch eine leistungsstarke JavaScript-Bibliothek, die zum programmgesteuerten Erstellen und Bearbeiten von PDF-Dokumenten bereitgestellt wird.

Während IronPDF die dynamische Erstellung und Verwaltung von PDF-Dokumenten ermöglicht, verwaltet der SockJS-Client den Echtzeit-Datenaustausch und die Kollaborationsfunktionen in Online-Anwendungen über einen domänenübergreifenden Kommunikationskanal. Durch die Integration des SockJS-Server-Pendants mit IronPDF können Entwickler basierend auf dynamischen Daten oder Benutzerinteraktionen einfach PDF-Dokumente erstellen und bereitstellen, während sie ihre Apps mit Echtzeit-Updates verbessern. Mit dieser Kombination können Entwickler komplexe Online-Apps entwerfen, die eine Vielzahl von Anwendungsfällen unterstützen, einschließlich dokumentenintensiver Anwendungen und kollaborativer Plattformen, indem sie sowohl Echtzeitkommunikation als auch dynamische PDF-Erstellung nutzen.

Was ist SockJS NPM?

SockJS ist eine browserseitige JavaScript-Bibliothek, die Echtzeit-, bidirektionale Kommunikation zwischen Web-Clients und Servern erleichtert. Es abstrahiert WebSocket und bietet einen Fallback-Mechanismus zu alternativen Transportprotokollen wie HTTP-Long-Polling und XHR-Streaming, um die Kompatibilität über verschiedene Webbrowser und Umgebungen hinweg sicherzustellen. Es bietet eine einfache JavaScript-API zum Aufbau und Verwalten von Verbindungen und zum Handhaben von Ereignissen wie Verbindungseröffnung, Nachrichteneingang und Schließen. Darüber hinaus beinhaltet SockJS einen Kommandozeilen-Client, der zu Testzwecken und zur Fehlerbehebung verwendet werden kann, was es sowohl für Entwicklungs- als auch für Produktionsumgebungen vielseitig macht. Insgesamt vereinfacht das SockJS JavaScript-Objekt die Implementierung von Echtzeitfunktionen in Webanwendungen und unterstützt skalierbare und reaktionsfähige Kommunikationskanäle.

sockjs NPM (How It Works For Developers): Abbildung 1 - SockJS

Hauptmerkmale von SockJS

Browsersystemübergreifende Kompatibilität

SockJS gewährleistet konsistentes Verhalten und Funktionalität über viele Webbrowser und Umgebungen hinweg.

Fallback-Mechanismus

Wenn WebSocket-Verbindungen nicht verfügbar sind oder fehlschlagen, kann SockJS transparent zu anderen Transportprotokollen wie HTTP-Long-Polling, XHR-Streaming oder sogar JSONP-Polling wechseln.

Echtzeit-Kommunikation

Es ermöglicht serverseitigen Anwendungen (normalerweise unter Verwendung von Node.js oder anderen serverseitigen Technologien) und clientseitigen JavaScript-Apps (die in Webbrowsern ausgeführt werden), in Echtzeit und ereignisgesteuert zu kommunizieren.

Benutzerfreundlichkeit

Da SockJS eine einfache API bietet, die WebSocket entspricht, können Entwickler es einfach in ihre Projekte einbinden und nutzen.

Skalierbarkeit

SockJS erleichtert die Entwicklung skalierbarer Apps, die viele gleichzeitige Verbindungen und eine Vielzahl von Netzwerksituationen handhaben können, indem es mehrere Transportprotokolle und Fallback-Techniken unterstützt.

Einfachheit der Integration

Es macht die Implementierung von Echtzeitfunktionen einfacher, indem es eine einfache API bereitstellt, die Entwickler ohne komplexe low-level Netzwerkprogrammierung in ihre Webanwendungen integrieren können.

Transportprotokoll-Abstraktion:

WebSocket, HTTP-Long-Polling und andere zugrunde liegende Transportprotokolle werden von SockJS abstrahiert. Dank seiner Anpassungsfähigkeit wird eine zuverlässige Kommunikation auch in Situationen gewährleistet, in denen WebSocket-Verbindungen eingeschränkt oder nicht verfügbar sind.

SockJS erstellen und konfigurieren

Üblicherweise müssen Sie SockJS sowohl auf der Clientseite (in Ihrem Webbrowser) als auch auf der Serverseite (unter Verwendung eines Browsers oder Server-Frameworks wie Node.js) einrichten, um es für die Echtzeitkommunikation in einer Online-Anwendung zu erstellen und zu konfigurieren. Das Folgende ist eine grundlegende Anleitung zum Erstellen und Konfigurieren von SockJS:

Installieren Sie SockJS

SockJS kann mit NPM installiert oder direkt über ein CDN eingebunden werden:

npm install sockjs-client

npm install sockjs-client

SHELL

SockJS in Ihr HTML einfügen

Binden Sie die SockJS-JavaScript-Bibliothek in die von Ihnen erstellte HTML-Datei ein:

<script src="https://cdn.jsdelivr.net/npm/sockjs-client@1/dist/sockjs.min.js"></script>

<script src="https://cdn.jsdelivr.net/npm/sockjs-client@1/dist/sockjs.min.js"></script>

HTML

SockJS-Verbindung initialisieren

Erstellen Sie eine SockJS-Instanz in Ihrer JavaScript-Datei (app.js oder etwas Ähnliches) und verbinden Sie sich mit Ihrem Server:

<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>SockJS + IronPDF Example</title>
  </head>
  <body>
    <script src="https://cdn.jsdelivr.net/npm/sockjs-client@1/dist/sockjs.min.js"></script>
    <script>
      // Initialize SockJS connection
      const sock = new SockJS("http://localhost:3000/socket");

      // Event handlers
      sock.onopen = function () {
        console.log("Connection opened");
      };
      sock.onmessage = function (e) {
        console.log("Message received:", e.data);
      };
      sock.onclose = function () {
        console.log("Connection closed");
      };

      // Example function to send a message
      function sendMessage(message) {
        sock.send(message);
      }
    </script>
    Enter the Message:
  </body>
</html>

<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>SockJS + IronPDF Example</title>
  </head>
  <body>
    <script src="https://cdn.jsdelivr.net/npm/sockjs-client@1/dist/sockjs.min.js"></script>
    <script>
      // Initialize SockJS connection
      const sock = new SockJS("http://localhost:3000/socket");

      // Event handlers
      sock.onopen = function () {
        console.log("Connection opened");
      };
      sock.onmessage = function (e) {
        console.log("Message received:", e.data);
      };
      sock.onclose = function () {
        console.log("Connection closed");
      };

      // Example function to send a message
      function sendMessage(message) {
        sock.send(message);
      }
    </script>
    Enter the Message:
  </body>
</html>

HTML

Die URL Ihres serverseitigen WebSocket-Endpunkts sollte anstelle von "http://localhost:3000/socket" verwendet werden.

sockjs NPM (How It Works For Developers): Abbildung 2 - SockJS-Verbindungsausgabe

Serverseitige Einrichtung

Installieren Sie SockJS-Node

Verwenden Sie npm, um das SockJS-Node-Paket zu installieren:

npm install sockjs

npm install sockjs

SHELL

SockJS-Server konfigurieren

Konfigurieren Sie SockJS in Ihrem Node.js-Server:

// Import necessary modules
const http = require('http');
const sockjs = require('sockjs');

// Create a SockJS server
const sockjsServer = sockjs.createServer();

// Attach the server to an HTTP server instance
const server = http.createServer();

// Install SockJS handlers
sockjsServer.installHandlers(server, { prefix: '/socket' });

// Define SockJS event handlers
sockjsServer.on('connection', function(conn) {
    console.log('Client connected');
    conn.on('data', function(message) {
        console.log('Received message:', message);
        // Handle incoming messages from client
    });
    conn.on('close', function() {
        console.log('Client disconnected');
    });
});

// Start the server
const PORT = 3000;
server.listen(PORT, function() {
    console.log(`Server listening on port ${PORT}`);
});

// Import necessary modules
const http = require('http');
const sockjs = require('sockjs');

// Create a SockJS server
const sockjsServer = sockjs.createServer();

// Attach the server to an HTTP server instance
const server = http.createServer();

// Install SockJS handlers
sockjsServer.installHandlers(server, { prefix: '/socket' });

// Define SockJS event handlers
sockjsServer.on('connection', function(conn) {
    console.log('Client connected');
    conn.on('data', function(message) {
        console.log('Received message:', message);
        // Handle incoming messages from client
    });
    conn.on('close', function() {
        console.log('Client disconnected');
    });
});

// Start the server
const PORT = 3000;
server.listen(PORT, function() {
    console.log(`Server listening on port ${PORT}`);
});

JAVASCRIPT

Stellen Sie sicher, dass der serverseitige Code an die Anforderungen Ihrer Anwendung angepasst ist und mit dem vorhandenen Server-Framework oder der Konfiguration funktioniert.

sockjs NPM (How It Works For Developers): Abbildung 3 - SockJS-Server-Kompatibilitätskonfiguration Ausgabe

Cross-Origin Requests (CORS): Stellen Sie sicher, dass Ihr Server CORS-Einstellungen effektiv handhabt, wenn sich Server und Client auf getrennten Domains befinden.

Fehlerbehandlung: Implementieren Sie Fehlerbehandlung und Sicherheitsmaßnahmen (wie Authentifizierung und Autorisierung) gemäß den Spezifikationen Ihrer Anwendung.

Bereitstellung: Richten Sie HTTPS für sichere Verbindungen ein und konfigurieren Sie SockJS und Ihren Server für Bereitstellungsumgebungen.

Diese Konfiguration bietet eine grundlegende Grundlage für die Echtzeitkommunikation zwischen einem Webclient und einem Webserver mit SockJS. Abhängig von den Anforderungen und der Architektur Ihrer spezifischen Anwendung können Anpassungen erforderlich sein.

Einstieg

Das Einrichten einer Webanwendung, die die Echtzeitkommunikationsfähigkeiten von SockJS und die dynamische PDF-Erstellung mit IronPDF nutzt, ist der erste Schritt, um mit SockJS und IronPDF zu beginnen. Hier ist ein Ausgangspunkt-Leitfaden:

Was ist IronPDF?

Ein leistungsstarkes Node.js-Tool namens IronPDF ist dafür ausgelegt, HTML-Daten in außergewöhnlich hochwertige PDF-Dateien zu transformieren. Ohne das ursprüngliche Webinhalt zu opfern, beschleunigt es den Prozess, HTML-, CSS- und andere JavaScript-Dateien in korrekt formatierte PDFs umzuwandeln. Dies ist ein sehr nützliches Werkzeug für Webanwendungen, die dynamische, druckbare Dokumente wie Berichte, Rechnungen und Zertifikate generieren müssen.

Anpassbare Seiteneinstellungen, Kopf- und Fußzeilen sowie die Möglichkeit, Schriftarten und Bilder hinzuzufügen, sind nur einige der Funktionen von IronPDF. Es kann komplexe Layouts und Stile handhaben, um sicherzustellen, dass jede Test-PDF-Ausgabe die Anforderungen erfüllt. Darüber hinaus verwaltet IronPDF die Ausführung von JavaScript innerhalb von HTML und ermöglicht präzise dynamische und interaktive Inhalt-Darstellungen.

sockjs NPM (How It Works For Developers): Abbildung 4 - IronPDF

Funktionen von IronPDF

1. PDF-Erzeugung aus HTML

JavaScript, HTML und CSS in PDF konvertieren. Unterstützt Medienabfragen und Responsive Design, zwei moderne Webstandards. Nützlich zur dynamischen Verzierung von PDF-Berichten, -Rechnungen und -Dokumenten mit HTML und CSS.

2. PDF-Bearbeitung

Bereits vorhandene PDFs können Text, Bilder und andere Inhalte hinzugefügt werden. Text und Bilder aus PDFs extrahieren. Kombinieren Sie mehrere PDFs in einer Datei. Teilen Sie PDF-Dateien in mehrere separate Dokumente auf. Fügen Sie Wasserzeichen, Anmerkungen, Kopf- und Fußzeilen ein.

3. leistungsfähigkeit und zuverlässigkeit

Hohe Leistung und Zuverlässigkeit sind erwünschte Designqualitäten in industriellen Umgebungen. Verwaltet große Dokumentensätze problemlos.

IronPDF installieren

Installieren Sie das IronPDF-Paket, um die Werkzeuge zu erhalten, die Sie benötigen, um in Node.js-Projekten mit PDFs zu arbeiten. Führen Sie den folgenden Befehl aus:

npm install @ironsoftware/ironpdf

npm install @ironsoftware/ironpdf

SHELL

SockJS mit IronPDF kombinieren

Konfigurieren Sie SockJS auf Ihrem Node.js-Server, um Anfragen zur PDF-Erstellung zu bearbeiten und Clientverbindungen zu verwalten:

// server.js

// Import necessary modules
const http = require("http");
const sockjs = require("sockjs");
const IronPdf = require("@ironsoftware/ironpdf");

// Configure IronPDF with your license key
var config = IronPdf.IronPdfGlobalConfig;
config.setConfig({
  licenseKey: "",  // Add your IronPDF license key here
});

// Create a SockJS server
const sockjsServer = sockjs.createServer();

// Attach the SockJS server to an HTTP server instance
const server = http.createServer();
sockjsServer.installHandlers(server, { prefix: "/socket" });

// Handle SockJS connections and messages
sockjsServer.on("connection", function (conn) {
  console.log("Client connected");

  // Handle incoming messages (PDF generation requests)
  conn.on("data", async function(message) {
    console.log("Received message:", message);

    // Generate PDF using IronPDF
    let pdfdata = await generatePdf(message);

    // Send generated PDF data back to client
    conn.write(pdfdata);
  });

  conn.on("close", function () {
    console.log("Client disconnected");
  });
});

// Function to generate PDF using IronPDF
const generatePdf = async (htmlContent) => {
  const pdfDocument = IronPdf.PdfDocument;
  let result = (await pdfDocument.fromHtml(htmlContent));
  const pdfBuffer = await result.saveAsBuffer();
  return pdfBuffer;
};

// Start the HTTP server
const PORT = 3000;
server.listen(PORT, function () {
  console.log(`Server listening on port ${PORT}`);
});

// server.js

// Import necessary modules
const http = require("http");
const sockjs = require("sockjs");
const IronPdf = require("@ironsoftware/ironpdf");

// Configure IronPDF with your license key
var config = IronPdf.IronPdfGlobalConfig;
config.setConfig({
  licenseKey: "",  // Add your IronPDF license key here
});

// Create a SockJS server
const sockjsServer = sockjs.createServer();

// Attach the SockJS server to an HTTP server instance
const server = http.createServer();
sockjsServer.installHandlers(server, { prefix: "/socket" });

// Handle SockJS connections and messages
sockjsServer.on("connection", function (conn) {
  console.log("Client connected");

  // Handle incoming messages (PDF generation requests)
  conn.on("data", async function(message) {
    console.log("Received message:", message);

    // Generate PDF using IronPDF
    let pdfdata = await generatePdf(message);

    // Send generated PDF data back to client
    conn.write(pdfdata);
  });

  conn.on("close", function () {
    console.log("Client disconnected");
  });
});

// Function to generate PDF using IronPDF
const generatePdf = async (htmlContent) => {
  const pdfDocument = IronPdf.PdfDocument;
  let result = (await pdfDocument.fromHtml(htmlContent));
  const pdfBuffer = await result.saveAsBuffer();
  return pdfBuffer;
};

// Start the HTTP server
const PORT = 3000;
server.listen(PORT, function () {
  console.log(`Server listening on port ${PORT}`);
});

JAVASCRIPT

Clientseitige Einrichtung

Konfigurieren Sie SockJS auf der Clientseite, um mit dem Server zu interagieren und PDF-Erstellungsanforderungen zu senden.

<!-- index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>SockJS + IronPDF Example</title>
</head>
<body>
    <button onclick="generatePdf()">Generate PDF</button>
    <!-- Add SockJS browser JavaScript library -->
    <script src="https://cdn.jsdelivr.net/npm/sockjs-client@1/dist/sockjs.min.js"></script>
    <script>
        // Initialize SockJS connection
        const sock = new SockJS('http://localhost:3000/socket');

        // Event handlers
        sock.onopen = function() {
            console.log('Connection opened');
        };

        sock.onmessage = function(e) {
            console.log('PDF received');
            // Example: Display or download PDF received from server
            displayPdf(e.data);
        };

        sock.onclose = function() {
            console.log('Connection closed');
        };

        // Function to generate PDF
        function generatePdf() {
            // Example: HTML content to generate PDF
            const htmlContent = '<html><body><h1>Hello, IronPDF!</h1></body></html>';
            // Send HTML content to server for PDF generation
            sock.send(htmlContent);
        }

        // Function to display or download PDF data
        function displayPdf(pdfData) {
            // Example: Display or download PDF data received from server
            const pdfBlob = new Blob([atob(pdfData)], { type: 'application/pdf' });
            const pdfUrl = URL.createObjectURL(pdfBlob);
            window.open(pdfUrl, '_blank');
        }
    </script>
</body>
</html>

<!-- index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>SockJS + IronPDF Example</title>
</head>
<body>
    <button onclick="generatePdf()">Generate PDF</button>
    <!-- Add SockJS browser JavaScript library -->
    <script src="https://cdn.jsdelivr.net/npm/sockjs-client@1/dist/sockjs.min.js"></script>
    <script>
        // Initialize SockJS connection
        const sock = new SockJS('http://localhost:3000/socket');

        // Event handlers
        sock.onopen = function() {
            console.log('Connection opened');
        };

        sock.onmessage = function(e) {
            console.log('PDF received');
            // Example: Display or download PDF received from server
            displayPdf(e.data);
        };

        sock.onclose = function() {
            console.log('Connection closed');
        };

        // Function to generate PDF
        function generatePdf() {
            // Example: HTML content to generate PDF
            const htmlContent = '<html><body><h1>Hello, IronPDF!</h1></body></html>';
            // Send HTML content to server for PDF generation
            sock.send(htmlContent);
        }

        // Function to display or download PDF data
        function displayPdf(pdfData) {
            // Example: Display or download PDF data received from server
            const pdfBlob = new Blob([atob(pdfData)], { type: 'application/pdf' });
            const pdfUrl = URL.createObjectURL(pdfBlob);
            window.open(pdfUrl, '_blank');
        }
    </script>
</body>
</html>

HTML

Serverseitig: Der Node.js-Server konfiguriert einen SockJS-Server (sockjsServer) und hört auf Verbindungsanfragen auf dem /socket-Pfad. Es verwendet IronPDF (IronPdf.PdfDocument), um die Funktion generatePdf() zu initiieren, um eingehende Nachrichten (PDF-Erstellungsanforderungen) zu behandeln. Nach der Erstellung des PDFs verwendet es die SockJS-Verbindung, um die base64-kodierten PDF-Daten an den Client zurückzusenden.

sockjs NPM (How It Works For Developers): Abbildung 5 - SockJS-Client-Quellcode-Ausgabe

Clientseitig: Der Client verbindet sich über eine SockJS-Verbindung (sock) mit dem Server und hört auf Ereignisse wie onopen, onmessage und onclose. Der Benutzer sendet mit sock.send(htmlContent) HTML-Inhalte (htmlContent) an den Server zur PDF-Erstellung, wenn er auf die Schaltfläche "PDF generieren" klickt. Es zeigt oder lädt das PDF, nachdem die PDF-Daten vom Server erhalten wurden (sock.onmessage).

sockjs NPM (How It Works For Developers): Abbildung 6 - Clientseitige Ausgabe

Unten ist die Ausgabe, die vom Code generiert wurde.

sockjs NPM (How It Works For Developers): Abbildung 7 - PDF-Ausgabe

Abschluss

Eine starke Synergie wird in der Entwicklung von Webanwendungen geschaffen, wenn SockJS zur Echtzeitkommunikation und IronPDF zur dynamischen PDF-Erstellung verwendet wird. Mit SockJS wird die bidirektionale Kommunikation zwischen Clients und Servern einfach gemacht, was Funktionen wie interaktive Zusammenarbeit und Echtzeit-Updates ermöglicht. IronPDF hingegen gibt Programmierern die Möglichkeit, PDF-Dokumente programmgesteuert zu erstellen und zu bearbeiten. Es kann sogar HTML-Text dynamisch in PDFs umwandeln.

Komplexe Webanwendungen, die möglicherweise PDF-Dokumente sofort in Reaktion auf Benutzereingaben oder Echtzeit-Datenaktualisierungen erstellen, werden durch die Integration dieser Technologien ermöglicht. Anwendungen, die Echtzeit-Dokumentenerzeugung, Gruppenbearbeitung oder interaktive Berichtsfunktionen benötigen, werden diese Integration besonders nützlich finden. Durch die Nutzung von SockJS für sofortige Updates und IronPDF für dynamische PDF-Erstellung können Entwickler die Benutzererfahrung optimieren, Workflows verbessern und robuste Lösungen bereitstellen, die eine Vielzahl von Geschäftsanforderungen für jeden seriösen SockJS-Benutzer erfüllen.

Wir können die Nützlichkeit Ihres Node.js-App-Entwicklungstools erweitern, indem wir IronPDF nutzen, um OCR, Barcode-Scanning, PDF-Generierung, Excel-Interaktion und viele weitere Funktionen hinzuzufügen. Iron Software's hoch konfigurierbare Systeme und umfangreiche Bibliothek von gemeinschaftlich unterstützten Plugins ermöglichen es Entwicklern, Funktionen und Webanwendungen schneller zu entwickeln.

Entwickler können die zahlreichen Funktionen von IronPDF mit einer kostenlosen Testlizenz und einer Reihe von Codebeispielen des Unternehmens verwenden, bevor sie sich für den Kauf entscheiden. Für weitere Informationen über die unbefristete Lizenzierung von IronPDF besuchen Sie die Lizenzseite. Für weiterführende Anweisungen zur Nutzung von IronPDF besuchen Sie die Dokumentationsseite.

Darrius Serrant

Jetzt mit dem Ingenieurteam chatten

Full-Stack-Software-Ingenieur (WebOps)

Darrius Serrant hat einen Bachelor-Abschluss in Informatik von der University of Miami und arbeitet als Full-Stack-WebOps-Marketing-Ingenieur bei Iron Software. Seit seiner Jugend vom Programmieren angezogen, sah er die Informatik als sowohl mysteriös als auch zugänglich, was es zum perfekten Medium für Kreativität und Problemlösung ...