Integreer uw Node.js-toepassing met een MongoDB-database met behulp van Mongoose.
Het beheren van gegevens in een MongoDB-database kan een uitdaging zijn, vooral als het gaat om complexe gegevensmodellen. MongoDB is een database zonder schema, wat betekent dat gegevens kunnen worden toegevoegd zonder een bepaalde structuur te volgen. Deze flexibiliteit maakt MongoDB ideaal voor het opslaan van grote hoeveelheden gegevens, maar maakt het beheren van gegevens ook moeilijker.
Mongoose biedt een op schema gebaseerde oplossing die ervoor zorgt dat gegevens die zijn opgeslagen in MongoDB consistent en correct zijn opgemaakt. Met Mongoose kunt u een schema voor uw gegevensmodellen definiëren, dat de structuur van de gegevens specificeert en de regels voor hoe die gegevens moeten worden opgemaakt. Hier leert u hoe u Mongoose gebruikt in een Express-toepassing.
Uw ontwikkelomgeving opzetten
Voordat u Mongoose gebruikt, moet u het als een afhankelijkheid in uw project installeren.
U kunt Mongoose installeren door de onderstaande opdracht uit te voeren:
npm installeer mangoest
Nadat u Mongoose in uw project hebt geïnstalleerd, moet u uw toepassing verbinden met MongoDB met behulp van Mongoose.
Mongoose maakt verbinding met een MongoDB-database met behulp van de aansluiten methode, die een MongoDB URI als argument gebruikt.
Hier is een voorbeeld:
// index.js
const mangoest = vereisen("mangoest")mangoest.connect("mongodb://127.0.0.1:27017/voorbeeld", () =>
troosten.log("Verbonden met database succesvol")
);
Het bovenstaande codeblok maakt verbinding met een lokale MongoDB-instantie en registreert een succesbericht wanneer uw toepassing met succes verbinding maakt met MongoDB.
Een mangoestmodel maken
Een Mongoose-model is een op een schema gebaseerde klasse in Mongoose waarmee u kunt communiceren met een MongoDB-verzameling.
Een Mongoose-schema definieert de structuur van de documenten die u in een MongoDB-verzameling kunt opslaan en biedt daarin een interface voor het maken, lezen, bijwerken en verwijderen van documenten verzameling.
Wanneer u een Mongoose-model definieert, definieert u het schema voor de documenten in die verzameling, inclusief de eigenschappen, hun typen en eventuele validaties.
Hier is een voorbeeld van een Mongoose-model voor een Gebruiker verzameling:
const mangoest = vereisen("mangoest");const userSchema = mangoest. Schema({
naam: {
type: Snaar,
vereist: [WAAR, "Naam is vereist"],
},
e-mail: {
type: Snaar,
vereist: WAAR,
},
leeftijd: {
type: Nummer,
valideren: {
validator: functie (waarde) {
opbrengst waarde > 0;
},
bericht: () =>"Voer een geldige leeftijd in",
},
},
});const Gebruiker = mangoest.model("Gebruiker", gebruikersSchema);
moduul.exports = Gebruiker;
Het bovenstaande codeblok definieert een Mongoose-schema met drie eigenschappen: naam, e-mailen, En leeftijd. Elke eigenschap heeft een gedefinieerde set regels die u moet volgen bij het toewijzen van een waarde aan het opgegeven veld. Hier is een overzicht van de regels:
- naam: De naam eigendom is een snaar typ gemarkeerd als vereist, wat betekent dat u een tekenreeks aan dit veld moet toewijzen. Als u het veld leeg laat of een ander invoert JavaScript-gegevenstype, gooit Mongoose een fout.
- e-mailen: De e-mailen eigendom is een snaar typ gemarkeerd als vereist. Het heeft geen andere validatieregels, maar in de praktijk moet u valideren of de e-mail correct is. U kunt de e-mail valideren regex-expressies gebruiken of bibliotheken van derden, zoals class-validator.
- leeftijd: De leeftijd eigendom is een nummer typ met een aangepaste validatieregel die controleert of de aan het veld toegewezen waarde groter is dan nul. Als de waarde de validatie niet doorstaat, geeft Mongoose een foutmelding met het bericht Voer een geldige leeftijd in. U kunt dit veld leeg laten omdat het niet is gemarkeerd als vereist.
Nadat het schema is gedefinieerd, maakt het codeblok een Mongoose-model met de naam Gebruiker gebruik makend van mangoest.model() methode. Deze methode heeft twee argumenten nodig: de naam van het model en het schema dat voor de documenten moet worden gebruikt.
eindelijk, de Gebruiker model wordt geëxporteerd naar andere delen van uw toepassing.
Interactie met MongoDB met behulp van Mongoose
Met uw applicatie verbonden met een MongoDB-database en uw model gemaakt en toegankelijk voor andere delen van uw applicatie, kunt u communiceren met uw database met behulp van methoden die door Mongoose worden geleverd.
Voor deze tutorial ga je optreden CRUD-bewerkingen op een MongoDB-database.
Opmerking: Zorg ervoor dat u uw Mongoose-model importeert in een module waar u de CRUD-bewerkingen gaat uitvoeren.
Bijvoorbeeld:
// router.js
const Gebruiker = vereisen("./gebruikerModel")
Een document maken
Een document is een instantie van een model. Er zijn verschillende manieren waarop u met Mongoose een document kunt maken en opslaan in MongoDB.
Eerst kunt u een instantie van de klasse van uw model maken en vervolgens de redden methode erop.
Bijvoorbeeld:
//Een nieuwe gebruiker aanmaken
laten gebruiker = nieuw Gebruiker({
naam,
e-mailen,
leeftijd,
});
//Gebruiker opslaan in database
gebruiker
.redden()
.Dan(() => {
troosten.log("Gebruiker succesvol aangemaakt");
})
.vangst((fout) => {
// omgaan met fout
});
Het bovenstaande codeblok maakt en bewaart een nieuw Gebruiker document toe aan uw MongoDB-database.
U kunt ook gegevens in uw database opslaan met behulp van de creëren methode. De creëren methode instantiseert uw model en roept de redden methode erop. Met andere woorden, het combineert de twee bewerkingen van de eerder genoemde techniek.
Bijvoorbeeld:
User.create({ naam, e-mail, leeftijd }, (err, data) => {
als (fout) gooiennieuwFout("Interne Server Fout");
troosten.log(`Gebruiker succesvol aangemaakt: ${gegevens}`);
});
Het bovenstaande codeblok maakt een nieuw Gebruiker document met de eigenschappen doorgegeven als een argument aan de creëren methode.
U kunt ook gegevens in uw database opslaan met behulp van de insertMany methode. Hoewel deze methode alleen ideaal is om gegevens in batches op te slaan.
Bijvoorbeeld:
Gebruiker.insertMany(
[
{ naam, e-mail, leeftijd },
{ naam_1, e-mail_1, leeftijd_1 },
],
(fout, resultaat) => {
als (fout) {
// omgaan met fout
} anders {
// Resultaten verzenden
}
}
);
Het bovenstaande codeblok maakt twee nieuwe documenten in het Gebruiker verzameling met behulp van de array die als argument is doorgegeven aan de insertMany methode.
Een document lezen
U hebt toegang tot alle opgeslagen documenten in uw MongoDB-database met behulp van Mongoose's vinden methode.
Bijvoorbeeld:
Gebruiker.vind({})
.Dan((gegevens) => {
troosten.log (gegevens);
})
.vangst((fout) => {
// omgaan met fout
});
Het bovenstaande codeblok retourneert alle documenten in het Gebruiker verzameling.
U kunt ook alle documenten vinden die overeenkomen met een bepaalde zoekopdracht door een zoekopdracht door te geven aan de zoekmethode.
Bijvoorbeeld:
// vind alle documenten waar de leeftijd minstens 18 jaar is
Gebruiker.vind({ leeftijd: { $gte: 18 } })
.Dan((gegevens) =>troosten.log (gegevens))
.vangst((fout) =>troosten.log (fout));
Het bovenstaande codeblok retourneert alle documenten met een leeftijdswaarde groter dan 18 in de Gebruiker verzameling.
U kunt ook afzonderlijke records lezen met behulp van de vindById methode en het doorgeven van een document-ID als een argument of het gebruik van de vind een methode en een filter doorgeven als argument.
Bijvoorbeeld:
//findById
User.findById (id, (fout, resultaat) => {
als (resultaat) troosten.log (resultaat);
als (fout) troosten.fout (fout)
});
//findOne
Gebruiker.findOne({ e-mailen: "[email protected]" }).Dan((gebruiker) => {
als (!gebruiker) {
// omgaan met fout
}
//stuur antwoord
});
In het bovenstaande codeblok is de vindById methode retourneert het document met de overeenkomende ID. De vind een methode retourneert het eerste document met de e-mail [email protected].
Een document bijwerken
U kunt een document op MongoDB bijwerken met Mongoose met behulp van de findByIdAndUpdate methode. Deze methode heeft een ID en een object nodig met de bijgewerkte details.
Bijvoorbeeld:
User.findByIdAndUpdate (id, req.body, (err, doc) => {
als (document) {
//Stuur antwoord
}
als (fout) {
// omgaan met fout
}
});
Het codeblok hierboven werkt het document bij met een ID die overeenkomt met de verstrekte ID met het verstrekte update-object (verzoek.lichaam).
Een document verwijderen
U kunt een document op MongoDB verwijderen met Mongoose met behulp van de vindByIdAndDelete methode. Deze methode neemt een ID als argument en verwijdert het document met de overeenkomstige ID.
Bijvoorbeeld:
User.findByIdAndDelete (id, (fout, resultaat) => {
als (resultaat) {
// Behandel resultaat
}
als (fout) {
// Behandel fout
}
});
Het bovenstaande codeblok verwijdert een document met de opgegeven ID uit uw MongoDB-database.
Mongoose gebruiken in uw Express-toepassingen
Dit artikel gaf een overzicht van hoe u Mongoose zou kunnen gebruiken in uw uitdrukkelijke toepassing. Behandelen hoe u een verbinding met MongoDB tot stand kunt brengen, gegevens die in uw MongoDB-database zijn opgeslagen, kunt structureren en valideren, en eenvoudige CRUD-bewerkingen kunt uitvoeren.
Door Mongoose in uw Express-applicaties te gebruiken, kunt u de interacties tussen uw applicatie en een MongoDB-database vereenvoudigen en stroomlijnen.