NodeJS API létrehozása keretrendszer használata nélkül

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) => {});





instagram viewer
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.