Ako vytvoriť NodeJS API bez použitia rámca

Ako vytvoriť NodeJS API bez použitia rámca

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.





VYUŽITIE VIDEA DŇA

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 install mongoose

Ď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:

const http = require("http"); 
const server = http.createServer((req, res) => {}); 
  
server.listen(3000, () => { 
  console.log(`Server is running`); 
});

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 :

const mongoose = require("mongoose");

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:

const mongoose = require("mongoose"); 
const blogSchema = mongoose.Schema({ 
  title: { 
    type: String, 
    required: [true, "Blog must have a title"], 
  }, 
  body: { 
    type: String, 
    required: [true, "Blog must have a body"], 
  }, 
}); 
module.exports = 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 ( blogSchedule ) 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:

ako odstrániť moje vyhľadávania Google 
const Blog = require("../models/blogModel");

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

const router = async function (req, res) {}; 
module.exports = 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 :

ako vytvoriť tapetu pre prezentáciu v systéme Windows 10 
//  GET: /api/blogs 
if (req.url === "/api/blogs" && req.method === "GET") { 
    // get all blogs 
    const blogs = await Blog.find(); 
  
    // set the status code and content-type 
    res.writeHead(200, { "Content-Type": "application/json" }); 
  
    // send data 
    res.end(JSON.stringify(blogs)); 
}

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 trasy pre jeden zdroj:

// GET: /api/blogs/:id 
if (req.url.match(/\/api\/blogs\/([0-9]+)/) && req.method === "GET") { 
    try { 
        // extract id from url 
        const id = req.url.split("/")[3]; 
  
        // get blog from DB 
        const blog = await Blog.findById(id); 
  
        if (blog) { 
            res.writeHead(200, { "Content-Type": "application/json" }); 
            res.end(JSON.stringify(blog)); 
        } else { 
            throw new Error("Blog does not exist"); 
        } 
    } catch (error) { 
        res.writeHead(404, { "Content-Type": "application/json" }); 
        res.end(JSON.stringify({ message: error })); 
    } 
}

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/<číslo> .

Ď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.method === "POST") { 
    try { 
        let body = ""; 
  
        // Listen for data event 
        req.on("data", (chunk) => { 
            body += chunk.toString(); 
        }); 
  
        // Listen for end event 
        req.on("end", async () => { 
            // Create Blog 
            let blog = new Blog(JSON.parse(body)); 
  
            // Save to DB 
            await blog.save(); 
            res.writeHead(200, { "Content-Type": "application/json" }); 
            res.end(JSON.stringify(blog)); 
        }); 
    } catch (error) { 
        console.log(error); 
    } 
}

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.method === "PUT") { 
    try { 
        // extract id from url 
        const id = req.url.split("/")[3]; 
        let body = ""; 
  
        req.on("data", (chunk) => { 
            body += chunk.toString(); 
        }); 
        req.on("end", async () => { 
            // Find and update document 
            let updatedBlog = await Blog.findByIdAndUpdate(id, JSON.parse(body), { 
                new: true, 
            }); 
  
            res.writeHead(200, { "Content-Type": "application/json" }); 
            res.end(JSON.stringify(updatedBlog)); 
        }); 
    } catch (error) { 
        console.log(error); 
    } 
}

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:

// DELETE: /api/blogs/:id 
if (req.url.match(/\/api\/blogs\/([0-9]+)/) && req.method === "DELETE") { 
    try { 
        const id = req.url.split("/")[3]; 
         
       // Delete blog from DB 
        await Blog.findByIdAndDelete(id); 
        res.writeHead(200, { "Content-Type": "application/json" }); 
        res.end(JSON.stringify({ message: "Blog deleted successfully" })); 
    } catch (error) { 
        res.writeHead(404, { "Content-Type": "application/json" }); 
        res.end(JSON.stringify({ message: error })); 
    } 
}

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:

const router = require("./routes/blogRoutes"); 
  
const 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.