Node.js je open-source JavaScript runtime postavený na chrome v8 engine, ktorý vám umožňuje spúšťať JavaScriptový kód mimo prehliadača.

Vďaka modelu udalostí, ekosystému a rýchlosti je Node.js jedným z najžiadanejších a najpoužívanejších runtime aplikácií pre aplikácie na strane servera.

Väčšina serverov Node.js API používa Express alebo iný rámec. V niekoľkých krokoch však môžete vytvoriť aj jednoduché rozhranie Node.js API bez rámca.

Krok 1: Nastavenie vývojového prostredia

Vytvorte adresár projektu a cd do toho spustením:

mkdir nodejs-api
cd nodejs-api

Ďalej inicializujte npm vo svojom projekte spustením:

npm init -y

Toto CRUD API bude obsahovať použitie MongoDB, databázy NoSQL, a jej populárnej ODM, mongoose.

Spustite nasledujúci príkaz na inštaláciu mangusta:

npm Inštalácia mangusta

Ďalej vytvorte a server.js súbor v koreňovom adresári vášho projektu a pridajte blok kódu nižšie, aby ste vytvorili server:

konšt http = vyžadovať("http");
konšt server = http.createServer((req, res) => {});
server.listen (3000, () => {
konzoly.log(`Server beží`);
});
instagram viewer

Tento blok kódu importuje modul http, hlavný modul Node.js. Modul http umožňuje Node.js prenášať dáta cez HTTP. Tento modul obsahuje metódy potrebné na vytvorenie servera.

Ďalej zavolá modul http createServer metóda, ktorá vytvára a vracia inštanciu servera. The createServer metóda berie funkciu spätného volania s objektom požiadavky a odpovede ako parametre.

Ďalej kód zavolá počúvaj metóda na vrátenej inštancii servera. To umožňuje serveru začať počúvať prevádzku na danom porte. The počúvaj metóda spustí spätné volanie – druhý argument – ​​keď uspeje.

Nakoniec vytvorte dva adresáre s názvom trasy a modelov v koreňovom adresári vášho projektu. The trasy priečinok bude obsahovať logiku smerovania pre vaše API, zatiaľ čo Model bude obsahovať všetko, čo súvisí s databázou.

Krok 2: Pripojenie vašej aplikácie k databáze

In server.js, dovoz mangusta:

konšt mangusta = vyžadovať("mangusta");

Zavolajte na pripojiť metóda zapnutá mangusta a odovzdajte svoje MongoDB URI ako argument:

mongoose.connect("MongoDB_URI")

Krok 3: Vytvorenie modelu API

Vytvorte CRUD API pre jednoduchú blogovú aplikáciu. V tvojom modelov priečinok, vytvorte a blogModel.js súbor a do svojho súboru pridajte nasledujúci kód:

konšt mangusta = vyžadovať("mangusta");
konšt blogSchema = mongoose. Schéma({
 názov: {
 typ: Reťazec,
 požadované: [pravda, "Blog musí mať názov"],
 },
 telo: {
 typ: Reťazec,
 požadované: [pravda, "Blog musí mať telo"],
 },
});
modul.exportov = mongoose.model("Blog", blogSchema);

Vyššie uvedený blok kódu vytvára model mongoose s dvoma vlastnosťami a mapuje ich do databázy MongoDB.

Obe vlastnosti v tomto modeli majú a Reťazec typ s požadovaný nastavený na pravda. Ak telo požiadavky neobsahuje žiadnu z vlastností, zobrazia sa sprievodné chybové hlásenia.

Posledný riadok vytvorí a exportuje model mongoose volaním Model metóda zapnutá mangusta. Zadajte názov modelu (Blog) ako prvý argument a schému (blogSchema) ako druhý argument.

Krok 4: Implementácia smerovania vo vašej aplikácii

Bez pomoci rámce ako Express, budete musieť manuálne vytvoriť logiku na spracovanie každej požiadavky odoslanej do vášho API.

Najprv vytvorte a blogRoutes.js súbor vo vašom trasy priečinok, potom importujte model blogu:

konšt Blog = vyžadovať("../models/blogModel");

Ďalej vytvorte asynchrónny router funkcia, pas req a res ako parametre a exportujte funkciu:

konšt router = asyncfunkciu (req, req) {};
modul.exportov = router;

Táto funkcia bude obsahovať všetku vašu logiku smerovania.

Ďalej implementujete logiku smerovania trasu po trase.

GET Trasy

Pridajte blok kódu nižšie do svojho router funkciu na implementáciu GET obslužný program smerovania pre požiadavky /api/blogs:

// GET: /api/blogs
if (req.url "/api/blogs"&& req.metóda "GET") {
// získať všetky blogy
konšt blogy = čakať Blog.find();
// nastaviť na postavenie kód aobsahu-typu
 res.writeHead (200, { "Druh obsahu": "application/json" });
// odoslať dáta
res.koniec(JSON.stringovať(blogy));
}

Vyššie uvedený blok kódu kontroluje url a metóda vlastnosti objektu požiadavky. Potom načíta všetky blogy z databázy cez Nájsť metóda na modeli mongoose (Blog).

Ďalej volá písaťHead metóda zapnutá res, objekt odpovede. Táto metóda odošle hlavičku odpovede s tromi argumentmi: stavový kód, voliteľná stavová správa a hlavičky. The 200 stavový kód predstavuje úspešnú odpoveď a typ obsahu pre toto volanie API je nastavený na application/json.

Nakoniec zatvorte požiadavku, aby ste sa uistili, že server nezamrzne volaním koniec metóda zapnutá res. Výzva k JSON.stringify konvertuje blogy objekt do reťazca JSON a odovzdať ho do koniec metóda ho vráti ako telo odpovede.

Pridajte blok kódu nižšie do svojho router funkciu na implementáciu GET obslužný program smerovania pre jeden zdroj:

// GET: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.metóda "GET") {
skúste {
// extrahovať ID z adresy URL
 const id = req.url.split("/")[3];
// získajte blog z DB
konšt blog = čakať Blog.findById (id);
if (blog) {
 res.writeHead (200, { "Druh obsahu": "application/json" });
res.koniec(JSON.stringovať(blog));
 } inak {
hodiťNovýChyba("Blog neexistuje");
 }
 } chytiť (chyba) {
 res.writeHead (404, { "Druh obsahu": "application/json" });
res.koniec(JSON.stringovať({ správu: chyba }));
 }
}

Tento kód používa zápas metóda, ktorá berie ako argument regexový výraz na kontrolu, či sa adresa URL zhoduje s formátom: /api/blogs/.

Ďalej extrahujte id majetok z url reťazec volaním jeho rozdeliť metóda. Táto metóda používa vzor ako argument (/), rozdelí reťazec na základe vzoru a vráti pole. Tretím prvkom tohto poľa je id.

Nakoniec získajte dokument so zhodou id z vašej databázy. Ak existuje, pošlite a kód odpovede 200, zatvorte žiadosť a odošlite načítaný blog. Ak neexistuje, vyhoďte chybu a odošlite ju ako odpoveď v bloku catch.

POST Trasa

Pridajte blok kódu nižšie do funkcie smerovača na implementáciu POST obsluha trasy:

// POST: /api/blogs/
if (req.url "/api/blogs"&& req.metóda "POST") {
skúste {
 nech telo = "";
// Vypočuť si dátovú udalosť
 req.on("údajov", (kúsok) => {
 telo += chunk.toString();
 });


// Počúvajte koniecudalosť
 req.on("koniec", async () => {
// Vytvoriť blog
nech blog = Nový Blog(JSON.parse (telo));
// Uložiť do DB
čakať blog.save();
 res.writeHead (200, { "Druh obsahu": "application/json" });
res.koniec(JSON.stringovať(blog));
 });
 } chytiť (chyba) {
konzoly.log (chyba);
 }
}

Objekt požiadavky implementuje Node.js ReadableStream rozhranie. Tento prúd vyžaruje a údajov a koniec udalosť, ktorá vám umožní prístup k údajom z tela žiadosti.

Tento kód počúva dátovú udalosť a spracuje ju tak, že ju skonvertuje na reťazec a zreťazí ho do telo premenlivý. V koniec obsluhu udalosti, vytvorí a Blog inštancia s analyzovaným reťazcom tela. Potom uloží nový blog, odošle stavový kód a hlavičku obsahu a zatvorí požiadavku.

Cesta PUT

Pridajte blok kódu nižšie do funkcie smerovača na implementáciu PUT obsluha trasy:

// PUT: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.metóda "PUT") {
skúste {
// extrahovať ID z adresy URL
 const id = req.url.split("/")[3];
 nech telo = "";
req.on("údajov", (kúsok) => {
 telo += chunk.toString();
 });
 req.on("koniec", async () => {
 // Nájsť a aktualizovaťdokument
nech aktualizovanýBlog = čakať Blog.findByIdAndUpdate (id, JSON.parse (body), {
Nový: pravda,
 });
res.writeHead (200, { "Druh obsahu": "application/json" });
res.koniec(JSON.stringovať(aktualizovanýBlog));
 });
 } chytiť (chyba) {
konzoly.log (chyba);
 }
}

Obsluha požiadavky PUT je takmer identická s obsluhou POST spracovateľa žiadostí, okrem toho, že extrahuje súbor id majetok z url aktualizovať príslušný blog.

VYMAZAŤ trasu

Pridajte blok kódu nižšie do funkcie smerovača, aby ste implementovali svoju VYMAZAŤ obsluha trasy:

// VYMAZAŤ: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.metóda "VYMAZAŤ") {
skúste {
 const id = req.url.split("/")[3];
// Odstrániť blog od DB
čakať Blog.findByIdAndDelete (id);
 res.writeHead (200, { "Druh obsahu": "application/json" });
 res.end (JSON.stringify({ správa: "Blog bol úspešne odstránený" }));
 } chytiť (chyba) {
 res.writeHead (404, { "Druh obsahu": "application/json" });
res.koniec(JSON.stringovať({ správu: chyba }));
 }
}

Tento blok kódu extrahuje id z url, vymaže dokument s párovaním id, odošle stavový kód a hlavičky a zatvorí požiadavku.

Nakoniec import router v tvojom server.js súbor a zavolajte do svojho router funkcia, prechádzanie req a res ako argumenty:

konšt router = vyžadovať(./routes/blogRoutes");
konšt server = http.createServer((req, res) => {
 router (req, res);
});

To vášmu serveru umožňuje správne zachytávať a spracovávať požiadavky.

Dokončený projekt nájdete v tomto úložisko GitHub.

Použitie rámca Node.js

Aj keď je možné vytvoriť webové API ručne, môže to byť náročná úloha. Budete sa musieť uistiť, že ste pokryli veľa okrajových prípadov a váš kód by mal byť bez chýb.

V priebehu rokov vývojári vytvorili rámce ako ExpressJS, NestJS, Fastify atď., Aby to bolo oveľa jednoduchšie.