Cara Membuat API NodeJS Tanpa Menggunakan Rangka Kerja

Cara Membuat API NodeJS Tanpa Menggunakan Rangka Kerja

Node.js ialah masa jalan JavaScript sumber terbuka yang dibina pada enjin v8 chrome yang membolehkan anda menjalankan kod JavaScript di luar penyemak imbas.





Model acara, ekosistem dan kelajuannya telah menjadikan Node.js sebagai salah satu masa jalan yang paling dikehendaki dan digunakan untuk aplikasi sebelah pelayan.



Kebanyakan pelayan API Node.js menggunakan Express atau rangka kerja lain. Walau bagaimanapun, anda juga boleh mencipta API Node.js ringkas tanpa rangka kerja dalam beberapa langkah sahaja.





MAKEUSEOF VIDEO OF THE DAY

Langkah 1: Sediakan Persekitaran Pembangunan Anda

Buat direktori projek dan cd ke dalamnya dengan menjalankan:

mkdir nodejs-api 
cd nodejs-api

Seterusnya, mulakan npm dalam projek anda dengan menjalankan:



npm init -y

API CRUD ini akan menampilkan penggunaan MongoDB, pangkalan data NoSQL, dan ODM yang popular, mongoose.

Jalankan arahan berikut untuk memasang mongoose :



google drive video tidak dapat dimainkan 
npm install mongoose

Seterusnya, buat a server.js fail dalam direktori akar projek anda dan tambahkan blok kod di bawah untuk membuat pelayan:

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

Blok kod ini mengimport modul http, modul teras Node.js. Modul http membenarkan Node.js memindahkan data melalui HTTP. Modul ini mengandungi kaedah yang diperlukan untuk mencipta pelayan.



Seterusnya, ia memanggil modul http createServer kaedah yang mencipta dan mengembalikan contoh pelayan. The createServer kaedah mengambil fungsi panggil balik dengan objek permintaan dan tindak balas sebagai parameter.

Seterusnya, kod itu memanggil dengar kaedah pada contoh pelayan yang dikembalikan. Ini membolehkan pelayan mula mendengar trafik pada port yang diberikan. The dengar kaedah melancarkan panggilan balik—hujah kedua—apabila ia berjaya.

Akhir sekali, buat dua direktori bernama laluan dan model dalam direktori akar projek anda. The laluan folder akan mengandungi logik penghalaan untuk API anda, manakala model akan mengandungi semua yang berkaitan dengan pangkalan data.

Langkah 2: Menyambungkan Aplikasi Anda ke Pangkalan Data

Dalam server.js , import mongoose :

const mongoose = require("mongoose");

Panggil ke menyambung kaedah pada mongoose dan lulus URI MongoDB anda sebagai hujah:

mongoose.connect("MongoDB_URI")

Langkah 3: Mencipta Model API

Buat API CRUD untuk aplikasi blog mudah. dalam anda model folder, buat a blogModel.js fail dan tambah kod berikut pada fail anda:

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

Blok kod di atas mencipta model mongoose dengan dua sifat dan memetakannya ke pangkalan data MongoDB.

Kedua-dua sifat dalam model ini mempunyai a Tali taip dengan diperlukan ditetapkan untuk benar . Mesej ralat yang disertakan akan dipaparkan jika badan permintaan tidak mengandungi salah satu sifat.

Baris akhir mencipta dan mengeksport model mongoose dengan memanggil model kaedah pada mongoose. Lulus nama model ( Blog ) sebagai hujah pertama dan skema ( blogSchedule ) sebagai hujah kedua.

Langkah 4: Melaksanakan Penghalaan dalam Aplikasi Anda

Tanpa bantuan daripada rangka kerja seperti Express , anda perlu mencipta logik secara manual untuk mengendalikan setiap permintaan yang dibuat kepada API anda.

Pertama, buat a blogRoutes.js fail dalam anda laluan folder, kemudian import model blog:

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

Seterusnya, buat tak segerak penghala fungsi, lulus req dan semula sebagai parameter, dan eksport fungsi:

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

Fungsi ini akan mengandungi semua logik penghalaan anda.

Seterusnya, anda akan melaksanakan laluan logik penghalaan mengikut laluan.

GET Laluan

Tambahkan blok kod di bawah pada anda penghala berfungsi untuk melaksanakan DAPATKAN pengendali laluan untuk permintaan yang dibuat kepada /api/blogs :

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

Blok kod di atas menyemak url dan kaedah sifat objek permintaan. Ia kemudian mengambil semua blog daripada pangkalan data melalui cari kaedah pada model mongoose ( Blog ).

Seterusnya, ia memanggil tulisKepala kaedah pada semula , objek tindak balas. Kaedah ini menghantar pengepala respons diberikan tiga argumen: kod status, mesej status pilihan dan pengepala. The 200 kod status mewakili respons yang berjaya dan jenis kandungan untuk panggilan API ini ditetapkan kepada aplikasi/json .

mengapa saya tidak boleh memotong dalam pratonton

Akhir sekali, tutup permintaan untuk memastikan pelayan tidak hang dengan memanggil tamat kaedah pada semula . Panggilan kepada JSON.stringify menukarkan blog membantah rentetan JSON dan menghantarnya ke tamat kaedah mengembalikannya sebagai badan tindak balas.

Tambahkan blok kod di bawah pada anda penghala berfungsi untuk melaksanakan DAPATKAN pengendali laluan untuk satu sumber:

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

Kod ini menggunakan perlawanan kaedah, yang mengambil ungkapan regex sebagai hujah, untuk menyemak sama ada url sepadan dengan format: /api/blogs/ .

Seterusnya, ekstrak ID harta daripada url rentetan dengan memanggilnya berpecah kaedah. Kaedah ini mengambil corak sebagai hujah ( / ), memisahkan rentetan berdasarkan corak dan mengembalikan tatasusunan. Elemen ketiga tatasusunan itu ialah ID .

cara menetapkan gif sebagai latar belakang anda

Akhir sekali, dapatkan semula dokumen dengan padanan ID daripada pangkalan data anda. Jika wujud, hantar a kod jawapan 200 , tutup permintaan dan hantar blog yang diambil semula. Jika ia tidak wujud, buang ralat dan hantarkannya sebagai respons dalam blok tangkapan.

Laluan POST

Tambahkan blok kod di bawah pada fungsi penghala anda untuk melaksanakan POS pengendali laluan:

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

Objek permintaan melaksanakan Node.js ReadableStream antara muka. Aliran ini mengeluarkan a data dan an tamat acara yang memberi anda akses kepada data daripada badan permintaan.

Kod ini mendengar peristiwa data dan mengendalikannya dengan menukarkannya kepada rentetan dan menggabungkannya kepada badan pembolehubah. Di dalam tamat pengendali acara, ia mewujudkan a Blog contoh dengan rentetan badan yang dihuraikan. Ia kemudian menyimpan blog baharu, menghantar kod status dan pengepala kandungan, dan menutup permintaan.

Laluan PUT

Tambahkan blok kod di bawah pada fungsi penghala anda untuk melaksanakan LETAK pengendali laluan:

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

Pengendali permintaan PUT hampir sama dengan POS pengendali permintaan, kecuali ia mengekstrak ID harta daripada url untuk mengemaskini blog yang berkaitan.

PADAM Laluan

Tambahkan blok kod di bawah pada fungsi penghala anda untuk melaksanakan anda PADAM pengendali laluan:

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

Blok kod ini mengekstrak ID daripada url , memadamkan dokumen dengan padanan ID , menghantar kod status dan pengepala, dan menutup permintaan.

Akhir sekali, import penghala dalam awak server.js fail dan hubungi anda penghala fungsi, lulus req dan semula sebagai hujah:

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

Ini membolehkan pelayan anda memintas dan mengendalikan permintaan dengan sewajarnya.

Anda boleh mencari projek yang telah siap dalam ini repositori GitHub .

Menggunakan Rangka Kerja Node.js

Walaupun anda boleh membuat API web dengan tangan, ia boleh menjadi tugas yang sukar. Anda perlu memastikan anda telah merangkumi banyak kes tepi dan kod anda lebih baik bebas pepijat.

Selama bertahun-tahun, pembangun telah membina rangka kerja seperti ExpressJS, NestJS, Fastify, dll., untuk menjadikannya lebih mudah.