Einführung
MongoDB ist die beliebteste NoSQL-Datenbank. Sie speichert Daten in Sammlungen. Die einzelnen Datensätze in einer Sammlung werden Dokumente genannt und weisen eine Schlüssel-Wert-Struktur ähnlich wie JSON-Daten auf. MongoDB wird aufgrund seiner Leistungsfähigkeit, Flexibilität und Skalierbarkeit bevorzugt.
Was ist ein Mungo?
Mongoose ist eine auf Promises basierende Bibliothek zur objektorientierten Datenmodellierung (ODM) für das Node.js-Framework. Mongoose vereinfacht die Interaktion mit der MongoDB-Datenbank. Sie ermöglicht das Erstellen und Modellieren von MongoDB-Schemas. Dadurch entfällt das Schreiben komplexer Datenbankabfragen und -schemas. Mit Mongoose können Sie die Daten modellieren, die Sie in MongoDB speichern möchten.
Diese Anleitung hilft Ihnen zu verstehen, wie Sie MongoDB mithilfe von Mongoose mit Node.js verbinden.
Voraussetzung:
Um dieser Anleitung zu folgen, stellen Sie sicher, dass Node.js auf Ihrem Computer installiert ist. MongoDB muss entweder auf Ihrem Computer installiert oder in einem MongoDB Atlas Cloud-Konto eingerichtet sein. Grundkenntnisse in der Erstellung von Node.js-Servern sind erforderlich. Postman muss installiert sein. Einrichten eines Node.js-Mongoose-Projekts: Wechseln Sie in den gewünschten Ordner und führen Sie `npm init -y` aus. Installieren Sie anschließend die folgenden Pakete: Express – zum Erstellen eines Node.js-HTTP-Servers. Mongoose – ein ODM für MongoDB in Node.js.
npm install mongoose --save
Kommunikation mit Mongoose und MongoDB in Node.js Um mit Mongoose über Mongoose zu kommunizieren, erstellen Sie eine Datei namens db.js und konfigurieren Sie die Mongoose-Verbindung wie folgt:
Importieren Sie die Mongoose-Bibliothek:
const connectDB = async () => {
try {
const conn = await mongoose.connect(`mongodb://localhost:27017/test`, {
useNewUrlParser: true,
});
console.log(`MongoDB Connected: {conn.connection.host}`);
} catch (error) {
console.error(error.message);
process.exit(1);
}
}Die hier verwendete MongoDB läuft lokal. Mongoose stellt daher eine Verbindung zu Ihrer Datenbank her. Stellen Sie sicher, dass Sie die korrekte URI eingeben, die zu Ihrer lokalen MongoDB-Installation oder zu MongoDB Atlas cloud führt: cloud.mongodb://localhost:27017test.
Abschließend exportiert die Funktion connectDB:
module.exports = connectDB;Zustand und Import der db.js-Datei:
const express = require('express');
const connectDB = require('./db'); Fügen Sie die Express-Middleware und den Parser hinzu:
// express
const app = express();
//body parser
app.use(express.json());Führen Sie die Funktion connectDB() aus:
//connect to database
connectDB();Server-Root hinzufügen:
// routes
// We will add these routes later in this guide.Führen Sie das Programm auf dem lokalen Port aus:
onst PORT = process.env.PORT || 5000;
app.listen(PORT, () => console.log(`Server running on port {PORT}`));Modellieren Sie ein Schema mit Mongoose
Ein Modell definiert ein Sammlungsschema in einer MongoDB-Datenbank. Erstellen Sie eine model.js-Datei und ein Mongoose-Sammlungsschema wie folgt:
const {
Schema,
model
} = require("mongoose");
const MySchema = new Schema({
name: {
type: String,
required: true,
maxlength: 50
},
createdAt: {
type: Date,
default: Date.now,
},
});
const TaskModel = model("test", MySchema)
module.exports = TaskModelHier erstellen wir eine Funktion `MySchema`, die die Methode `mongoose.Schema` ausführt. Diese Methode richtet das Schema ein, das Mongoose auf MongoDB ausführt. Um das Schema zu erstellen, fügen Sie die Dateien Ihrem Dokument hinzu. In diesem Fall fügen wir zwei Felder hinzu:
Name – Im obigen Code wird dieses Feld als Zeichenkette mit einer maximalen Länge von fünfzig Zeichen erstellt. Die Option „Erforderlich“ ist auf „true“ gesetzt, um anzugeben, dass jedes Dokument dieses Feld enthalten muss.
Das Feld „createAt“ gibt den Zeitpunkt der Dokumenterstellung an. Standardmäßig wird das aktuelle Datum als Erstellungsdatum verwendet.
Füge der Datenbank Daten mithilfe des Mongoose-Schemas hinzu:
Um Daten zur Datenbank hinzuzufügen, erstellen Sie eine controller.js-Datei.
Importiere MySchema aus der Modelldatei const Task = require('./model');
Füge dem Aufgabensatz eine Aufgabe hinzu. Dadurch wird der POST-Pfad festgelegt.
exports.createTask = async (req, res) => {
try {
// get the task from the body
const taskData = await req.body;
//create a new task then save
await Task.create(taskData)
.then((createdTask) => {
if (!createdTask) return res.status(404)
.json({
success: false,
message: "Task creation failed",
error: "Unable get created task"
})
res.status(201)
.json({
success: true,
createdTask
})
})
.catch((error) => {
res.status(404)
.json({
success: false,
error: error.message
})
})
} catch (error) {
res.status(500)
.json({
success: false,
message: "Internal server error"
})
}
}Alle Aufgaben wiederherstellen:
Fügen Sie diesen Code in die Datei controller.js ein. Dadurch wird die GET-Route festgelegt.
exports.createTask = async (req, res) => {
try {
// get the task from the body
const taskData = await req.body;
//create a new task then save
await Task.create(taskData)
.then((createdTask) => {
if (!createdTask) return res.status(404)
.json({
success: false,
message: "Task creation failed",
error: "Unable get created task"
})
res.status(201)
.json({
success: true,
createdTask
})
})
.catch((error) => {
res.status(404)
.json({
success: false,
error: error.message
})
})
} catch (error) {
res.status(500)
.json({
success: false,
message: "Internal server error"
})
}
}
exports.getTasks = async (req, res) => {
//get all the data in the model and return it as response
try {
Task.find()
.then((allTasks) => {
res.status(200)
.json({
success: true,
allTasks
})
})
.catch((error) => {
res.status(404)
.json({
success: false,
message: "Cant fined ",
error
})
})
} catch (error) {
res.status(500)
.json({
success: false,
message: "Internal server error",
error: error.message
})
}
}Route erstellen:
Erstellen Sie eine Route, um die oben genannten Controller auszuführen. Erstellen Sie eine neue Datei namens routes.js und fügen Sie den folgenden Code hinzu:
const router = require("express")
.Router()
const controller = require('./controller')
router
.post('/', controller.createTask)
.get('/', controller.getTasks)
module.exports = routerZum Schluss müssen diese Routen in der Datei server.js ausgeführt werden.
const router = require('./routes')
app.use('/tasks', router)Um eine neue Aufgabe hinzuzufügen, senden Sie eine POST-Anfrage mit Postman wie folgt:
Um die hinzugefügten Aufgaben abzurufen, senden Sie eine GET-Anfrage mit Postman wie folgt:
Die hinzugefügten Aufgaben können Sie in Ihrer MongoDB-Datenbank einsehen:
