deepstream io (Jak to działa dla programistów)
Serwer działający w czasie rzeczywistym jest zaprojektowany tak, aby natychmiast reagować na dane, dzięki czemu błyskawicznie odpowiada na każdą interakcję użytkownika lub zdarzenie systemowe. W przeciwieństwie do konwencjonalnych serwerów typu żądanie-odpowiedź, które powodują opóźnienia, [serwery](https://en.wikipedia.org/wiki/Server_(computing) działające w czasie rzeczywistym wykorzystują technologie i protokoły zapewniające ciągłą wymianę informacji i natychmiastowe aktualizacje. Wynika to z faktu, że serwer działający w czasie rzeczywistym ma kluczowe znaczenie dla wielu aplikacji wymagających komunikacji na żywo: systemów komunikacyjnych, gier online, platform transakcyjnych oraz narzędzi do współpracy. W tym artykule dowiemy się, jak korzystać z otwartego serwera działającego w czasie rzeczywistym deepstream oraz IronPDF do generowania plików PDF.
deepstream.io to skalowalny serwer działający w czasie rzeczywistym, służący do synchronizacji danych i komunikacji typu "wiele do wielu". Z łatwością radzi sobie z danymi i zapewnia synchronizację wielu klientów przy naprawdę niskim opóźnieniu, obsługując transfer danych binarnych. deepstream.io jest zaprojektowany do umieszczenia za innymi systemami równoważenia obciążenia i balancerami i oferuje wydajny sposób synchronizacji danych oraz aktualizacji plików zasobów, co sprawia, że idealnie nadaje się do aplikacji aktualizujących dane w czasie rzeczywistym i poszukujących skalowalnego rozwiązania serwerowego.
Wdrożenie deepstream.io przez programistów pozwala w łatwy sposób na aktualizacje na żywo, aplikacje oparte na współpracy oraz interaktywne doświadczenia w czasie rzeczywistym, bez konieczności rozpoczynania od zera. Zostało zaprojektowane z myślą o dużym obciążeniu i wydajnym skalowaniu, co czyni je oprogramowaniem z wyboru dla aplikacji o wysokiej współbieżności. deepstream.io jest elastyczne i może okazać się idealnym uzupełnieniem Twojego stosu technologicznego na wiele różnych sposobów. Zapewnia kompletne rozwiązanie, które pozwala użytkownikom tworzyć responsywne i interaktywne aplikacje internetowe oraz mobilne działające w czasie rzeczywistym.
Aby utworzyć nowy katalog Node.js, wprowadź następujące polecenia w konsoli:
mkdir deepstream-project
cd deepstream-project
npm init -ymkdir deepstream-project
cd deepstream-project
npm init -yZainstaluj pakiet deepstream.io
Przede wszystkim należy zainstalować deepstream.io. Można zainstalować je za pomocą NPM lub pobrać pliki binarne z oficjalnej strony internetowej.
npm install @deepstream/servernpm install @deepstream/serverPodstawowa konfiguracja 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();Powyższy fragment kodu pokazuje, jak skonfigurować i uruchomić serwer deepstream.io przy użyciu pakietu @deepstream/server w Node.js. Najpierw importuje klasę Deepstream z pakietu, a następnie tworzy nową instancję. Wywołanie server.start() powoduje uruchomienie serwera i przygotowanie go do przyjmowania połączeń przychodzących w celu obsługi usług backendowych związanych z powiązaniem danych w czasie rzeczywistym, przesyłaniem wiadomości lub obecnością.
Łączenie Deepstream z klientem
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);Powyższy kod pokazuje, jak połączyć się z deepstreamem za pomocą biblioteki @deepstream/client. Ten skrypt importuje klasę DeepstreamClient, tworzy instancję i łączy ją z serwerem deepstream działającym lokalnie pod adresem IP 127.0.0.1 na porcie 6020. Loguje się bez podawania danych uwierzytelniających, co jest wystarczające, jeśli serwer nie korzysta z uwierzytelniania lub jest używany do testów. Ta konfiguracja inicjuje klienta zdolnego do synchronizacji danych i komunikacji w czasie rzeczywistym.
Po nawiązaniu połączenia z węzłem serwera w konsoli serwera pojawi się komunikat podobny do poniższego.
Korzystanie z Listenera z deepstream.io
Poniżej znajduje się przykładowy kod, który można wykorzystać do tworzenia listenerów, jednej z podstawowych koncepcji 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!" });
}
});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!" });
}
});W powyższym kodzie klient loguje się do serwera deepstream hostowanego pod adresem 127.0.0.1:6020 przy użyciu biblioteki @deepstream/client. Po pomyślnym uwierzytelnieniu publikuje niestandardowe zdarzenie o nazwie "custom-event" z ładunkiem { message: "Hello, Deepstream!" }.
Przedstawiamy IronPDF
Użyj IronPDF, niezwykle wydajnego pakietu Node.js, do tworzenia, edytowania i konwertowania dokumentów PDF. Jest to narzędzie wykorzystywane w większości procesów programistycznych związanych z plikami PDF oraz w procesach zaplecza, takich jak modyfikowanie istniejących plików PDF i konwersja HTML na PDF. W aplikacjach, w których konieczne jest dynamiczne tworzenie i obsługa plików PDF, IronPDF staje się bardzo pomocny. Zapewnia przyjazny dla użytkownika i elastyczny sposób generowania wysokiej jakości dokumentów PDF.
Zainstaluj pakiet IronPDF
Użyj npm, aby pobrać i zainstalować pakiety, które umożliwiają korzystanie z funkcji IronPDF w Node.js.
npm install @ironsoftware/ironpdfnpm install @ironsoftware/ironpdfFunkcja generowania plików PDF
Utwórz funkcję, która wykorzystuje IronPDF do generowania plików PDF:
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;Konfiguracja klienta Deepstream
Napisz skrypt JavaScript, który będzie nasłuchiwał danych w czasie rzeczywistym i generował pliki PDF na podstawie tych danych:
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');
}
});Publikowanie zdarzeń w celu wygenerowania pliku PDF
Zdarzenia mogą być publikowane w celu wywołania generowania pliku PDF z innego pliku JavaScript lub części aplikacji:
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.'
});
});Deepstream.io działa poprzez nasłuchiwanie zdarzeń w czasie rzeczywistym, które uruchamiają generowanie plików PDF. Funkcja generatePDF tworzy dokument PDF na podstawie danych z wydarzeń Deepstream.io przy użyciu IronPDF. DeepstreamClient subskrybuje te zdarzenia i za każdym razem, gdy publikowane są odpowiednie zdarzenia, wywołuje funkcję generowania pliku PDF. Taka integracja umożliwia dynamiczne generowanie plików PDF w czasie rzeczywistym na podstawie zdarzeń, żądań lub zmian danych.
Licencjonowanie
Aby kod kompilował się i działał bez znaku wodnego, wymagany jest klucz licencyjny. Programiści, którzy chcieliby uzyskać Licencję Trial, mogą zarejestrować się tutaj. Aby je uzyskać, nie trzeba podawać danych karty kredytowej. Aby zarejestrować się na bezpłatny okres próbny, wystarczy podać swój adres e-mail.
Wnioski
Jedno z najskuteczniejszych rozwiązań do przetwarzania danych w czasie rzeczywistym i dynamicznego generowania dokumentów uzyskuje się dzięki połączeniu deepstream.io i IronPDF. deepstream.io synchronizuje zmiany i rejestruje wszystkie zdarzenia w czasie rzeczywistym, dzięki czemu może natychmiast reagować na każdą zmianę w danych. IronPDF zapewnia solidny mechanizm do tworzenia profesjonalnych dokumentów w locie. Ta integracja umożliwi Twoim aplikacjom automatyczne tworzenie i przetwarzanie dokumentów PDF nie tylko w przypadku zmian danych na żywo, ale również za każdym razem, gdy użytkownik wchodzi w interakcję z aplikacją.
Niezależnie od tego, czy chodzi o generowanie raportów, faktur czy jakichkolwiek innych dokumentów, deepstream.io zintegrowane z IronPDF pozwala uprościć przepływ pracy, tworzyć responsywne dokumenty oraz utrzymać aplikację w stanie aktualnym dzięki informacjom w czasie rzeczywistym. To połączenie sprawdza się najlepiej w przypadku zwinnych, opartych na danych i responsywnych aplikacji, które wymagają generowania dokumentów w czasie rzeczywistym oraz wsparcia w zakresie zarządzania nimi.
Biblioteki dostarczane przez Iron Software pozwalają nam szybko i łatwo tworzyć programy dla różnych systemów operacyjnych, przeglądarek i platform, w tym Windows, Android, MAC, Linux itp.
Rozpocznij za DARMO
Rozpocznij za DARMO
Zarezerwuj darmowe Demo na żywo
Nie wymaga karty kredytowej ani tworzenia konta
