Erstellen einer schnellen und flexiblen CRUD-API mit nativen Node.js- und MongoDB-Treibern

Verwendung von Node.js und Express mit nativen MongoDB-Treibern: Warum und wie

Wenn Sie mit Node.js und Express arbeiten, sind Sie möglicherweise auf Mongoose gestoßen, eine beliebte ODM-Bibliothek (Object Data Modeling) für MongoDB. Obwohl Mongoose viele hilfreiche Funktionen bietet, gibt es Gründe, warum Sie sich dafür entscheiden könnten, direkt mit den nativen Treibern von MongoDB zu arbeiten. In diesem Beitrag erläutere ich Ihnen die Vorteile der Verwendung nativer MongoDB-Treiber und erkläre Ihnen, wie Sie damit eine einfache CRUD-API implementieren können.

Warum native MongoDB-Treiber verwenden?

1. Leistung: Native MongoDB-Treiber bieten eine bessere Leistung, indem sie direkt mit MongoDB interagieren, ohne die zusätzliche Abstraktionsschicht, die Mongoose einführt. Dies kann besonders bei Hochleistungsanwendungen von Vorteil sein.

2. Flexibilität: Native Treiber bieten eine bessere Kontrolle über Ihre Abfragen und Dateninteraktionen. Mongoose legt mit seinen Schemata und Modellen eine gewisse Struktur fest, die möglicherweise nicht für jeden Anwendungsfall ideal ist.

3. Reduzierter Overhead: Durch die Verwendung nativer Treiber vermeiden Sie den zusätzlichen Overhead für die Pflege von Mongoose-Schemas und -Modellen, was Ihre Codebasis vereinfachen kann.

4. Lernmöglichkeit: Die direkte Zusammenarbeit mit nativen Treibern hilft Ihnen, die Abläufe von MongoDB besser zu verstehen und kann eine großartige Lernerfahrung sein.

Implementierung einer CRUD-API mit nativen MongoDB-Treibern

Hier finden Sie eine Schritt-für-Schritt-Anleitung zum Einrichten einer einfachen CRUD-API mit nativen Node.js-, Express- und MongoDB-Treibern.

1. Datenbankverbindung einrichten

Erstellen Sie eine utils/db.js-Datei, um die MongoDB-Verbindung zu verwalten:

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. Definieren Sie Ihr Modell

Erstellen Sie eine models/model.js-Datei, um mit der MongoDB-Sammlung zu interagieren:

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. Richten Sie Routen ein

Erstellen Sie eine index.js-Datei, um Ihre API-Routen zu definieren:

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. Implementieren Sie Controller

Erstellen Sie eine userController.js-Datei, um Ihre CRUD-Vorgänge zu verarbeiten:

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. Konfiguration

Speichern Sie Ihre MongoDB-Verbindungszeichenfolge in einer .env-Datei und erstellen Sie eine db.config.js-Datei, um sie zu laden:

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

Abschluss

Der Wechsel von Mongoose- zu MongoDB-nativen Treibern kann für bestimmte Projekte eine strategische Entscheidung sein und Leistungsvorteile und größere Flexibilität bieten. Die hier bereitgestellte Implementierung sollte Ihnen eine solide Grundlage bieten, um mit der Erstellung von Anwendungen mit nativen Node.js- und MongoDB-Treibern zu beginnen.

Schauen Sie sich gerne den vollständigen Code auf GitHub an und entdecken Sie weitere Funktionen oder Verbesserungen für Ihre eigenen Projekte!

Bei weiteren Fragen können Sie gerne einen Kommentar abgeben.

Viel Spaß beim Codieren! ?

Das obige ist der detaillierte Inhalt vonErstellen einer schnellen und flexiblen CRUD-API mit nativen Node.js- und MongoDB-Treibern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!