A Node.js egy nyílt forráskódú JavaScript futtatókörnyezet, amely a chrome v8-as motorjára épül, és lehetővé teszi JavaScript-kód böngészőn kívüli futtatását.
Eseménymodellje, ökoszisztémája és sebessége a Node.js-t a szerveroldali alkalmazások egyik legkeresettebb és leggyakrabban használt futási környezetévé tették.
A legtöbb Node.js API-kiszolgáló Expresszt vagy más keretrendszert használ. Azonban néhány lépésben létrehozhat egy egyszerű Node.js API-t keretrendszer nélkül is.
1. lépés: Fejlesztői környezet beállítása
Hozzon létre egy projektkönyvtárat és CD futva bele:
mkdir nodejs-api
CD nodejs-api
Ezután inicializálja npm a projektben a következő futtatással:
npm init -y
Ez a CRUD API a MongoDB, egy NoSQL adatbázis és annak népszerű ODM, a mongoose használatát fogja tartalmazni.
A telepítéshez futtassa a következő parancsot indiai menyét:
npm telepítés indiai menyét
Ezután hozzon létre a server.js fájlt a projekt gyökérkönyvtárába, és a szerver létrehozásához adja hozzá az alábbi kódblokkot:
const http = igényelnek("http");
const szerver = http.createServer((req, res) => {});
server.listen (3000, () => {
konzol.log(`A szerver fut`);
});
Ez a kódblokk importálja a http modult, amely egy központi Node.js modul. A http modul lehetővé teszi a Node.js számára az adatok HTTP-n keresztüli átvitelét. Ez a modul tartalmazza a szerver létrehozásához szükséges módszereket.
Ezután meghívja a http modult CreateServer metódus, amely létrehozza és visszaadja a szerver példányát. Az CreateServer metódus egy visszahívási függvényt vesz fel paraméterként egy kérés és válasz objektummal.
Ezután a kód meghívja a hallgat metódus a visszaadott kiszolgálópéldányon. Ez lehetővé teszi a szerver számára, hogy elkezdje figyelni a forgalmat az adott porton. Az hallgat A metódus sikeres visszahívást indít – a második argumentumot –.
Végül hozzon létre két nevű könyvtárat útvonalak és modellek a projekt gyökérkönyvtárában. Az útvonalak mappa tartalmazza az API útválasztási logikáját, míg modell tartalmaz mindent, ami az adatbázissal kapcsolatos.
2. lépés: Az alkalmazás összekapcsolása egy adatbázissal
Ban ben server.js, import indiai menyét:
const mangúz = igényelnek("indiai menyét");
Hívja a csatlakozni módszer bekapcsolva indiai menyét és adja át a MongoDB URI-ját argumentumként:
mongoose.connect("MongoDB_URI")
3. lépés: API-modell létrehozása
Hozzon létre egy CRUD API-t egy egyszerű blogalkalmazáshoz. A tiédben modellek mappát, hozzon létre a blogModel.js fájlt, és adja hozzá a következő kódot a fájlhoz:
const mangúz = igényelnek("indiai menyét");
const blogSchema = mangúz. Séma({
cím: {
típus: Húr,
kötelező: [igaz, "A blognak címet kell adni"],
},
test: {
típus: Húr,
kötelező: [igaz, "A blognak testnek kell lennie"],
},
});
modult.export = mongoose.model("Blog", blogSchema);
A fenti kódblokk létrehoz egy mongoose modellt két tulajdonsággal, és leképezi őket egy MongoDB adatbázisra.
Ebben a modellben mindkét tulajdonság rendelkezik a Húr írja be kívánt állítva igaz. A kísérő hibaüzenetek megjelennek, ha a kérés törzse nem tartalmazza a tulajdonságok egyikét sem.
Az utolsó sor egy mongúz modellt hoz létre és exportál a következő meghívásával modell módszer bekapcsolva indiai menyét. Add meg a modell nevét (Blog) mint első argumentum és séma (blogSchema) második érvként.
4. lépés: Az útválasztás megvalósítása az alkalmazásban
Segítség nélkül olyan keretrendszerek, mint az Express, akkor manuálisan kell létrehoznia a logikát az API-hoz intézett minden kérés kezeléséhez.
Először hozzon létre a blogRoutes.js fájlt a tiédben útvonalak mappát, majd importálja a blogmodellt:
const Blog = igényelnek(../models/blogModel");
Ezután hozzon létre egy aszinkront router funkció, passz req és res paraméterként, és exportálja a függvényt:
const router = asyncfunkció (req, res) {};
modult.export = router;
Ez a függvény tartalmazza az összes útválasztási logikát.
Ezután meg kell valósítania az útválasztási logikát útvonalonként.
Útvonalak beszerzése
Adja hozzá az alábbi kódblokkot a sajátjához router funkció megvalósításához a KAP címre küldött kérések útvonalkezelője /api/blogs:
// GET: /api/blogs
if (req.url "/api/blogs"&& req.method "KAP") {
// az összes blog letöltése
const blogok = várják Blog.find();// készlet az állapot kód éstartalom-típus
res.writeHead (200, { "Tartalom típus": "alkalmazás/json" });
// adatok küldése
res.vége(JSON.karikázni(blogok));
}
A fenti kódblokk ellenőrzi a url és módszer a kérés objektum tulajdonságai. Ezután lekéri az összes blogot az adatbázisból a megtalálja módszer a mongúz modellen (Blog).
Ezután a writeHead módszer bekapcsolva res, a válaszobjektum. Ez a metódus válaszfejlécet küld három argumentummal: állapotkóddal, opcionális állapotüzenettel és fejlécekkel. Az 200 Az állapotkód sikeres választ jelent, és ennek az API-hívásnak a tartalomtípusa a következőre van állítva alkalmazás/json.
Végül zárja be a kérést, hogy biztosítsa a kiszolgáló lefagyását a vége módszer bekapcsolva res. A hívás JSON.stringify átalakítja a blogok objektumot egy JSON karakterláncra, és átadja azt a vége metódus választörzsként adja vissza.
Adja hozzá az alábbi kódblokkot a sajátjához router funkció megvalósításához a KAP útvonalkezelő egyetlen erőforráshoz:
// GET: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.method "KAP") {
próbálja meg {
// azonosító kibontása az url-ből
const id = req.url.split("/")[3];// blog beszerzése a DB-től
const blog = várják Blog.findById (id);
if (blog) {
res.writeHead (200, { "Tartalom típus": "alkalmazás/json" });
res.vége(JSON.karikázni(blog));
} más {
dobásújHiba("A blog nem létezik");
}
} fogás (hiba) {
res.writeHead (404, { "Tartalom típus": "alkalmazás/json" });
res.vége(JSON.karikázni({ üzenet: hiba }));
}
}
Ez a kód a mérkőzés metódus, amely egy regex kifejezést vesz fel argumentumként annak ellenőrzésére, hogy az URL egyezik-e a formátummal: /api/blogs/.
Ezután bontsa ki a id ingatlan a url karakterlánc hívásával hasított módszer. Ez a metódus egy mintát vesz fel argumentumként (/), felosztja a karakterláncot a minta alapján, és egy tömböt ad vissza. Ennek a tömbnek a harmadik eleme a id.
Végül kérje le a megfelelő dokumentumot id az adatbázisodból. Ha létezik, küldje el a 200-as válaszkód, zárja be a kérést, és küldje el a letöltött blogot. Ha nem létezik, dobjon egy hibát, és küldje el válaszként a catch blokkban.
POST Útvonal
Adja hozzá az alábbi kódblokkot az útválasztó funkciójához a végrehajtásához POST útvonalkezelő:
// POST: /api/blogs/
if (req.url "/api/blogs"&& req.method "POST") {
próbálja meg {
hadd test = "";// Adatesemény figyelése
req.on("adat", (darab) => {
body += chunk.toString();
});// Figyelj rá végeesemény
req.on("vége", aszinkron () => {
// Blog létrehozása
hagyja blog = új Blog(JSON.parse (test));
// Mentés DB-be
várják blog.save();
res.writeHead (200, { "Tartalom típus": "alkalmazás/json" });
res.vége(JSON.karikázni(blog));
});
} fogás (hiba) {
konzol.log (hiba);
}
}
A kérelem objektum megvalósítja a Node.js ReadableStream felület. Ez a patak bocsát ki a adat és egy vége esemény, amely hozzáférést biztosít a kérelmező szervtől származó adatokhoz.
Ez a kód figyeli az adateseményt, és úgy kezeli, hogy karakterláncsá alakítja és összefűzi test változó. Ban,-ben vége eseménykezelő, létrehozza a Blog példány az elemzett törzskarakterlánccal. Ezután elmenti az új blogot, elküldi az állapotkódot és a tartalomfejlécet, és lezárja a kérést.
PUT Route
Adja hozzá az alábbi kódblokkot az útválasztó funkciójához a végrehajtásához PUT útvonalkezelő:
// PUT: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.method "PUT") {
próbálja meg {
// azonosító kibontása az url-ből
const id = req.url.split("/")[3];
hadd test = "";req.on("adat", (darab) => {
body += chunk.toString();
});
req.on("vége", aszinkron () => {
// Keresse meg és frissítésdokumentum
hagyja updatedBlog = várják Blog.findByIdAndUpdate (id, JSON.parse (törzs), {
új: igaz,
});
res.writeHead (200, { "Tartalom típus": "alkalmazás/json" });
res.vége(JSON.karikázni(frissítveBlog));
});
} fogás (hiba) {
konzol.log (hiba);
}
}
A PUT kéréskezelő szinte azonos a POST kéréskezelő, kivéve, hogy kivonja a id ingatlan a url a vonatkozó blog frissítéséhez.
Útvonal törlése
Adja hozzá az alábbi kódblokkot az útválasztó funkciójához, hogy megvalósítsa a sajátját TÖRÖL útvonalkezelő:
// TÖRÖL: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.method "TÖRÖL") {
próbálja meg {
const id = req.url.split("/")[3];
// Töröl blog tól től DB
várják Blog.findByIdAndDelete (id);
res.writeHead (200, { "Tartalom típus": "alkalmazás/json" });
res.end (JSON.stringify({ üzenet: "A blog sikeresen törölve" }));
} fogás (hiba) {
res.writeHead (404, { "Tartalom típus": "alkalmazás/json" });
res.vége(JSON.karikázni({ üzenet: hiba }));
}
}
Ez a kódblokk kivonja a id tól url, törli a megfelelő dokumentumot id, elküldi az állapotkódot és a fejléceket, és lezárja a kérést.
Végül az importálás router a tiédben server.js fájlt, és hívja fel router funkció, átadás req és res érvekként:
const router = igényelnek(./routes/blogRoutes");
const szerver = http.createServer((req, res) => {
router (req, res);
});
Ez lehetővé teszi, hogy a szerver elfogja és megfelelően kezelje a kéréseket.
Az elkészült projektet itt találja GitHub adattár.
Node.js-keretrendszer használata
Annak ellenére, hogy kézzel is létrehozható egy webes API, ez nehéz feladat lehet. Győződjön meg arról, hogy sok szélső esetet lefedett, és jobb, ha a kód hibamentes legyen.
Az évek során a fejlesztők olyan keretrendszereket építettek, mint az ExpressJS, a NestJS, a Fastify stb., hogy ezt sokkal könnyebbé tegyék.
