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

faye NPM (Jak to działa dla programistów)

Darrius Serrant
Darrius Serrant
Zaktualizowano:

IronPDF i Faye pełnią różne role w tworzeniu stron internetowych, ale ich możliwości dobrze się uzupełniają. Korzystając z WebSocket lub innych kompatybilnych protokołów, serwery i klienci internetowi mogą komunikować się w czasie rzeczywistym dzięki pakietowi NPM Faye. Oferuje prosty, ale skuteczny system komunikacji typu pub/sub, który umożliwia tworzenie skalowalnych aplikacji internetowych do natychmiastowej wymiany danych. Najnowsza wersja Faye to 1.4.0, wydana 4 lata temu. Z kolei inny pakiet npm o nazwie IronPDF pozwala programistom programowo tworzyć, modyfikować i konwertować dokumenty PDF w środowiskach Node.js.

Programiści mogą ulepszyć aplikacje internetowe o funkcje tworzenia plików PDF w czasie rzeczywistym, integrując Faye z IronPDF. To połączenie może okazać się bardzo pomocne w aplikacjach wymagających natychmiastowego generowania raportów PDF, dynamicznego tworzenia dokumentów w zależności od danych wprowadzanych przez użytkownika lub zmian danych w czasie rzeczywistym, a także w scenariuszach wspólnej edycji dokumentów. Dzięki narzędziom do tworzenia plików PDF firmy IronPDF oraz funkcjom komunikacji typu "publish-subscribe" w czasie rzeczywistym oferowanym przez Faye programiści mogą projektować interaktywne i elastyczne aplikacje internetowe oparte na danych, które spełniają różnorodne cele użytkowników i biznesowe.

Czym jest Faye?

Wtyczka Node.js o nazwie Faye ułatwia komunikację między klientami a serwerami w czasie rzeczywistym przy użyciu WebSocket lub innych kompatybilnych protokołów transportowych i WebSocket. Oferuje mechanizm komunikacji typu pub/sub, który sprawia, że komunikacja w aplikacjach internetowych jest skalowalna i efektywna. Dzięki płynnej obsłudze połączeń i routingu wiadomości między klientami a serwerami, Faye zamierza uprościć wdrażanie funkcji działających w czasie rzeczywistym — takich jak aktualizacje na żywo, powiadomienia i interakcje oparte na współpracy. Faye jest często wdrażana przez programistów w celu ulepszenia ich aplikacji o funkcje współpracy, interaktywności i responsywności, które wymagają transmisji danych w czasie rzeczywistym między użytkownikami a serwerami.

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

Funkcje Faye

Moduł Faye NPM jest przydatnym narzędziem do integracji komunikatów o zdarzeniach w czasie rzeczywistym z aplikacjami internetowymi, ponieważ zapewnia kilka ważnych funkcji:

  • Obsługa WebSocket i protokołów transportowych: Dzięki obsłudze WebSocket i metod rezerwowych dla alternatywnych protokołów transportowych, takich jak HTTP long-polling, Faye może utrzymywać kanały komunikacji w czasie rzeczywistym z różnymi przeglądarkami i konfiguracjami sieciowymi.

  • Komunikacja typu Pub/Sub: Dzięki wzorcowi komunikacji typu publish/subscribe w Faye użytkownicy mogą subskrybować konkretne kanały (tematy) i otrzymywać aktualizacje lub wiadomości, gdy tylko zostaną tam opublikowane.

  • Skalowalność: Dzięki skalowalnej architekturze może efektywnie zarządzać dużą liczbą jednoczesnych połączeń i komunikatów, co sprawia, że nadaje się do aplikacji wymagających dużej wydajności i szybkości reakcji.

  • Integracja po stronie klienta i serwera: Faye ułatwia płynną komunikację między klientami internetowymi a serwerami poprzez integrację zarówno po stronie klienta (przeglądarka), jak i po stronie serwera (Node.js).

  • Bezpieczeństwo: Aby regulować dostęp do kanałów i wiadomości, wykorzystuje techniki ochrony połączeń WebSocket, a także procedury uwierzytelniania i autoryzacji.

  • Łatwość użytkowania: Programiści mogą tworzyć funkcje, takie jak aktualizacje na żywo, powiadomienia, systemy czatu i inne, przy minimalnej konfiguracji, korzystając z prostego interfejsu API Faye do konfiguracji i zarządzania komunikacją w czasie rzeczywistym.

  • Niezawodność: Faye utrzymuje solidne kanały komunikacyjne, odporne na awarie sieci, zarządzając ponownym łączeniem i gwarantując niezawodność dostarczania wiadomości.

  • Dostosowywanie i rozszerzalność: Dzięki wtyczkom, rozszerzeniom i unikalnym adapterom programiści mogą zwiększyć możliwości Faye i dostarczać specjalistyczne rozwiązania spełniające konkretne potrzeby aplikacji.

Utwórz i skonfiguruj Faye

Aby zbudować i skonfigurować Faye przy użyciu NPM w środowisku Node.js, należy skonfigurować zarówno integrację po stronie klienta, jak i instancję Faye po stronie serwera. Oto instrukcja, która pomoże Ci zacząć:

Konfiguracja po stronie serwera

Zainstaluj Faye

Najpierw zainstaluj pakiet Faye:

npm install faye
npm install faye
SHELL

Utwórz serwer Faye

Upewnij się, że serwer Faye jest skonfigurowany, tworząc plik server.js w Node.js:

// server.js

const http = require('http');
const faye = require('faye');

// Create an HTTP server
const server = http.createServer();

// Mount the Faye server at '/faye'
const bayeux = new faye.NodeAdapter({ mount: '/faye', timeout: 45 });

// Attach Faye to the HTTP server
bayeux.attach(server);

// Start the HTTP server
const PORT = 8000;
server.listen(PORT, () => {
    console.log(`Faye server listening on port ${PORT}`);
});
// server.js

const http = require('http');
const faye = require('faye');

// Create an HTTP server
const server = http.createServer();

// Mount the Faye server at '/faye'
const bayeux = new faye.NodeAdapter({ mount: '/faye', timeout: 45 });

// Attach Faye to the HTTP server
bayeux.attach(server);

// Start the HTTP server
const PORT = 8000;
server.listen(PORT, () => {
    console.log(`Faye server listening on port ${PORT}`);
});
JAVASCRIPT

W tym przypadku serwer HTTP nasłuchujący na porcie 8000 ma serwer Faye zamontowany pod adresem /faye. Dostosuj trasę portu i montowania do potrzeb wersji swojej aplikacji.

Konfiguracja po stronie klienta

Dodaj bibliotekę kliencką Faye do swojej strony HTML lub użyj do tego narzędzia do pakowania modułów, takiego jak Webpack lub Browserify:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Faye Client Example</title>
  </head>
  <body>

    <script
      type="text/javascript"
      src="http://localhost:8000/faye/client.js"
    ></script>

    Enter the Message: 
    <input type="text" id="messageInput">
    <button onclick="sendMessage()">Send</button>

    <script>
      // Initialize Faye client
      const client = new Faye.Client('http://localhost:8000/faye');

      // Subscribe to a channel
      client.subscribe('/channel', function(message) {
          console.log('Received message:', message);
          // Handle received messages
      });

      // Function to publish a message
      function sendMessage() {
          const message = document.getElementById('messageInput').value;
          client.publish('/channel', { text: message });
      }
    </script>
  </body>
</html>
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Faye Client Example</title>
  </head>
  <body>

    <script
      type="text/javascript"
      src="http://localhost:8000/faye/client.js"
    ></script>

    Enter the Message: 
    <input type="text" id="messageInput">
    <button onclick="sendMessage()">Send</button>

    <script>
      // Initialize Faye client
      const client = new Faye.Client('http://localhost:8000/faye');

      // Subscribe to a channel
      client.subscribe('/channel', function(message) {
          console.log('Received message:', message);
          // Handle received messages
      });

      // Function to publish a message
      function sendMessage() {
          const message = document.getElementById('messageInput').value;
          client.publish('/channel', { text: message });
      }
    </script>
  </body>
</html>
HTML

Dostosuj adres URL serwera Faye (http://localhost:8000/faye) oraz kod źródłowy i adres URL skryptu klienta Faye (client.js) do swojej konfiguracji.

Możesz skutecznie dodać funkcje komunikacji w czasie rzeczywistym do swojej aplikacji internetowej Node.js, konfigurując pakiet Faye zgodnie z poniższymi instrukcjami. Zmodyfikuj przykłady zgodnie z architekturą i potrzebami konkretnej aplikacji.

Pierwsze kroki

Przed rozpoczęciem korzystania z IronPDF for Node.js do dynamicznego generowania plików PDF oraz Faye do komunikacji w czasie rzeczywistym konieczne jest skonfigurowanie serwera Node.js do obsługi połączeń z Faye oraz żądań generowania plików PDF. Oto szczegółowa instrukcja:

Czym jest IronPDF?

IronPDF for Node.js to solidny program Node.js przeznaczony do konwersji danych HTML na pliki PDF o niezwykle wysokiej jakości. Przyspiesza proces przekształcania plików HTML, CSS i innych plików JavaScript w poprawnie sformatowane pliki PDF bez utraty jakości oryginalnej treści internetowej. Jest to bardzo przydatne narzędzie dla aplikacji internetowych, które muszą generować dynamiczne, nadające się do druku dokumenty, takie jak faktury, certyfikaty i raporty.

IronPDF posiada kilka funkcji, w tym konfigurowalne ustawienia stron, nagłówki, stopki oraz opcję dodawania czcionek i obrazów. Potrafi obsługiwać złożone style i układy, aby zapewnić, że każdy testowy plik PDF spełnia specyfikacje. Ponadto IronPDF kontroluje wykonywanie kodu JavaScript w HTML, umożliwiając dokładne renderowanie treści dynamicznych i interaktywnych.

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

Funkcje IronPDF

  1. Generowanie plików PDF z HTML: Konwersja HTML, CSS i JavaScript do formatu PDF. Obsługuje dwa nowoczesne standardy internetowe: zapytania o media i projekt responsywny. Przydatne do dynamicznego formatowania dokumentów PDF, faktur i raportów przy użyciu HTML i CSS.

  2. Edycja plików PDF: Możliwe jest dodawanie tekstu, obrazów i innych materiałów do już istniejących plików PDF. Wyodrębnij tekst i obrazy z plików PDF. Połącz wiele plików PDF w jeden plik. Podziel pliki PDF na kilka oddzielnych dokumentów. Dodaj nagłówki, stopki, adnotacje i znaki wodne.

  3. Wydajność i niezawodność: W kontekście przemysłowym wysoka wydajność i niezawodność są pożądanymi cechami projektowymi. Z łatwością obsługuje duże zbiory dokumentów.

Zainstaluj IronPDF

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

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

Połącz Faye z IronPDF

Stwórz podstawowy serwer Node.js, który łączy IronPDF for Node.js do tworzenia plików PDF z Faye do przesyłania wiadomości w czasie rzeczywistym:

// server.js

const http = require('http');
const faye = require('faye');
const IronPdf = require('@ironsoftware/ironpdf');

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

// Create an HTTP server
const server = http.createServer();

// Create a Faye server
const bayeux = new faye.NodeAdapter({ mount: '/faye', timeout: 45 });

// Attach the Faye server to the HTTP server
bayeux.attach(server);

// Handle Faye client connections
bayeux.on('handshake', function(clientId) {
    console.log(`Client connected: ${clientId}`);
});

// Handle incoming messages for PDF generation
bayeux.on('publish', async function (clientId, channel, data) {
    if (channel === '/generate_pdf') {
        console.log(`Received PDF generation request from client ${clientId}: ${data.htmlContent}`);
        // Generate PDF using IronPDF
        let pdfData = await generatePdf(data.htmlContent);
        var base64String = btoa(String.fromCharCode.apply(null, new Uint8Array(pdfData)));
        bayeux.getClient().publish(`/pdf_result/${clientId}`, { pdfData: base64String });
    }
});

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

const http = require('http');
const faye = require('faye');
const IronPdf = require('@ironsoftware/ironpdf');

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

// Create an HTTP server
const server = http.createServer();

// Create a Faye server
const bayeux = new faye.NodeAdapter({ mount: '/faye', timeout: 45 });

// Attach the Faye server to the HTTP server
bayeux.attach(server);

// Handle Faye client connections
bayeux.on('handshake', function(clientId) {
    console.log(`Client connected: ${clientId}`);
});

// Handle incoming messages for PDF generation
bayeux.on('publish', async function (clientId, channel, data) {
    if (channel === '/generate_pdf') {
        console.log(`Received PDF generation request from client ${clientId}: ${data.htmlContent}`);
        // Generate PDF using IronPDF
        let pdfData = await generatePdf(data.htmlContent);
        var base64String = btoa(String.fromCharCode.apply(null, new Uint8Array(pdfData)));
        bayeux.getClient().publish(`/pdf_result/${clientId}`, { pdfData: base64String });
    }
});

// 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 Faye po stronie klienta, aby komunikowała się z serwerem i wysyłała żądania tworzenia plików PDF:

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

    <script src="https://cdn.jsdelivr.net/npm/faye/browser/faye-browser.min.js"></script>

    <script>
        // Initialize Faye client
        const client = new Faye.Client('http://localhost:3000/faye');

        // Subscribe to receive PDF result messages
        client.subscribe('/pdf_result/*', function(message) {
            console.log('PDF received:', message);
            displayPdf(message.pdfData);
        });

        // Function to request PDF generation
        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
            client.publish('/generate_pdf', { htmlContent: htmlContent });
        }

        // Function to display the generated PDF
        function displayPdf(pdfData) {
            // Example: Display or download PDF data received from server
            const pdfBlob = new Blob([Uint8Array.from(atob(pdfData), c => c.charCodeAt(0))], { 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>Faye + IronPDF Example</title>
</head>
<body>
    <button onclick="generatePdf()">Generate PDF</button>

    <script src="https://cdn.jsdelivr.net/npm/faye/browser/faye-browser.min.js"></script>

    <script>
        // Initialize Faye client
        const client = new Faye.Client('http://localhost:3000/faye');

        // Subscribe to receive PDF result messages
        client.subscribe('/pdf_result/*', function(message) {
            console.log('PDF received:', message);
            displayPdf(message.pdfData);
        });

        // Function to request PDF generation
        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
            client.publish('/generate_pdf', { htmlContent: htmlContent });
        }

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

Po stronie serwera: Serwer Faye (bayeux) jest zintegrowany z serwerem Node.js, który konfiguruje również serwer HTTP. Na kanale /generate_pdf monitoruje przychodzące wiadomości i połączenia klientów. Po otrzymaniu żądania wygenerowania pliku PDF konwertuje dostarczone informacje HTML do formatu PDF przy użyciu IronPDF i zwraca gotowe dane PDF w postaci łatwej w użyciu wiadomości do klienta.

Po stronie klienta: Aby uzyskać wygenerowane dane PDF, klient przeglądarki tworzy połączenie Faye (client) z serwerem i subskrybuje kanał /pdf_result/*. Przycisk "Generuj PDF" powoduje, że użytkownik wysyła żądanie treści HTML do serwera, który następnie wykorzystuje je do wygenerowania pliku PDF przy użyciu client.publish('/generate_pdf', { htmlContent: htmlContent }). Wyświetla lub pobiera plik PDF po otrzymaniu danych PDF.

Wnioski

Dzięki integracji Faye z IronPDF oferowane jest niezawodne rozwiązanie dla współczesnych aplikacji internetowych, łączące zalety dynamicznego tworzenia plików PDF i komunikacji w czasie rzeczywistym. Natychmiastowa komunikacja klient-serwer jest możliwa dzięki systemowi komunikatów pub/sub Faye, który obsługuje aplikacje wymagające aktualizacji w czasie rzeczywistym, takie jak narzędzia do śledzenia błędów, powiadomienia i funkcje pracy zespołowej. Natomiast IronPDF umożliwia programowe tworzenie, modyfikowanie i konwersję dokumentów PDF, umożliwiając dynamiczne generowanie raportów, faktur i innych dokumentów w odpowiedzi na dane wprowadzane przez użytkownika lub dane w czasie rzeczywistym.

Technologie te można zintegrować w celu dostarczania dynamicznie tworzonych materiałów i natychmiastowej informacji zwrotnej, co może poprawić komfort użytkowania. Na przykład użytkownicy nie muszą czekać na zakończenie procesu wsadowego ani odświeżać strony internetowej, aby otrzymać raport w formacie PDF, który jest przetwarzany natychmiast. Dzięki tej płynnej interakcji aplikacje internetowe stają się bardziej responsywne i wydajne, co zwiększa ich interaktywność i przyjazność dla użytkownika.

Dzięki integracji IronPDF i Iron Software możemy dodać do zestawu narzędzi do tworzenia aplikacji Node.js funkcje OCR, skanowania kodów kreskowych, generowania plików PDF, interakcji z Excelem i wiele innych, zwiększając jego użyteczność. Ogromna biblioteka wtyczek wspieranych przez społeczność oraz wysoce konfigurowalne technologie firmy Iron Software pozwalają programistom szybciej tworzyć funkcje i aplikacje internetowe.

Przed podjęciem decyzji o zakupie programiści mogą skorzystać z wielu funkcji IronPDF dzięki bezpłatnej licencji probnej oraz różnorodnym przykładom kodu źródłowego udostępnionym przez firmę. Więcej informacji na temat licencji wieczystej IronPDF można znaleźć na stronie licencji. Przejdź do strony dokumentacji projektu, aby uzyskać więcej informacji na temat rozpoczęcia korzystania z IronPDF.

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