Kako ustvariti API NodeJS brez uporabe ogrodja

Kako ustvariti API NodeJS brez uporabe ogrodja

Node.js je odprtokodno izvajalno okolje JavaScript, zgrajeno na Chromovem mehanizmu v8, ki omogoča izvajanje kode JavaScript zunaj brskalnika.





Njegov model dogodkov, ekosistem in hitrost so naredili Node.js enega najbolj zaželenih in uporabljanih izvajalnih časov za aplikacije na strani strežnika.



Večina strežnikov API Node.js uporablja Express ali drugo ogrodje. Lahko pa ustvarite tudi preprost API Node.js brez ogrodja v le nekaj korakih.





MAKEUSEOF VIDEO DNEVA

1. korak: Nastavitev vašega razvojnega okolja

Ustvarite imenik projekta in cd vanj tako, da zaženete:

mkdir nodejs-api 
cd nodejs-api

Nato inicializiraj npm v vašem projektu tako, da zaženete:



npm init -y

Ta CRUD API bo vseboval uporabo MongoDB, baze podatkov NoSQL, in njenega priljubljenega ODM, mongoose.

Za namestitev zaženite naslednji ukaz mungos :



npm install mongoose

Nato ustvarite a server.js datoteko v korenskem imeniku vašega projekta in dodajte spodnji blok kode, da ustvarite strežnik:

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

Ta blok kode uvozi modul http, jedrni modul Node.js. Modul http omogoča Node.js prenos podatkov prek HTTP. Ta modul vsebuje metode, potrebne za ustvarjanje strežnika.



Nato pokliče module http createServer metoda, ki ustvari in vrne primerek strežnika. The createServer metoda vzame funkcijo povratnega klica z objektom zahteve in odgovora kot parametroma.

Nato koda pokliče poslušaj metodo na vrnjenem primerku strežnika. To omogoča strežniku, da začne poslušati promet na danih vratih. The poslušaj metoda sproži povratni klic – drugi argument – ​​ko uspe.

ali lahko vidite svoje naročnike na youtube

Na koncu ustvarite dva imenika z imenom poti in modeli v korenskem imeniku vašega projekta. The poti bo vsebovala logiko usmerjanja za vaš API, medtem ko model bo vseboval vse, kar je povezano z bazo podatkov.

2. korak: Povezovanje aplikacije z zbirko podatkov

notri server.js , uvoz mungos :

const mongoose = require("mongoose");

Pokličite povezati metoda na mungos in posredujte svoj MongoDB URI kot argument:

mongoose.connect("MongoDB_URI")

3. korak: Ustvarjanje modela API

Ustvarite CRUD API za preprosto spletno aplikacijo. V vašem modeli mapo, ustvarite a blogModel.js in svoji datoteki dodajte naslednjo kodo:

t-mobile mlb tv 2021 
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);

Zgornji blok kode ustvari model mongoose z dvema lastnostma in ju preslika v bazo podatkov MongoDB.

Obe lastnosti v tem modelu imata a Vrvica tip z potrebno nastavljena prav . Spremljevalna sporočila o napakah se prikažejo, če telo zahteve ne vsebuje nobene od lastnosti.

Zadnja vrstica ustvari in izvozi model mongoose s klicem model metoda na mungos. Posredujte ime modela ( Blog ) kot prvi argument in shema ( blogSchedule ) kot drugi argument.

4. korak: Implementacija usmerjanja v vaši aplikaciji

Brez pomoči ogrodja, kot je Express , boste morali ročno ustvariti logiko za obravnavo vsake zahteve v vašem API-ju.

Najprej ustvarite a blogRoutes.js datoteko v vašem poti mapo, nato uvozite model bloga:

const Blog = require("../models/blogModel");

Nato ustvarite asinhrono usmerjevalnik funkcija, pass zahtevano in res kot parametre in izvozite funkcijo:

const router = async function (req, res) {}; 
module.exports = router;

Ta funkcija bo vsebovala vso vašo logiko usmerjanja.

Nato boste implementirali logiko usmerjanja pot za potjo.

GET Routes

Dodajte spodnji kodni blok svojemu usmerjevalnik funkcijo za izvajanje DOBITI upravljavec poti za zahteve /api/blogi :

//  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)); 
}

Zgornji blok kode preveri url in metoda lastnosti objekta zahteve. Nato pridobi vse bloge iz baze podatkov prek najti metoda na mungosovem modelu ( Blog ).

Nato pokliče writeHead metoda na res , objekt odziva. Ta metoda pošlje glavo odgovora s tremi argumenti: statusno kodo, neobvezno statusno sporočilo in glave. The 200 statusna koda predstavlja uspešen odgovor in tip vsebine za ta klic API-ja je nastavljen na aplikacija/json .

Na koncu zaprite zahtevo, da zagotovite, da strežnik ne bo obsojen, tako da pokličete konec metoda na res . Klic na JSON.stringify pretvarja blogi objekt v niz JSON in posredovanje tega v konec metoda ga vrne kot telo odziva.

Dodajte spodnji kodni blok svojemu usmerjevalnik funkcijo za izvajanje DOBITI upravljalnik poti za posamezen vir:

// 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 })); 
    } 
}

Ta koda uporablja tekma metoda, ki sprejme izraz regularnega izraza kot argument, da preveri, ali se url ujema z obliko: /api/blogs/<številka> .

Nato izvlecite id premoženje iz url niz tako, da ga pokličete razdeliti metoda. Ta metoda vzame vzorec kot argument ( / ), razdeli niz na podlagi vzorca in vrne matriko. Tretji element tega niza je id .

Nazadnje pridobite dokument z ujemanjem id iz vaše baze podatkov. Če obstaja, pošljite a koda odgovora 200 , zaprite zahtevo in pošljite pridobljeni blog. Če ne obstaja, sproži napako in jo pošlji kot odgovor v bloku catch.

POST pot

Dodajte spodnji blok kode v funkcijo usmerjevalnika, da implementirate OBJAVI upravljavec poti:

// 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 zahteve implementira Node.js ReadableStream vmesnik. Ta tok oddaja a podatke in an konec dogodek, ki vam omogoči dostop do podatkov iz telesa zahteve.

Ta koda posluša podatkovni dogodek in ga obravnava tako, da ga pretvori v niz in združi v telo spremenljivka. V konec obdelovalnik dogodkov, ustvari a Blog primerek z razčlenjenim telesnim nizom. Nato shrani nov spletni dnevnik, pošlje statusno kodo in glavo vsebine ter zapre zahtevo.

PUT Pot

Dodajte spodnji blok kode v funkcijo usmerjevalnika, da implementirate POSTAVITE upravljavec poti:

// 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); 
    } 
}

Obravnavalec zahtev PUT je skoraj enak OBJAVI obdelovalnik zahtev, le da ekstrahira id premoženje iz url za posodobitev ustreznega bloga.

IZBRIŠI pot

Spodnji blok kode dodajte funkciji usmerjevalnika, da izvedete svojo IZBRIŠI upravljavec poti:

// 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 })); 
    } 
}

Ta blok kode ekstrahira id Iz url , izbriše dokument z ujemanjem id , pošlje statusno kodo in glave ter zapre zahtevo.

Končno, uvoz usmerjevalnik v tvojem server.js datoteko in pokličite svojega usmerjevalnik funkcija, prehajanje zahtevano in res kot argumenti:

const router = require("./routes/blogRoutes"); 
  
const server = http.createServer((req, res) => { 
    router(req, res); 
});

To vašemu strežniku omogoča, da prestreže in ustrezno obravnava zahteve.

Dokončan projekt lahko najdete tukaj Repozitorij GitHub .

Uporaba ogrodja Node.js

Čeprav je mogoče ustvariti spletni API ročno, je to lahko težka naloga. Prepričati se boste morali, da ste pokrili veliko robnih primerov in da je bolje, da vaša koda ne vsebuje hroščev.

najboljši format za zunanji pogon Mac

Z leti so razvijalci zgradili ogrodja, kot so ExpressJS, NestJS, Fastify itd., da bi bilo veliko lažje.