Node-Anwendung mit MongoDB optimieren
Entdecken Sie in diesem Tutorial, wie Sie nahtlos MongoDB mit Ihrer Node.js-Anwendung integrieren können. Von der Erstellung eines administrativen Benutzers bis hin zur Implementierung von Mongoose-Schemas und Controllern – erfahren Sie, wie Sie Ihre Daten effizient verwalten und Ihre Anwendung optimieren können.
Bei der Arbeit mit Node.js müssen Sie möglicherweise ein Projekt entwickeln, das Daten speichert und abfragt. In diesem Fall müssen Sie eine Datenbanklösung auswählen, die für die Daten und Abfragetypen Ihrer Anwendung sinnvoll ist.
In diesem Tutorial integrieren Sie eine MongoDB-Datenbank in eine vorhandene Node-Anwendung. NoSQL-Datenbanken wie MongoDB können nützlich sein, wenn Ihre Datenanforderungen Skalierbarkeit und Flexibilität umfassen. MongoDB integriert sich auch gut in Node, da sie so konzipiert ist, dass Sie asynchron mit JSON-Objekten arbeitet.
Um MongoDB in Ihr Projekt zu integrieren, verwenden Sie den Object Document Mapper (ODM) Mongoose, um Schemas und Modelle für Ihre Anwendungsdaten zu erstellen. Dies ermöglicht es Ihnen, Ihren Anwendungscode nach dem Modell-View-Controller (MVC)-Architekturmuster zu organisieren, das es Ihnen ermöglicht, die Logik zu trennen, wie Ihre Anwendung Benutzereingaben handhabt, von der Struktur Ihrer Daten und wie Sie dem Benutzer präsentiert werden. Die Verwendung dieses Musters kann zukünftige Tests und Entwicklungen erleichtern, indem Sie eine Trennung der Anliegen in Ihren Code einführen.
Am Ende des Tutorials haben Sie eine funktionierende Anwendung zur Haifischinformation, die die Eingabe eines Benutzers über Ihre Lieblingshaie entgegennimmt und die Ergebnisse im Browser anzeigt.
Voraussetzungen
- Ein lokaler Entwicklungsmaschine oder Server, der Ubuntu 18.04 ausführt, zusammen mit einem nicht-root Benutzer mit Sudo-Berechtigungen und einer aktiven Firewall.
- Node.js und npm auf Ihrer Maschine oder Ihrem Server installiert, nach den Anweisungen zur Installation mit dem PPA von NodeSource.
- MongoDB auf Ihrer Maschine oder Ihrem Server installiert, nach Schritt 1 von Wie man MongoDB in Ubuntu 18.04 installiert.
Schritt 1: Erstellen eines Mongo-Benutzers
Bevor wir mit dem Arbeiten am Anwendungscode beginnen, erstellen wir einen Administrationsbenutzer, der Zugriff auf die Datenbank unserer Anwendung hat.
Zuerst überprüfen wir, ob MongoDB auf Ihrem Server läuft:
sudo systemctl status mongodb
Öffnen Sie dann die Mongo-Shell, um Ihren Benutzer zu erstellen:
mongo
Verwenden Sie dann in der Shell die `use admin` Befehl, um die admin-Datenbank zu verwenden, um Ihren Benutzer zu erstellen. Ersetzen Sie `sammy` und `your_password` durch Ihren eigenen Benutzernamen und Ihr eigenes Passwort.
use admin
db.createUser(
{
user: „sammy“,
pwd: „your_password“,
roles: [ { role: „userAdminAnyDatabase“, db: „admin“ } ]
}
)
Mit dem erstellten Benutzer können Sie die Mongo-Shell jetzt verlassen:
exit
Schritt 2: Hinzufügen von Mongoose und Datenbankinformationen zum Projekt
Klonen Sie zunächst den Anfangscode des Projekts und fügen Sie Mongoose und Ihre MongoDB-Datenbankinformationen hinzu.
Klonen Sie das Repository in ein Verzeichnis namens `node_project`:
git clone https://github.com/do-community/nodejs-image-demo.git node_project
Fügen Sie dann das Mongoose npm-Paket zum Projekt hinzu:
npm install mongoose
Erstellen Sie eine Datei für Ihre Datenbankverbindungsinformationen namens `db.js`.
Fügen Sie den folgenden Inhalt in die `db.js` Datei ein:
const mongoose = require(‚mongoose‘);
const MONGO_USERNAME = ’sammy‘;
const MONGO_PASSWORD = ‚your_password‘;
const MONGO_HOSTNAME = ‚127.0.0.1‘;
const MONGO_PORT = ‚27017‘;
const MONGO_DB = ’sharkinfo‘;
const url = `mongodb://${MONGO_USERNAME}:${MONGO_PASSWORD}@${MONGO_HOSTNAME}:${MONGO_PORT}/${MONGO_DB}?authSource=admin`;
mongoose.connect(url, {useNewUrlParser: true});
Fügen Sie schließlich die Datenbankverbindungsinformationen zur `app.js` Datei hinzu, damit die Anwendung darauf zugreifen kann.
Schritt 3: Erstellen von Mongoose-Schemas und -Modellen
Denken Sie als nächstes über die Struktur der Haifischsammlung nach, die Benutzer mit Ihren Eingaben in der Haifischinformationsseite der Anwendung erstellen werden.
Erstellen Sie ein Schema und ein Modell für die Haie in einer Datei namens `sharks.js`.
Fügen Sie den folgenden Inhalt in die `sharks.js` Datei ein:
const mongoose = require(‚mongoose‘);
const Schema = mongoose.Schema;
const Shark = new Schema ({
name: { type: String, required: true },
character: { type: String, required: true },
});
module.exports = mongoose.model(‚Shark‘, Shark)
Schritt 4: Erstellen von Controllern
Erstellen Sie einen Controller, der festlegt, wie die Benutzereingaben gespeichert und an den Benutzer zurückgegeben werden.
Erstellen Sie einen Controller in einer Datei namens `sharks.js` im Verzeichnis `controllers`.
Fügen Sie den folgenden Inhalt in die `sharks.js` Datei ein:
const path = require(‚path‘);
const Shark = require(‚../models/sharks‘);
exports.index = function (req, res) {
res.sendFile(path.resolve(‚views/sharks.html‘));
};
exports.create = function (req, res) {
var newShark = new Shark(req.body);
newShark.save(function (err) {
if(err) {
res.status(400).send(‚Unable to save shark to database‘);
} else {
res.redirect(‚/sharks/getshark‘);
}
});
};
exports.list = function (req, res) {
Shark.find({}).exec(function (err, sharks) {
if (err) {
return res.send(500, err);
}
res.render(‚getshark‘, {
sharks: sharks
});
});
};
Schritt 5: Einrichten der Express Middleware
Um unsere Anwendung in der Lage zu machen, mit Benutzerdaten zu arbeiten, müssen wir zwei Dinge tun: Zuerst werden wir eine eingebaute Express-Middleware-Funktion namens `urlencoded()` einbinden, die es unserer Anwendung ermöglicht, die vom Benutzer eingegebenen Daten zu parsen. Zweitens werden wir Template-Tags zu unseren Ansichten hinzufügen, um eine dynamische Interaktion mit Benutzerdaten in unserem Code zu ermöglichen.
Öffnen Sie dazu zunächst Ihre `app.js`-Datei und fügen Sie folgende Zeile oberhalb der `express.static()`-Funktion hinzu:
app.use(express.urlencoded({ extended: true }));
Diese Funktion ermöglicht den Zugriff auf die geparsten POST-Daten unseres Haifisch-Informationssystems. Die Option `extended: true` ermöglicht eine größere Flexibilität beim Parsen verschiedener Arten von Daten.
Schritt 6: Hinzufügen von EJS-Tags zur dynamischen Interaktion
Um dynamische Inhalte basierend auf Benutzerdaten in unseren Ansichten zu rendern, fügen wir Template-Tags hinzu. Installieren Sie zunächst das EJS-Paket mit npm:
npm install ejs
Öffnen Sie dann Ihre Ansichtsdatei `sharks.html` und fügen Sie ein Formular hinzu, in dem Benutzer Informationen über Haie eingeben können. Fügen Sie außerdem Template-Tags hinzu, um diese Daten dynamisch zu rendern.
Durch die Verwendung von Template-Tags und JavaScript-Syntax können wir die Benutzereingaben den entsprechenden Feldern in unserem Datenmodell zuordnen.
Schritt 7: Routing und Controller-Logik einrichten
Um die Anwendung dynamisch zu gestalten und Benutzerdaten zu verarbeiten, müssen wir die Routen und Controller-Logik einrichten. Dies umfasst das Erstellen von Routen für das Anzeigen von Haifischinformationen und das Hinzufügen neuer Haie.
router.get(‚/‘, function(req, res){
shark.index(req,res);
});
router.post(‚/addshark‘, function(req, res) {
shark.create(req,res);
});
Diese Routen verwenden die entsprechenden Funktionen in unserem Shark-Controller, um die angeforderten Aktionen auszuführen.
Fazit
Durch die Verwendung von EJS und Express Middleware können wir Benutzerdaten sammeln und dynamisch auf unserer Website rendern. Dies ermöglicht eine benutzerfreundliche Interaktion und eröffnet zahlreiche Möglichkeiten für die Erstellung dynamischer Webanwendungen.
