Przejdź do treści stopki
  1. IronPDF for Node.js
  2. Blog IronPDF for Node.js
  3. Pomoc Node
  4. sockjs NPM
POMOC NODE

sockjs NPM (jak to działa dla programistów)

Darrius Serrant
Darrius Serrant
Zaktualizowano:

SockJS i IronPDF odgrywają różne, ale uzupełniające się role w tworzeniu aplikacji internetowych. Pakiet JavaScript o nazwie SockJS oferuje dwukierunkowy interfejs API HTTP do komunikacji klient-serwer, który przypomina WebSockets. Umożliwia to komunikację między przeglądarkami internetowymi a serwerami w czasie rzeczywistym oraz poprzez zdarzenia, umożliwiając korzystanie z aplikacji takich jak czaty, serwisy informacyjne na żywo oraz narzędzia do pracy zespołowej. Jednak w środowisku Node.js IronPDF jest potężną biblioteką JavaScript, która umożliwia programowe tworzenie i modyfikowanie dokumentów PDF.

Podczas gdy IronPDF umożliwia dynamiczne tworzenie dokumentów PDF i zarządzanie nimi, klient SockJS zarządza wymianą danych w czasie rzeczywistym oraz funkcjami współpracy w aplikacjach internetowych poprzez kanał komunikacji międzydomenowej. Dzięki integracji serwerowej wersji SockJS z IronPDF programiści mogą z łatwością generować i udostępniać dokumenty PDF na podstawie danych dynamicznych lub interakcji użytkownika, jednocześnie wzbogacając swoje aplikacje o zmiany w czasie rzeczywistym. Dzięki tej kombinacji programiści mogą projektować zaawansowane aplikacje internetowe obsługujące różnorodne scenariusze użytkowania, w tym aplikacje intensywnie wykorzystujące dokumenty oraz platformy współpracy, wykorzystując zarówno komunikację w czasie rzeczywistym, jak i dynamiczne tworzenie plików PDF.

Czym jest SockJS NPM?

SockJS to biblioteka JavaScript działająca po stronie przeglądarki, która ułatwia dwukierunkową komunikację w czasie rzeczywistym między klientami internetowymi a serwerami. Abstrahuje WebSocket i oferuje mechanizm awaryjny dla alternatywnych protokołów transportowych, takich jak długie odpytywanie HTTP i strumieniowanie XHR, zapewniając kompatybilność w różnych przeglądarkach internetowych i srodowiskach. Zapewnia prosty interfejs API JavaScript do nawiązywania połączeń i zarządzania nimi oraz obsługi zdarzeń, takich jak otwarcie połączenia, odbiór wiadomości i zamknięcie. Ponadto SockJS zawiera klienta wiersza poleceń do testowania i debugowania, dzięki czemu jest wszechstronny zarówno w środowiskach programistycznych, jak i produkcyjnych. Ogólnie rzecz biorąc, obiekt JavaScript SockJS upraszcza wdrażanie funkcji działających w czasie rzeczywistym w aplikacjach internetowych, obsługując skalowalne i responsywne kanały komunikacyjne.

sockjs NPM (Jak to działa dla programistów): Rysunek 1 – SockJS

Kluczowe funkcje SockJS

Kompatybilność z różnymi przeglądarkami

SockJS zapewnia spójne działanie i funkcjonalność w wielu przeglądarkach internetowych i środowiskach.

Mechanizm awaryjny

Jeśli połączenia WebSocket są niedostępne lub kończą się niepowodzeniem, SockJS może w sposób przejrzysty przełączyć się na inne protokoły transportowe, takie jak długie odpytywanie HTTP, strumieniowanie XHR, a nawet odpytywanie JSONP.

Komunikacja w czasie rzeczywistym

Umożliwia to aplikacjom po stronie serwera (zwykle wykorzystującym Node.js lub inne technologie po stronie serwera) oraz aplikacjom JavaScript po stronie klienta (działającym w przeglądarkach internetowych) komunikację w czasie rzeczywistym i w sposób sterowany zdarzeniami.

Łatwość użytkowania

Ponieważ SockJS oferuje proste API odpowiadające WebSocket, programiści mogą z łatwością włączyć je do swoich projektów i z niego korzystać.

Skalowalność

SockJS ułatwia tworzenie skalowalnych aplikacji, które mogą obsługiwać wiele jednoczesnych połączeń i różne sytuacje sieciowe dzięki obsłudze wielu protokołów transportowych i technik awaryjnych.

Łatwość integracji

Ułatwia wdrażanie funkcji w czasie rzeczywistym, zapewniając proste API, które programiści mogą włączyć do swoich aplikacji internetowych bez konieczności stosowania skomplikowanego programowania sieciowego niskiego poziomu.

Abstrakcja protokołu transportowego:

WebSocket, HTTP long-polling i inne protokoły transportowe są abstrakcyjnie przedstawione przez SockJS. Dzięki swojej elastyczności gwarantowana jest niezawodna komunikacja nawet w sytuacjach, gdy połączenia WebSocket są ograniczone lub niedostępne.

Utwórz i skonfiguruj SockJS

Zazwyczaj konieczne jest skonfigurowanie SockJS zarówno po stronie klienta (w przeglądarce internetowej), jak i po stronie serwera (przy użyciu przeglądarki lub frameworka serwerowego, takiego jak Node.js), aby zbudować i skonfigurować go do komunikacji w czasie rzeczywistym w aplikacji internetowej. Poniżej znajduje się podstawowy przewodnik dotyczący tworzenia i konfiguracji SockJS:

Zainstaluj SockJS

SockJS można zainstalować za pomocą NPM lub dołączyć bezpośrednio poprzez CDN:

npm install sockjs-client
npm install sockjs-client
SHELL

Dodaj SockJS do swojego kodu HTML

Dodaj bibliotekę JavaScript SockJS do tworzonego pliku HTML:

<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

Inicjalizacja połączenia SockJS

Utwórz instancję SockJS w pliku JavaScript (app.js lub podobnym) i połącz się z serwerem:

<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

Zamiast "http://localhost:3000/socket" należy użyć adresu URL punktu końcowego WebSocket po stronie serwera.

sockjs NPM (Jak to działa dla programistów): Rysunek 2 – Wynik połączenia SockJS

Konfiguracja po stronie serwera

Zainstaluj SockJS-Node

Aby zainstalować pakiet SockJS-Node, użyj npm:

npm install sockjs
npm install sockjs
SHELL

Konfiguracja serwera SockJS

Na serwerze Node.js skonfiguruj SockJS:

// 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

Upewnij się, że kod po stronie serwera jest dostosowany do wymagań Twojej aplikacji i współpracuje z posiadaną już platformą serwerową lub konfiguracją.

sockjs NPM (Jak to działa dla programistów): Rysunek 3 – Wynik konfiguracji zgodnej z serwerem SockJS

Żądania międzydomenowe (CORS): Upewnij się, że Twój serwer skutecznie obsługuje ustawienia CORS, jeśli serwer i klient znajdują się w oddzielnych domenach.

Obsługa błędów: Zaimplementuj obsługę błędów i środki bezpieczeństwa (takie jak uwierzytelnianie i autoryzacja) zgodnie ze specyfikacjami Twojej aplikacji.

Wdrożenie: Skonfiguruj HTTPS dla bezpiecznych połączeń oraz skonfiguruj SockJS i swój serwer dla środowisk wdrożeniowych.

Ta konfiguracja stanowi podstawę do nawiązania komunikacji w czasie rzeczywistym między klientem internetowym a serwerem internetowym przy użyciu SockJS. W zależności od wymagań i architektury konkretnej aplikacji mogą być konieczne pewne dostosowania.

Pierwsze kroki

Konfiguracja aplikacji internetowej wykorzystującej możliwości komunikacji w czasie rzeczywistym SockJS oraz integracja IronPDF w celu dynamicznego tworzenia plików PDF to pierwszy krok w rozpoczęciu pracy z SockJS i IronPDF. Oto przewodnik stanowiący punkt wyjścia:

Czym jest IronPDF?

Potężne narzędzie Node.js o nazwie IronPDF służy do przekształcania danych HTML w pliki PDF o wyjątkowo wysokiej jakości. Nie tracąc na jakości oryginalnej treści internetowej, przyspiesza proces konwersji plików HTML, CSS i innych plików JavaScript do poprawnie sformatowanych plików PDF. Jest to bardzo pomocne narzędzie dla aplikacji internetowych, które muszą generować dynamiczne, nadające się do druku dokumenty, takie jak raporty, faktury i certyfikaty.

Konfigurowalne ustawienia stron, nagłówki, stopki oraz możliwość dodawania czcionek i obrazów to tylko niektóre z możliwości IronPDF. Może obsługiwać skomplikowane układy i style, aby zagwarantować, że każdy testowy plik PDF spełnia wymagania. Ponadto IronPDF zarządza wykonywaniem kodu JavaScript w kodzie HTML, umożliwiając precyzyjne renderowanie treści dynamicznych i interaktywnych.

sockjs NPM (Jak to działa dla programistów): Rysunek 4 – IronPDF

Funkcje IronPDF

1. Generowanie plików PDF z HTML

Konwertuj JavaScript, HTML i CSS do formatu PDF. Obsługuje zapytania o media i responsywny projekt, dwa współczesne standardy internetowe. Przydatne do dynamicznego ozdabiania raportów PDF, faktur i dokumentów za pomocą HTML i CSS.

2. Edycja plików PDF

Do istniejących plików PDF można dodawać tekst, obrazy i inne treści. Wyodrębnij tekst i obrazy z plików PDF. Połącz wiele plików PDF w jeden plik. Podziel pliki PDF na wiele oddzielnych dokumentów. Należy uwzględnić znaki wodne, adnotacje, nagłówki i stopki.

3. Wydajność i niezawodność

Wysoka wydajność i niezawodność to cechy projektowe pożądane w środowiskach przemysłowych. Z łatwością zarządza dużymi zbiorami dokumentów.

Zainstaluj IronPDF

Zainstaluj pakiet IronPDF, aby uzyskać narzędzia potrzebne do pracy z plikami PDF w projektach Node.js. Uruchom następujące polecenie:

npm install @ironsoftware/ironpdf
npm install @ironsoftware/ironpdf
SHELL

Połącz SockJS z IronPDF

Skonfiguruj SockJS na serwerze Node.js, aby obsługiwał żądania generowania plików PDF i zarządzał połączeniami klientów:

// 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

Konfiguracja po stronie klienta

Skonfiguruj SockJS po stronie klienta, aby komunikować się z serwerem i wysyłać żądania w celu generowania plików PDF.


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>SockJS + IronPDF Example</title>
</head>
<body>
    <button onclick="generatePdf()">Generate PDF</button>

    <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>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>SockJS + IronPDF Example</title>
</head>
<body>
    <button onclick="generatePdf()">Generate PDF</button>

    <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

Po stronie serwera: Serwer Node.js konfiguruje serwer SockJS (sockjsServer) i nasłuchuje połączeń na ścieżce /socket. Wykorzystuje IronPDF (IronPdf.PdfDocument) do wywołania funkcji generatePdf() w celu obsługi przychodzących komunikatów (żądania generowania plików PDF). Po wygenerowaniu pliku PDF wykorzystuje połączenie SockJS do wysłania danych PDF zakodowanych w base64 z powrotem do klienta.

sockjs NPM (Jak to działa dla programistów): Rysunek 5 – Kod źródłowy klienta SockJS

Po stronie klienta: Klient łączy się z serwerem za pośrednictwem połączenia SockJS (sock) i nasłuchuje zdarzeń, takich jak onopen, onmessage oraz onclose. Użytkownik używa sock.send(htmlContent), aby wysłać zawartość HTML (htmlContent) do serwera w celu wygenerowania pliku PDF po kliknięciu przycisku "Generuj PDF". Wyświetla lub pobiera plik PDF po uzyskaniu danych PDF z serwera (sock.onmessage).

sockjs NPM (Jak to działa dla programistów): Rysunek 6 – Wynik po stronie klienta

Poniżej znajduje się wynik wygenerowany na podstawie kodu.

sockjs NPM (Jak to działa dla programistów): Rysunek 7 – Wynik w formacie PDF

Wnioski

W tworzeniu aplikacji internetowych powstaje silna synergia, gdy SockJS jest używany do komunikacji w czasie rzeczywistym, a IronPDF do dynamicznego tworzenia plików PDF. Dzięki SockJS dwukierunkowa komunikacja między klientami a serwerami staje się łatwa, umożliwiając takie funkcje, jak interaktywna współpraca i aktualizacje w czasie rzeczywistym. Jednak IronPDF daje programistom możliwość tworzenia i modyfikowania dokumentów PDF programowo. Może nawet dynamicznie konwertować tekst HTML na pliki PDF.

Dzięki integracji tych technologii możliwe jest tworzenie złożonych aplikacji internetowych, które mogą natychmiast generować dokumenty PDF w odpowiedzi na działania użytkownika lub aktualizacje danych w czasie rzeczywistym. Integracja ta będzie szczególnie pomocna w aplikacjach wymagających generowania dokumentów w czasie rzeczywistym, edycji grupowej lub funkcji interaktywnego raportowania. Dzięki wykorzystaniu SockJS do natychmiastowych aktualizacji oraz IronPDF do dynamicznego tworzenia plików PDF programiści mogą zoptymalizować doświadczenia użytkowników, usprawnić przepływ pracy oraz zapewnić niezawodne rozwiązania, które spełniają szeroki zakres wymagań biznesowych każdego poważnego użytkownika SockJS.

Możemy zwiększyć użyteczność zestawu narzędzi do tworzenia aplikacji Node.js, wykorzystując IronPDF do dodania funkcji OCR, skanowania kodów kreskowych, tworzenia plików PDF, interakcji z Excelem i wielu innych. Wysoce konfigurowalne systemy Iron Software oraz obszerna biblioteka wtyczek wspieranych przez społeczność umożliwiają programistom szybsze tworzenie funkcji i aplikacji internetowych.

Przed podjęciem decyzji o zakupie programiści mogą skorzystać z licznych funkcji IronPDF w ramach bezpłatnej licencji probnej oraz z szeregu przykładów kodu udostępnionych przez firmę. Aby uzyskać więcej informacji na temat licencji wieczystej IronPDF, odwiedź stronę licencji. Aby uzyskać dalsze instrukcje dotyczące rozpoczęcia korzystania z IronPDF, odwiedź stronę dokumentacji.

Darrius Serrant
Darrius Serrant
  Czat z zespołem inżynierów teraz
Full Stack Software Engineer (WebOps)

Darrius Serrant posiada tytuł licencjata z informatyki z Uniwersytetu Miami i pracuje jako Full Stack WebOps Marketing Engineer w Iron Software. Już od młodych lat zainteresował się kodowaniem, postrzegając informatykę jako zarówno tajemniczą, jak i dostępną, co czyni ją doskonałym medium dla kreatywności ...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie