Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF for Node.js
  2. Blog do IronPDF for Node.js
  3. Ajuda do Node
  4. Falha do NPM
AJUDA DO NODE

faye NPM (Como funciona para desenvolvedores)

Darrius Serrant
Darrius Serrant
Atualizado:

IronPDF e Faye desempenham papéis diferentes no desenvolvimento web, mas suas habilidades se complementam muito bem. Graças ao pacote NPM Faye, que utiliza WebSocket ou outros protocolos de transporte compatíveis, servidores e clientes web podem se comunicar em tempo real. Oferece um sistema de mensagens pub/sub simples, porém eficaz, que permite aplicações web escaláveis ​​e de compartilhamento instantâneo de dados. A versão mais recente do Faye é a 1.4.0, publicada há 4 anos. Por outro lado, outro pacote npm chamado IronPDF permite que os desenvolvedores criem, modifiquem e convertam documentos PDF programaticamente em ambientes Node.js

Os desenvolvedores podem aprimorar aplicativos da web com recursos de produção de PDF em tempo real integrando o Faye ao IronPDF. Aplicações que necessitam da geração instantânea de relatórios em PDF, geração dinâmica de documentos dependendo das entradas do usuário ou de alterações de dados em tempo real, e cenários de edição colaborativa de documentos podem achar essa conexão muito útil. Com a ajuda das ferramentas de criação de PDFs do IronPDF e dos recursos de mensagens de publicação/assinatura simples e em tempo real do Faye, os desenvolvedores podem criar aplicativos da web interativos, adaptáveis ​​e orientados a dados que atendem a uma variedade de objetivos de usuários e negócios.

O que é Faye?

Um plugin do Node.js chamado Faye facilita a comunicação em tempo real entre clientes e servidores usando WebSocket ou outros protocolos de transporte e WebSocket compatíveis. Oferece um mecanismo de mensagens pub/sub que torna a comunicação de aplicações web escalável e eficaz. Ao gerenciar conexões e roteamento de mensagens entre clientes e servidores de forma fluida, o Faye pretende simplificar a implementação de funcionalidades em tempo real, como atualizações ao vivo, notificações e interações colaborativas. A Faye é frequentemente integrada por desenvolvedores para aprimorar seus aplicativos com recursos colaborativos, interativos e responsivos que exigem transmissão de dados em tempo real entre usuários e servidores.

faye NPM (Como funciona para desenvolvedores): Figura 1 - Faye

Características de Faye

O módulo Faye NPM é uma ferramenta útil para integrar mensagens de eventos em tempo real em aplicações web, pois oferece diversos recursos importantes:

  • Suporte a WebSocket e protocolos de transporte: Com suporte a WebSocket e métodos alternativos para protocolos de transporte, como HTTP long-polling, o Faye pode manter canais de comunicação em tempo real com diferentes navegadores e configurações de rede.

  • Mensagens Pub/Sub: Com a ajuda do padrão de mensagens de publicação/assinatura do Faye, os usuários podem se inscrever em canais (tópicos) específicos e receber atualizações ou mensagens assim que forem publicadas.

  • Escalabilidade: Graças à sua arquitetura escalável, consegue gerir eficazmente um grande número de ligações e mensagens simultâneas, sendo, portanto, adequado para aplicações que exigem um elevado desempenho e capacidade de resposta.

  • Integração do lado do cliente e do servidor: Faye facilita a comunicação fluida entre clientes web e servidores, integrando tanto o lado do cliente (navegador) quanto o lado do servidor (Node.js).

  • Segurança: Para regular o acesso a canais e mensagens, incorpora técnicas para proteger conexões WebSocket, bem como para realizar procedimentos de autenticação e autorização.

  • Facilidade de uso: Os desenvolvedores podem criar recursos como atualizações ao vivo, notificações, sistemas de bate-papo e muito mais com pouca configuração, usando a API intuitiva do Faye para configurar e gerenciar comunicações em tempo real.

  • Confiabilidade: A Faye mantém canais de comunicação robustos e resistentes a interrupções de rede, gerenciando reconexões e garantindo a entrega confiável de mensagens.

  • Personalização e extensibilidade: Com o uso de plugins, extensões e adaptadores exclusivos, os desenvolvedores podem aumentar a capacidade do Faye e fornecer soluções especializadas para atender a necessidades específicas de aplicativos.

Criar e configurar Faye

Tanto a integração do lado do cliente quanto a instância do Faye do lado do servidor devem ser configuradas para construir e configurar o Faye usando o NPM em um ambiente Node.js Aqui está um manual prático para você começar:

Configuração do lado do servidor

Instalar Faye

Instale primeiro o pacote Faye:

npm install faye
npm install faye
SHELL

Criar servidor Faye

Certifique-se de que o servidor Faye esteja configurado criando um arquivo server.js em 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

Neste caso, um servidor HTTP que escuta na porta 8000 tem o servidor Faye montado em /faye. Adapte a porta e a rota de montagem às necessidades da versão da sua aplicação.

Configuração do lado do cliente

Adicione a biblioteca cliente Faye à sua página HTML ou utilize um bundler de módulos como o Webpack ou o Browserify para fazer isso:

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

Adapte o URL do servidor Faye (http://localhost:8000/faye) e o código-fonte e URL do script do cliente Faye (client.js) à sua configuração.

Você pode adicionar recursos de mensagens em tempo real ao seu aplicativo web Node.js configurando o pacote Faye seguindo estas instruções. Modifique os exemplos de acordo com a arquitetura e as necessidades da sua aplicação específica.

Começando

Você precisará configurar um servidor Node.js para lidar com as conexões Faye e as solicitações de geração de PDF antes de poder usar o IronPDF para geração dinâmica de PDFs e o Faye para comunicações em tempo real. Aqui está um guia detalhado:

O que é o IronPDF?

IronPDF for Node.js é um programa robusto em Node.js projetado para converter dados HTML em arquivos PDF de altíssima qualidade. Ele acelera o processo de conversão de arquivos HTML, CSS e outros arquivos JavaScript em PDFs formatados corretamente, sem comprometer o conteúdo original online. Esta é uma ferramenta extremamente útil para aplicações web que precisam gerar documentos dinâmicos e imprimíveis, como faturas, certificados e relatórios.

O IronPDF possui diversos recursos, incluindo configurações de página personalizáveis, cabeçalhos, rodapés e a opção de adicionar fontes e imagens. Ele consegue gerenciar estilos e layouts complexos para garantir que cada PDF de teste gerado atenda às especificações. Além disso, o IronPDF controla a execução de JavaScript dentro do HTML, permitindo uma renderização de conteúdo dinâmica e interativa precisa.

faye NPM (Como funciona para desenvolvedores): Figura 4 - IronPDF

Funcionalidades do IronPDF

  1. Geração de PDF a partir de HTML: Converta HTML, CSS e JavaScript em PDF. Suporta dois padrões modernos da web: media queries e design responsivo. Útil para usar HTML e CSS para decorar dinamicamente documentos PDF, faturas e relatórios.

  2. Edição de PDF: É possível adicionar texto, imagens e outros materiais a PDFs já existentes. Extrair texto e imagens de arquivos PDF. Mesclar vários PDFs em um único arquivo. Dividir arquivos PDF em vários documentos distintos. Adicione cabeçalhos, rodapés, anotações e marcas d'água.

  3. Desempenho e Confiabilidade: Em contextos industriais, alto desempenho e confiabilidade são atributos de projeto desejáveis. Lida facilmente com grandes conjuntos de documentos.

Instale o IronPDF

Para obter as ferramentas necessárias para trabalhar com PDFs em projetos Node.js , instale o pacote IronPDF . Execute o seguinte comando:

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

Combine Faye com IronPDF

Crie um servidor Node.js rudimentar que combine o IronPDF para geração de PDFs com o Faye para mensagens em tempo real:

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

Configuração do lado do cliente

Configure o Faye no lado do cliente para interagir com o servidor e enviar solicitações para a criação de PDFs:

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

Lado do servidor: Um servidor Faye (bayeux) é integrado pelo servidor Node.js , que também configura um servidor HTTP. No canal /generate_pdf, ele monitora mensagens recebidas e conexões de clientes. Ao receber uma solicitação para geração de PDF, o sistema converte as informações HTML fornecidas em um PDF usando o IronPDF e retorna os dados do PDF finalizado como uma mensagem fácil de usar para o cliente.

Lado do cliente: Para obter os dados PDF gerados, o cliente do navegador cria uma conexão Faye (client) com o servidor e se inscreve no canal /pdf_result/*. O botão "Gerar PDF" faz com que o usuário envie uma solicitação de conteúdo HTML para o servidor, que então usa o servidor para gerar um PDF usando client.publish('/generate_pdf', { htmlContent: htmlContent }). O programa exibe ou baixa o PDF após receber os dados do arquivo.

Conclusão

Ao integrar o Faye com o IronPDF, oferece-se uma solução confiável para aplicações web contemporâneas, combinando os benefícios da criação dinâmica de PDFs e do envio de mensagens em tempo real. A comunicação instantânea entre cliente e servidor é possível graças ao sistema de mensagens pub/sub do Faye, que suporta aplicações que necessitam de atualizações em tempo real, como rastreadores de bugs, notificações e recursos de trabalho em equipe. Em contrapartida, o IronPDF permite a criação, modificação e conversão programática de documentos PDF, possibilitando a geração dinâmica de relatórios, faturas e outros documentos em resposta à entrada do usuário ou a dados em tempo real.

Essas tecnologias podem ser integradas para fornecer material criado dinamicamente e feedback instantâneo, o que pode melhorar a experiência do usuário. Por exemplo, os consumidores não precisam esperar pelo processamento em lote nem atualizar a página da web para receber uma solicitação de relatório em PDF que é processada instantaneamente. Graças a essa interação fluida, os aplicativos da Web tornam-se mais responsivos e eficientes, aumentando sua interatividade e facilidade de uso.

Ao integrar o IronPDF e o Iron Software , podemos adicionar OCR, leitura de código de barras, saída em PDF, interação com o Excel e muitas outras funcionalidades ao seu conjunto de ferramentas de desenvolvimento de aplicativos Node.js , aumentando sua utilidade. A vasta biblioteca de plugins com suporte da comunidade e as tecnologias altamente configuráveis ​​da Iron Software permitem que os desenvolvedores criem recursos e aplicativos da web mais rapidamente.

Antes de decidir comprar, os desenvolvedores podem aproveitar os diversos recursos do IronPDF com uma licença de avaliação gratuita e vários exemplos de código-fonte fornecidos pela empresa. Consulte a página de licença para obter mais detalhes sobre o licenciamento perpétuo do IronPDF. Acesse a página de documentação do projeto para obter mais detalhes sobre como começar a usar o IronPDF.

Darrius Serrant
Darrius Serrant
  Converse agora mesmo com a equipe de engenharia.
Engenheiro de Software Full Stack (WebOps)

Darrius Serrant é bacharel em Ciência da Computação pela Universidade de Miami e trabalha como Engenheiro de Marketing WebOps Full Stack na Iron Software. Atraído por programação desde jovem, ele via a computação como algo misterioso e acessível ao mesmo tempo, tornando-a o meio ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim