Membina API CRUD yang Pantas dan Fleksibel dengan Node.js dan Pemacu Asli MongoDB

Menggunakan Node.js dan Express dengan Pemacu Asli MongoDB: Mengapa dan Bagaimana

Jika anda bekerja dengan Node.js dan Express, anda mungkin pernah menemui Mongoose, perpustakaan ODM (Pemodelan Data Objek) yang popular untuk MongoDB. Walaupun Mongoose menyediakan banyak ciri berguna, terdapat sebab anda mungkin memilih untuk bekerja secara langsung dengan pemacu asli MongoDB. Dalam siaran ini, saya akan membimbing anda melalui faedah menggunakan pemacu asli MongoDB dan berkongsi cara anda boleh melaksanakan API CRUD mudah dengan mereka.

Mengapa Menggunakan Pemacu Asli MongoDB?

1. Prestasi: Pemacu asli MongoDB menawarkan prestasi yang lebih baik dengan berinteraksi secara langsung dengan MongoDB tanpa lapisan abstraksi tambahan yang diperkenalkan oleh Mongoose. Ini boleh memberi manfaat terutamanya untuk aplikasi berprestasi tinggi.

2. Fleksibiliti: Pemacu asli memberikan kawalan yang lebih besar ke atas pertanyaan dan interaksi data anda. Mongoose, dengan skema dan modelnya, mengenakan beberapa struktur, yang mungkin tidak sesuai untuk setiap kes penggunaan.

3. Overhed Dikurangkan: Dengan menggunakan pemacu asli, anda mengelakkan overhed tambahan untuk mengekalkan skema dan model Mongoose, yang boleh memudahkan pangkalan kod anda.

4. Peluang Pembelajaran: Bekerja secara langsung dengan pemacu asli membantu anda memahami operasi MongoDB dengan lebih baik dan boleh menjadi pengalaman pembelajaran yang hebat.

Melaksanakan API CRUD dengan Pemacu Asli MongoDB

Berikut ialah panduan langkah demi langkah tentang cara menyediakan API CRUD mudah menggunakan pemacu asli Node.js, Express dan MongoDB.

1. Sediakan Sambungan Pangkalan Data

Buat fail utils/db.js untuk mengurus sambungan MongoDB:

require('dotenv').config()
const dbConfig = require('../config/db.config');
const { MongoClient } = require('mongodb');

const client = new MongoClient(dbConfig.url);

let _db;
let connectPromise;

async function connectToDb() {
    if (!connectPromise) {
        connectPromise = new Promise(async (resolve, reject) => {
            try {
                await client.connect();
                console.log('Connected to the database ?', client.s.options.dbName);
                _db = client.db();
                resolve(_db);
            } catch (error) {
                console.error('Error connecting to the database:', error);
                reject(error);
            }
        });
    }
    return connectPromise;
}

function getDb() {
    if (!_db) {
        throw new Error('Database not connected');
    }
    return _db;
}

function isDbConnected() {
    return Boolean(_db);
}

module.exports = { connectToDb, getDb, isDbConnected };

2. Tentukan Model Anda

Buat fail models/model.js untuk berinteraksi dengan koleksi MongoDB:

const { ObjectId } = require('mongodb');
const db = require('../utils/db');

class AppModel {
    constructor($collection) {
        this.collection = null;

        (async () => {
            if (!db.isDbConnected()) {
                console.log('Waiting for the database to connect...');
                await db.connectToDb();
            }
            this.collection = db.getDb().collection($collection);
            console.log('Collection name:', $collection);
        })();
    }

    async find() {
        return await this.collection.find().toArray();
    }

    async findOne(condition = {}) {
        const result = await this.collection.findOne(condition);
        return result || 'No document Found!';
    }

    async create(data) {
        data.createdAt = new Date();
        data.updatedAt = new Date();
        let result = await this.collection.insertOne(data);
        return `${result.insertedId} Inserted successfully`;
    }

    async update(id, data) {
        let condition = await this.collection.findOne({ _id: new ObjectId(id) });
        if (condition) {
            const result = await this.collection.updateOne({ _id: new ObjectId(id) }, { $set: { ...data, updatedAt: new Date() } });
            return `${result.modifiedCount > 0} Updated successfully!`;
        } else {
            return `No document found with ${id}`;
        }
    }

    async deleteOne(id) {
        const condition = await this.collection.findOne({ _id: new ObjectId(id) });
        if (condition) {
            const result = await this.collection.deleteOne({ _id: new ObjectId(id) });
            return `${result.deletedCount > 0} Deleted successfully!`;
        } else {
            return `No document found with ${id}`;
        }
    }
}

module.exports = AppModel;

3. Sediakan Laluan

Buat fail index.js untuk menentukan laluan API anda:

const express = require('express');
const router = express.Router();

const users = require('../controllers/userController');

router.get("/users", users.findAll);
router.post("/users", users.create);
router.put("/users", users.update);
router.get("/users/:id", users.findOne);
router.delete("/users/:id", users.deleteOne);

module.exports = router;

4. Melaksanakan Pengawal

Buat fail userController.js untuk mengendalikan operasi CRUD anda:

const { ObjectId } = require('mongodb');
const Model = require('../models/model');

const model = new Model('users');

let userController = {
    async findAll(req, res) {
        model.find()
            .then(data => res.send(data))
            .catch(err => res.status(500).send({ message: err.message }));
    },
    async findOne(req, res) {
        let condition = { _id: new ObjectId(req.params.id) };
        model.findOne(condition)
            .then(data => res.send(data))
            .catch(err => res.status(500).send({ message: err.message }));
    },
    create(req, res) {
        let data = req.body;
        model.create(data)
            .then(data => res.send(data))
            .catch(error => res.status(500).send({ message: error.message }));
    },
    update(req, res) {
        let id = req.body._id;
        let data = req.body;
        model.update(id, data)
            .then(data => res.send(data))
            .catch(error => res.status(500).send({ message: error.message }));
    },
    deleteOne(req, res) {
        let id = new ObjectId(req.params.id);
        model.deleteOne(id)
            .then(data => res.send(data))
            .catch(error => res.status(500).send({ message: error.message }));
    }
}

module.exports = userController;

5. Konfigurasi

Simpan rentetan sambungan MongoDB anda dalam fail .env dan buat fail db.config.js untuk memuatkannya:

module.exports = {
    url: process.env.DB_CONFIG,
};

Kesimpulan

Bertukar daripada pemacu asli Mongoose kepada MongoDB boleh menjadi pilihan strategik untuk projek tertentu, menawarkan faedah prestasi dan lebih fleksibiliti. Pelaksanaan yang disediakan di sini seharusnya memberi anda asas yang kukuh untuk mula membina aplikasi dengan pemacu asli Node.js dan MongoDB.

Sila lihat kod penuh di GitHub dan teroka lebih banyak ciri atau peningkatan untuk projek anda sendiri!

Sebarang pertanyaan lanjut boleh komen.

Selamat pengekodan! ?

Atas ialah kandungan terperinci Membina API CRUD yang Pantas dan Fleksibel dengan Node.js dan Pemacu Asli MongoDB. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!