A body-parser egy Node.js middleware modul, amely
megkönnyíti a bejövő HTTP-kérések body részének kezelését. Ez a modul különösen
hasznos akkor, ha az űrlapadatokat vagy JSON-tartalmat szeretnél fogadni és
feldolgozni egy POST vagy PUT kérés során az Express-ben.
Miért van szükség a
body-parser-re?
Alapértelmezésben a Node.js és az Express nem képes a
kérések törzsét automatikusan feldolgozni. Ezért van szükség a body-parser
modulra, amely a kérések törzsét elérhetővé teszi a req.body objektumon
keresztül.
Telepítése: npm install body-parser
Példa a használatára:
const express = require('express');
const bodyParser = require('body-parser');
const app = express();
// A body-parser használata JSON formátumú adatok
feldolgozásához
/* app.use(bodyParser.json()): Ez a middleware lehetővé
teszi, hogy JSON típusú kéréseket tudjunk feldolgozni, így például egy API-ban
érkező JSON adatok a req.body-ban lesznek elérhetők. */
app.use(bodyParser.json());
// A body-parser használata URL-kódolt adatok
feldolgozásához
/* app.use(bodyParser.urlencoded({ extended: true })): Ez az
opció az űrlapokon keresztül küldött URL-kódolt adatokat dolgozza fel (mint a
HTML form elemek application/x-www-form-urlencoded típusa). Az extended: true
opció lehetővé teszi, hogy összetett objektumokat (pl. beágyazott objektumokat)
is kezeljünk. */
console.log('Szerver
fut a http://localhost:3000 címen');
});
Működés:
Ha egy POST kérés érkezik a /submit útvonalra, például egy
HTML űrlapból, a body-parser feldolgozza a kérést, és az adatokat a req.body
objektumban tárolja. Ezután az adatok hozzáférhetők a további feldolgozáshoz
vagy válaszként történő küldéshez.
Extended beállítás a
urlencoded metódusnál
extended: true: Lehetővé teszi, hogy összetett
adatstruktúrák, például beágyazott objektumok is kezelhetők legyenek (azaz
nemcsak sima string értékeket tudsz fogadni).
extended: false: Csak egyszerű key-value párokat enged
feldolgozni, például az alapvető URL-kódolt formákat.
Az express újabb verzióiban (pl. Express 4.x-től) a
body-parser bizonyos funkciói beépítésre kerültek az Express alapvető
részeként, így külön body-parser telepítése nem mindig szükséges, mivel
használhatod az Express saját beépített módszereit is:
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
vagyis nem kell külön telepíteni. Ezért nézzük meg a verzió számot.
Az Express.js a Node.js egyik legnépszerűbb és legszélesebb körben használt
keretrendszere. Ez egy minimalista és rugalmas webes keretrendszer, amely
egyszerűsíti a webalkalmazások és API-k fejlesztését. Az Express.js a
Node.js-re épül, és lehetővé teszi, hogy gyorsan és hatékonyan fejlesszünk
webes szervereket, mivel számos olyan alapvető funkciót biztosít, amelyekkel
különben kézzel kellene bajlódnunk.
Mi az az Express.js?
Az Express.js egy Node.js
alapú, nyílt forráskódú webes alkalmazáskeretrendszer, amelyet főleg
kiszolgálói alkalmazások készítésére használnak. Az Express segítségével
gyorsan és könnyen létrehozhatunk weboldalakat és webes API-kat. Ez a
keretrendszer azért vált népszerűvé, mert megkönnyíti a HTTP kérések és válaszok
kezelését, a különböző útvonalak (routing) beállítását, valamint a
middleware-ek alkalmazását, amelyek speciális funkciókat biztosítanak.
Az Express.js
Telepítése
Mielőtt használni kezdhetjük az Express.js-t, telepítenünk kell. Ehhez
először telepíteni kell a Node.js-t, majd a Node Package Manager (npm)
segítségével az Express-t.
Nyisd meg a terminált (vagy parancssort) és hozd
létre az alkalmazásod mappáját:
mkdir my-express-app
cd my-express-app
Inicializáld az npm-et a mappában:
npm init -y
Telepítsd az Express.js-t:
npm install express --save
Egyszerű Express.js
Alkalmazás Létrehozása
Az alábbi kód egy egyszerű Express.js alkalmazás, amely egy HTTP szervert
hoz létre, és válaszol a bejövő kérésekre.
// Az express modul importálása
const express = require('express');
// Egy új express alkalmazás létrehozása
const app = express();
// Egy útvonal kezelése a gyökér URL-re ('/')
app.get('/', (req, res) => {
res.send('Hello, Express.js!');
});
// A szerver elindítása és figyelés egy adott porton (3000)
app.listen(3000, () => {
console.log('Szerver fut a http://localhost:3000 címen');
});
1.const express =
require('express');:
Az express
modul importálása szükséges ahhoz, hogy használni tudjuk az Express.js
keretrendszert. Ez a sor betölti az Express modulját, amit később az app nevű változóban
fogunk használni.
2.const app = express();:
Az express()
meghívása létrehoz egy új Express alkalmazást, amely egy HTTP szerverként
fog viselkedni. Az app
nevű változóban tároljuk az alkalmazást, hogy később hozzáférjünk a
különböző funkcióihoz.
3.app.get('/', (req, res)
=> { ... });:
Itt definiálunk egy útvonalat a gyökér URL-re
(azaz a / útvonalra). Ez azt
jelenti, hogy ha valaki meglátogatja az alkalmazást a böngészőjében a
gyökér URL-en, akkor a megadott callback függvény fut le.
A callback függvény két paramétert kap: req (request) és res (response). A req tartalmazza a
kliens által küldött kérés részleteit, a res pedig azt az objektumot, amellyel
válaszolhatunk a kliensnek.
A res.send('Hello,
Express.js!'); sor elküldi a válaszként a "Hello,
Express.js!" szöveget a kliensnek.
4.app.listen(3000, ()
=> { ... });:
Ezzel a sorral indítjuk el a szervert, és
megadjuk, hogy melyik porton figyeljen (ebben az esetben a 3000-es
porton). Amikor a szerver sikeresen elindul, a callback függvény fut le,
és kiírja a konzolra, hogy a szerver fut.
A routing az az eljárás, amellyel az alkalmazás
meghatározza, hogyan válaszoljon a bejövő kérésekre egy adott URL-re. Az
Express.js ezt rendkívül egyszerűvé teszi. Különböző HTTP módszereket (pl. GET,
POST, PUT, DELETE) használhatunk, hogy különböző típusú kéréseket kezeljünk.
Erre példának, egy komplex feladatot fogunk megoldani közösen.
A middleware az Express.js egyik legfontosabb
eleme. A middleware-ek olyan függvények, amelyek a bejövő kérések és a
kiszolgált válaszok közötti folyamatokat kezelik. Ezek a függvények lehetővé
teszik, hogy módosítsuk a kérés és válasz objektumokat, befejezzük a kérelem-
és válaszfolyamatot, vagy továbblépjünk a következő middleware-re.
Példa Egy Egyszerű
Middleware-re
const express = require('express');
const app = express();
// Egy egyszerű middleware, amely minden kérésnél lefut
app.use((req, res, next) => {
console.log(`${req.method} kérés érkezett a(z) ${req.url} URL-re`);
next(); // Tovább lép a következő middleware-re vagy útvonalra
});
// Kezelés a gyökér URL-re
app.get('/', (req, res) => {
res.send('Kezdőlap');
});
// Kezelés az '/about' URL-re
app.get('/about', (req, res) => {
res.send('About oldal');
});
app.listen(3000, () => {
console.log('Szerver fut a http://localhost:3000 címen');
});
Middleware Kód
Magyarázata
app.use((req, res, next) => { ...
});:
Az app.use
metódussal definiálunk egy általános middleware-t, amely minden egyes
bejövő kérésnél lefut.
A middleware függvény három paramétert kap: req (kérés), res (válasz) és next (egy függvény,
amely a következő middleware-t vagy útvonalkezelőt hívja meg).
Ebben az esetben a middleware naplózza a konzolra
a kérés típusát (pl. GET) és a kért URL-t. Ezután a next() meghívásával a
folyamat továbbhalad a következő middleware-re vagy útvonalkezelőre.
Példák és Gyakorlati
Feladatok
Példa 1: Alapvető
Routing
Hozz létre egy Express.js alkalmazást, amely különböző útvonalakat kezel:
GET /: Válaszoljon
"Főoldal".
GET /about:
Válaszoljon "Rólunk".
GET /contact:
Válaszoljon "Kapcsolat".
GET *: Válaszoljon
"404 - Az oldal nem található", ha a felhasználó egy nem létező
oldalra próbál navigálni.
Megoldás:
const express = require('express');
const app = express();
app.get('/', (req, res) => {
res.send('Főoldal');
});
app.get('/about', (req, res) => {
res.send('Rólunk');
});
app.get('/contact', (req, res) => {
res.send('Kapcsolat');
});
app.get('*', (req, res) => {
res.status(404).send('404 - Az oldal nem található');
});
app.listen(3000, () => {
console.log('Szerver fut a http://localhost:3000 címen');
});
Példa 2: Middleware
Használata
Adj hozzá egy middleware-t, amely naplózza a bejövő kéréseket és a kért
URL-eket, majd kezelje az alábbi útvonalakat:
GET /: Válaszoljon
"Kezdőlap".
GET /about:
Válaszoljon "About oldal".
Megoldás:
const express = require('express');
const app = express();
app.use((req, res, next) => {
console.log(`${req.method} kérés érkezett a(z) ${req.url} URL-re`);
next();
});
app.get('/', (req, res) => {
res.send('Kezdőlap');
});
app.get('/about', (req, res) => {
res.send('About oldal');
});
app.listen(3000, () => {
console.log('Szerver fut a http://localhost:3000 címen');
Amikor a futó programunkon változtatásokat hajtunk végre, gyakran előfordul, hogy a mentést követően ezek a módosítások nem lépnek azonnal érvénybe. A fejlesztés közben minden alkalommal újra kell indítani az egész alkalmazást, hogy a frissítések érvényesüljenek. Ez különösen időigényessé válhat bonyolultabb programok esetében, ahol a fejlesztők jelentős időt veszíthetnek az állandó újraindítások miatt.
Ennek a problémának a megoldására hozták létre a Nodemon modult, amely automatikusan újraindítja a szervert, ha bármilyen változtatás történik a kódban. A következő lépésekben bemutatjuk, hogyan bővíthetjük fejlesztői környezetünket ezzel az eszközzel.
Először is, navigáljunk a projektünk gyökérkönyvtárába, majd telepítsük globálisan a Nodemon modult az alábbi paranccsal:
npm install -g nodemon
A globális telepítés azt jelenti, hogy a Nodemon bármelyik projektben elérhető lesz, függetlenül attól, hogy korábban helyileg telepítve volt-e vagy sem.
A telepítés befejezése után indítsuk újra a szervert, ezúttal a Nodemon segítségével:nodemon simple-server.js
Ahogy elmentettük a fájlokat, észre fogjuk venni, hogy a szervert nem kell manuálisan leállítani és újraindítani. A Nodemon folyamatosan figyeli a fájlok változásait, és automatikusan újraindítja a szervert, amikor módosítás történik.
A „nodemon watching” üzenet azt jelenti, hogy a Nodemon figyeli az adott mappában található összes fájlt. Ha bármelyiket módosítjuk, a Nodemon automatikusan újraindítja a Node.js alkalmazást, így jelentős időt takaríthatunk meg a fejlesztés során.
A Nodemon
telepítése során előfordulhat, hogy a parancssor nem találja a fájlt vagy
modult, ami több különböző okból eredhet. Itt van néhány lépés, amelyek
segíthetnek a probléma megoldásában:
Node.js ellenőrzése: Először is győződj meg arról,
hogy a Node.js megfelelően van telepítve az iskolai gépeken. A következő
parancsokkal ellenőrizheted a verziókat:
node -v
npm -v
Ha ezek a parancsok nem adnak ki verziószámot, akkor
lehet, hogy a Node.js nincs megfelelően telepítve.
Nodemon globális telepítése: Próbáld meg a Nodemon modult
globálisan telepíteni, hogy minden projektnél elérhető legyen. Használd a
következő parancsot:
npm install -g nodemon
Ezzel a Nodemon globálisan települ, és a nodemon parancsot közvetlenül használhatod.
Hozzáférési jogok: Ha rendszergazdai jogokra van
szükség a modul telepítéséhez, akkor futtasd a telepítést sudo-val (ha Linux vagy macOS
rendszeren dolgozol), vagy rendszergazdaként Windows alatt:
sudo npm install -g nodemon
Windows rendszeren nyisd meg a parancssort
rendszergazdai jogokkal (jobb kattintás, „Futtatás rendszergazdaként”).
Node.js telepítési útvonal
hozzáadása a PATH-hoz: Ha a Node.js telepítve van, de a parancssor nem
találja a megfelelő fájlokat, akkor lehet, hogy a Node.js nincs hozzáadva
a PATH környezeti változókhoz. Ezt manuálisan hozzá kell adnod:
Windows rendszeren:
Menj a Vezérlőpultba ->
Rendszer és biztonság -> Rendszer -> Speciális rendszerbeállítások
-> Környezeti változók.
A „Rendszerváltozók” részen
keresd meg a „Path” bejegyzést, és szerkeszd.
Add hozzá a Node.js
telepítési könyvtárát (pl. C:\Program Files\nodejs\).
Linux vagy macOS rendszeren:
Add hozzá a következő sort a .bashrc vagy .zshrc fájlhoz:
export PATH=$PATH:/usr/local/bin/node
Projekt mappán belüli telepítés: Ha csak egy adott projektben
szeretnéd használni a Nodemon-t, navigálj a projekt mappájába, és ott
futtasd a telepítést:
npm install nodemon --save-dev
Mivel mi ellenőriztük a verziókat, és a megfelelő paranccsal próbáltuk telepíteni, a környezeti változók beállítását próbáljuk meg.
amivel el tudjuk indítanni végül: npx nodemon és a fájlod neve
A Node.js egy nyílt forráskódú, platformfüggetlen futtatási
környezet, amely lehetővé teszi, hogy a JavaScript nyelvet ne csak a
böngészőben, hanem szerveroldalon is használjuk. Ez azt jelenti, hogy a
JavaScript segítségével nemcsak interaktív weboldalakat készíthetünk, hanem
teljes szerveroldali alkalmazásokat is fejleszthetünk.
NodeJs egy olyan futtató környezet, ami lehetőséget nyújt
JavaScriptben írt programok futtatására szervereken. JavaScriptet leginkább a
kliens oldalon szokták használni, a böngészőn keresztül. Ahhoz, hogy, megértsük
miképp futtathatunk JavaScript kódot szerveren, először nézzük meg, miképp
valósul meg ugyanez a böngészőn keresztül. A böngésző applikáció fejlesztők
számára olyan motorokat kell biztosítani (a Google Chrome esetén a v8 engine),
amik a JavaScript kódot gépi nyelvként interpretálják és le is futtatják.
Alapvetően a NodeJs is ugyanazt a v8 engine-t használja, némi módosítással.
Most felmerülhet bennünk az a kérdés, hogy miben jobb, mint a PHP, asp.net, stb.
? Annyi könnyebbséget nyújt, ha már dolgoztunk frontend oldalon, nem kell egy
teljesen új nyelvet megtanulni ahhoz, hogy a backend-et is implementáljuk. Tehát
ha valaki megtanulta a javascriptet, akkor nem kell új programnyelvet tanulnia
ahhoz, hogy a szerver oldalon is tudjon programozni. Lényegében ugyanazokkal az
eljárásokkal, függvényekkel, szintaxissal tudsz szerver oldali alkalmazást is
írni. Tehát nagyon leegyszerűsítve ez a lényege.
A másik előnye az, hogy a non-blocking természetéből adódóan
alkalmas egyszerre több ezer bejövő 'egyszerű' kérés kezelésére. A Node.js-t
úgy írták meg, hogy (szinte) minden esemény aszinkron legyen, ezért az program
sosem blokkolódik, azaz nem kell várni, hogy egy művelet befejeződjön, vele
párhuzamosan futtathatunk további műveleteket. Ez pontosan ugyan úgy működik,
mint a böngészőben levő XHR kérések, vagy más események, mint például a click,
mouseover. Ez az alkalmazás folyamatosabb futását, több alkalmazás
párhuzamosítását, valamint az egész rendszer optimálisabb működését teszi
lehetővé. Tehát ebből is látszik, hogy másik nagy előnye az, hogy kezeli az
eseményeket is más szerver oldali alkalmazásokkal szemben.
A hétköznapi életben az egyik legelterjedtebb variáció, az
Apache és php kombinációja. Ez úgy néz ki, hogy kap egy kérést az Apache
szerver valahonnan, egy böngészőből a netről, 80-as porton. Amikor megkapja a
kérést akkor megnézni, hogy hol van az erőforrás amit kértek, hol van az a
honlap, és ha megtalálja, az „index.php” a kezdő fájl, akkor meghívja a php-t
elindítja, a php legenerálja az oldal tartalmát neki, amikor végzett akkor
vissza adja a vezérlést az Apache szervernek. Az Apache szerver lelövi a php-t
kész vége a folyamatnak, leáll, és utána vissza küldi a tartalmat a kliens
felé, és bontja a kapcsolatot. Tehát így néz ki egy http kérés.
Érdekesség képpen, vizsgáljuk meg a „nodejs-org” oldalt,
nyomjunk neki egy f12-t, kattintsunk a Network fülre, és itt ha egy f5-öt, ha
nyomunk újra frissíti az oldalt, és itt látható hogy egy csomó kérést elküld a
szerver felé az oldalunk, és látható, hogy mi az amit legelőször lekér, az a
document, tehát mindig a legelső az a html váza az oldalnak, ami lejön a
szerverről. ugye a html dokumentunk ezzel még sokat fogunk foglalkozni, az egy
xml-ben htmlxml-ben írt dokumentum, rákattintva látható is a nyers váza az
oldalnak, itt vannak leírva az alapvető scriptek stb. illetve egy csomó
hivatkozást tartalmaz. A böngésző úgy dolgozik, hogy föntről lefelé elindul,
teljesen egyszerűen, mint ahogyan az ember olvassa soronként elolvassa ezt a
kódot, és amit ott talál azt végre hajtja. Először megnézi, hogy dokumentum
típusa html, majd látja, hogy elindul a html-ünk, html nyitó tag, beállítja a
nyelvet angolul, aztán jön fejrész, beállítja a karakterkódolást, majd a címet,
beállítja a linkeket megy tovább. Utána talál egy scriptet lefutatja a
scirptet, és amíg a scirpt nem futott le addig nem megy tovább, majd jön az
oldalnak a body része amit mindenki lát, abban is van egy header, container,
talál egy ilyet img src, az srcből tudja hogy ez egy külső erőforrás be kell
olvasnunk, meghívja újra küld egy kérést a szerver felé, letölti a logo.svg
fájlt, ha kész van megy tovább. Utána megkeresi a következő ilyen hivatkozást,
és még sok minden más huncutság van itt sorról sorra és a végén van egy css
fájl, ami gyakorlatilag az oldal megjelenését írja le, azt is lekéri, aztán
látható benne webfont.js fáj, javascript fájl, aztán még jónéhány javascriptet
lefuttat, és a végén kiszáll. Ez egy tipikus weboldal ebből a szempontból és ha
a network fül alatt megnézzük, látható hány kérést küldött pl 14-et a szerver
felé a böngészőnk, és azt is láthatjuk ezen kérések során, milyen mennyiségű
fájlt mozgatott meg. Nem túl sok ha már be van cash-elve.
Ezt azért néztük meg, mert a nodejs egy tipikusan szerver
alkalmazás, kiszolgáló alkalmazás. Tehát ha mi nodejs-ben szeretnénk egy
weblapot elkészíteni, akkor az összes kérést ami itt fel van sorolva mindet a
nodejs-nek kell kiszolgálni. Elküldi a tartalmat a html-t kiszolgálja a
fájlokat, vissza küldi a felhasználónak a kért fájlokat, összeállítja a tartalamat
templatekből, minden egyes kérésnél beállítja a fejlécket, stb ezt mind mind a
nodejs fogja kiszolgálni.
Nincs külön szerveroldali nyelv mint a php, nincs külön
szerver mint IS vagy apache, hanem a kettő egyben van. Tulajdonképpen mind a
kettő a nodejs. A nodejs egy személyben ő szerver is és ő generálja a tartalmat
is. A klasszikus megközelítés az volt, hogy mindig külön volt a szerver program
és külön a kódgenerátor. Típustól függően microsoftos kódgenerátor php vagy
bármi más, ami generálta a kódot, itt a kettő egyben van!
Hátránya, hogy
mivel összetetetettebb kódot kell írni, könnyebb elrontani. Ugyanaz végzi a
fájlkiszolgálást is meg a tartalom generálást is.
Előnye, hogy
lényegesen kisebb a processzor és a memória felhasználása. Miért, mert mindegy
egyes folyamat amit fut a szerveren, ugyanúgy mint a windowson ha megnyitjuk a
folyamat kezelőt, minden egyes folyamat foglal memóriát, processzor időt stb.
Itt ebben az esetben nem kell két folyamatot futtatnia, külön a szervert külön
a generátort, hanem egy folyamat fut csak, jellemzően olyan ötöde tizede a
memória felhasználása, egy ugyanakkora oldanál egy nodejsnek mint pl az apache
php kombónak. Ez egy nagyon nagy előny. Nem blokkolja az I/O modelt,
Az oldalon láthatjuk le van írva angolul, hogy a nodejs egy
eseményvezérelt rendszert használ, az input output modell tulajdonképpen a
kapcsolódás és lekapcsolódás, amikor egy hagyományos szerver végez bontja a kapcsolatot a felhasználóval. Viszont a
nodejs-el meg tudjuk azt csinálni, hogy amikor kiszolgálta a felhasználó
kérését utána kapcsolatban marad egy socketen keresztül a felhasználó gépével,
és nem kell mindig minden kérésnél újra felépíteni a kapcsolatot, hanem a
meglévő csatornán socketen keresztül tudnak kommunikálni egymással. (socket –
konnektort jelent) tehát be van csatlakoztatva a konektorba a felhasználó és
folyamatos a kapcsolat a két fél között.
A Node.JS és a böngésző jelentősen különböznek egymástól,
annak ellenére, hogy mindkettő a JavaScript nyelven alapszik. A node.js veszi
az alap nyelvet, akárcsak bármelyik böngésző motor, és különböző API-kkal
bővíti azt, ezzel lehetőséget nyújtva szerveroldali műveletekre, hálózati
feladatok ellátására.
Először is nézzük meg, hogy a node.js milyen futtatási
környezetben működik, és hogyan illeszkedik abba a rendszerbe, amivel már
kliens oldali fejlesztőként találkoztatok. Ehhez nyugodtan elővehetjük azt a
kis ábrát, amit a javascripttel való ismerkedés elején néztünk meg, ami
bemutatja a http protkoll alapvető működését.
A böngészőben működik
egy beépülő program, egy ún js engine vagy js motor, ez egy interpreter, amibe
a bemenet a js nyelven írott kód, és amit ez csinál, az az, hogy vezérli a
böngészőt. Ezt több módon is teszi, többek között az enginet a motort tudja
vezérelni, tehát a html dokumentumot, tulajdonképpen megvan a motornak a
hatalma arra, hogy elementeket hozzon létre, vagy bármely element bármely
attribútumát módosítsa. Emellett hozzáférése van az ún console-hoz, ami egy
interfész arra, hogy mi közvetlenül kommandokat tudjunk beküldeni az enginenek,
és meg is tudjuk nézni azt, amit az engine vissza küld válaszként. A console-t
sokat fogjuk használni. Emellett az enginenek megvan a hatalma arra, hogy ő
maga küldjön ilyen http kéréseket, és a beérkező válaszokat feldolgozza, ezek
az ún ajax kérések, és nagyon nagy szerepük van a kliens oldali
alkalmazásokban. Emellett az enginen keresztül adatot is tudunk tárolni,
létezik a böngészőnek egy local storage nevű szekciója, ahol elhelyezhetünk
adatot és később akár újabb oldalletöltéssel kiolvashatunk minden adatot.
Manapság már nemcsak a kliens oldalon működik javascript engine, hanem már
megannyi futtatási környezetben használható ez a motor, többek között szerver
oldalon is futtatható. Node.js programon keresztül is használható az engine, de
ebben a kontextusban merőben eltérő feladatai vannak az enginennek, hiszen ő a
kéréseket fogadja és ezekre válaszokat küld. Tehát célját és feladatait
tekintve abszolút eltér a kliens oldalon használt engine-től.
A kliens oldalon két
fő feladata van a js—nek, egyrészt a html elementek módosítása révén elérhető
egyfajta interakció fokozás, másrészről meg ajax kérések küldése révén tudunk
oldal letöltés nélkül kis mennyiségű adatért folyamodni a szerver oldalra.
Amennyiben maxra járatjuk a js kódot, a kliens oldalon létrehozhatunk olyan
user interface-ket, amik oldal letöltés nélkül kommunikálnak folyamatosan a
szerver oldalra és ilyen olyan interaktív hatásokat is hoznak létre tehát akár
egy telefonos applikáció hatását is keltik, egy klasszikus értelemben vett
weboldal hatását, ahol kattintgatunk és frissülnek az oldalak, tehát egy
folyamatos smooth élményt egy megszakítás nélküli felhasználói élményt
nyújtanak.
Nézzük tovább, ha van egy szervered, akkor a nodejs program
milyen feladatokat hivatott ott ellátni. Ha pl nodejs szervert üzemeltetsz a
szerver elsődleges célja a http kéréseknek a fogadása, majd a kérés alapján egy
http válasz megküldése. Most átülünk a rendszer másik oldalára, ahol a
kéréseket fogadjuk, és a válaszokat küldjük. A szerverednek hozzáférése van a
lokális gépednek a fájl rendszeréhez. Az előző képet egy kis dobozkával lehet
kiegészíteni file system, ebbe a fájl rendszerbe a node js program tud írni, és
tud belőle olvasni. Emellett a nodejs applikáció tipikusan kapcsolatba lép
adatbázissal, ez által a rendszer alkalmassá válik klienstől kapott adat
eltárolására, majd akár egy újabb beérkező request kapcsán az adat kiolvasására
majd a válaszként való megküldésére. A két rendszer működése a való életben úgy
néz ki, hogy teszem azt le akarod tölteni a portfolio.hu oldalát, ezért beírod
url-nek, hogy portfolio.hu, és rányomsz az enterre. Ekkor a böngésző kiküld egy
http kérést, a portfolio.hu szerverének, ezt a kérést a szerver egy adott
portján keresztül fogadja, majd a fájl rendszeréből egy html sablont olvas be.
Emellett az adatbázissal is kapcsolatba lép, és kiolvassa a napi legfrissebb
híreket. A beolvasott html sablonból, valamint az adatbázisból származó
információból össze állít, specifikus, arra az adott napra aktuálisan érvényes
html dokumentumot. Ezt a dokumentumot megküldi válaszként a kliensnek. A
böngésző ezután kirendereli a tartalmat, valamint hogyha a html tartalomban
vannak hivatkozások, további erőforrásra, azokat a kéréseket kiküldi szintén
szerver oldalra. Az adott esetben ilyen módon kiszolgált szerver oldali
scriptek lefutnak a böngészőben. Amennyiben a html tartalomban vannak
interaktív komponenesek, teszem azt megnézzük a tőzsdei információkat valós
időben (itt 15 perces késéssel látjuk, valós időhoz előfizetés szükséges)
szolgáltató interaktív komponenst, akkor az interaktivitást a szerverről
megkapott kliens oldali script biztosítja, és ez a js kód folyamodhat friss
tőzsdei adatokhoz, időként a szerverhez, tehát ő maga kiküldhet http kérést,
miután az oldalt letöltöttük. Ebben az esetben ez a kérés szerver oldalon
szintén beérkezik egy bizonyos portra. A nodjs a kérésnek megfelelő adatokat
kiolvassa, majd ezt json formátumban küldi meg válaszként. A beérkező json
tartalmat a js app kirendereli kliens oldalon, így egy folyamatosan frissülő
tartalmat láthatunk.
Amit fontos látnunk, hogy a szerver, amikor először
letöltöttük az oldalt, még csak egy html tartalommal válaszolt, és ez volt az
első dolog amit a kliens megkapott. Utána a kliens kért tőle képeket,
scripteket, css fájlokat, majd amikor a script elkezdett futni, és ajax kérést
küldött ki, akkor a szerver json tartalmat is szolgáltatott. Tehát a szerver
sokfajta tartalom típus szolgáltatásért felelős. Ezeket fogjuk megnézni, hogy a
különböző tartalom típusokra irányuló kéréseket, hogyan tudjuk teljesíteni,
kiszolgálni, illetve hogyan tudjuk őket szerver oldalon kezelni.
A Node.js Története
A Node.js-t Ryan Dahl alkotta meg 2009-ben. Az ötlet abból
származott, hogy Dahl szerette volna megoldani a webszervereknél gyakori
problémát: a lassú I/O műveleteket, amelyek a felhasználói élményt jelentősen
ronthatják. Az Apache webszerver, amely abban az időben a legelterjedtebb volt,
minden egyes kliens számára új szálat nyitott, ami nagy terhelés esetén jelentős
erőforrás-felhasználást eredményezett. Dahl felismerte, hogy egy nem blokkoló,
eseményvezérelt modellt használó környezet sokkal hatékonyabb lehet.
A Node.js hamar elterjedt a fejlesztők körében, különösen azok körében, akik
nagy terhelésű, skálázható alkalmazásokat szerettek volna készíteni, mint
például a valós idejű chat alkalmazások vagy a streaming szolgáltatások. A
Node.js népszerűségét az is növelte, hogy ugyanazt a nyelvet használhatják a
fejlesztők a kliens és a szerver oldalon is, ami egységesíti és egyszerűsíti a
fejlesztést.
Főbb Jellemzők
1.Aszinkron és eseményvezérelt:
A Node.js nem blokkoló I/O modellt használ. Ez azt jelenti, hogy amikor a
szerver egy műveletet, például egy adatbázis-lekérdezést hajt végre, nem várja
meg a művelet befejezését, mielőtt továbblépne a következő műveletre. Ehelyett
események alapján működik: ha egy művelet befejeződik, egy esemény jön létre,
amely elindítja a megfelelő visszahívó (callback) függvényt. Ez a megközelítés
lehetővé teszi, hogy a Node.js egyszerre nagy mennyiségű párhuzamos kérést
kezeljen, anélkül hogy várakoznia kellene egy-egy művelet befejezésére.
2.Egyszálú, de nem korlátozott:
A Node.js alapvetően egyszálú, ami azt jelenti, hogy minden művelet ugyanazon a
szálon fut. Azonban a háttérben, a Node.js belső működésében több szál is
dolgozik a nehéz, számításigényes feladatok kezelésére (például fájlok
olvasása/írása, hálózati kapcsolatok kezelése). Ez az egyszálú, de
eseményvezérelt megközelítés lehetővé teszi a magas párhuzamosságot, miközben a
fejlesztőnek nem kell aggódnia a szálkezelés miatt.
3.Modularitás:
A Node.js moduláris felépítésű, ami azt jelenti, hogy különböző funkciókat
elkülönítve, modulokba szervezhetünk. Ezáltal könnyebb újrahasznosítani a
kódot, és a projekt különböző részein ugyanazokat a modulokat használhatjuk. A
Node.js közössége által létrehozott modulok és csomagok hatalmas tárháza
található a npm (Node Package Manager) segítségével, amely egy
olyan eszköz, amely lehetővé teszi ezen modulok könnyű kezelését és
telepítését.
Miért Használjuk a
Node.js-t?
A Node.js-t széles körben használják különféle típusú alkalmazások
fejlesztésére:
Webszerverek: Kiválóan
alkalmas webszerverek fejlesztésére, mivel hatékonyan kezeli a nagy
mennyiségű kérést.
Valós idejű alkalmazások:
Például chat alkalmazások, ahol a szervernek nagyon gyorsan kell
válaszolnia a felhasználói eseményekre.
REST API-k: A Node.js
egyszerűsíti a RESTful API-k fejlesztését, amelyek az adatbázisokkal való
kommunikációra használhatók.
Streaming alkalmazások: A
nem blokkoló modell különösen jól használható streaming szolgáltatások
fejlesztésére.
A Node.js
Elterjedtsége és Verziói
A Node.js nagyon elterjedt a fejlesztők körében, különösen a modern webes
alkalmazások fejlesztése során. A nagy tech cégek, mint a Netflix, Uber, PayPal
és LinkedIn is használják a Node.js-t különféle szolgáltatásaikhoz. Az egyik
legnagyobb előnye a nagy közösség és a rengeteg elérhető modul, amely lehetővé
teszi a gyors fejlesztést és innovációt.
A Node.js-nek több hivatalos verziója van, és ezek rendszeresen frissülnek.
Az LTS (Long-Term Support) verziók azok, amelyeket hosszabb
ideig támogatnak, és ezek a verziók a stabilitást és a hosszú távú támogatást
kereső fejlesztők számára ajánlottak. Az aktuális verziók
azok, amelyekben az új funkciók és fejlesztések először jelennek meg, és ezek
gyorsabban frissülnek, de kevésbé stabilak.
Node.js Licenc és
Közösség
A Node.js nyílt forráskódú, ami azt jelenti, hogy ingyenesen használható,
módosítható és terjeszthető. A projektet a Node.js Foundation
kezeli, amely a Linux Foundation része. Ez a szervezet
felügyeli a Node.js fejlesztését és biztosítja annak folyamatos fejlődését és
támogatását.
A nyílt forráskódú természet és a nagy, aktív közösség miatt a Node.js
folyamatosan fejlődik, és új funkciókkal, optimalizációkkal bővül. A fejlesztők
világszerte hozzájárulnak a Node.js kódjához, modulokat fejlesztenek, és
megosztják tudásukat a közösség többi tagjával.
Összefoglalás
A Node.js egy rendkívül népszerű és erőteljes eszköz a modern webes és szerveroldali
alkalmazások fejlesztéséhez. Kiváló teljesítményt nyújt az aszinkron, nem
blokkoló modelljének köszönhetően, és lehetővé teszi a fejlesztők számára, hogy
JavaScriptet használjanak mind a szerver, mind a kliens oldalon. A nagy
közösség és az ingyenesség pedig még vonzóbbá teszi a Node.js-t, különösen a
skálázható, nagy terhelésű alkalmazások fejlesztésében.
A Node.js telepítése rendkívül egyszerű és gyorsan
elvégezhető. A következő lépéseken keresztül telepíthetjük a Node.js-t
különböző operációs rendszereken.
A telepítés után ellenőrizzük, hogy a Node.js és az npm helyesen települt-e.
Ehhez a következő parancsokat használjuk a terminálban vagy parancssorban:
node -v
npm -v
Ezek a parancsok a telepített Node.js és npm verziószámát adják vissza.
Például:
