Transcription
1. Introduction du cours: Bienvenue dans le module 8 de modélisation des relations
avec Mongoose Ce cours s'inscrit dans la continuité de la série de cours Express JS. Je m'appelle Shawn
Ragunhi et je serai votre guide alors que nous aborderons les techniques
avancées de conception de bases de données J'ai eu le
privilège de travailler sur plusieurs applications de production
no JS, et je suis ravi de partager
mes idées avec vous. Parmi mes meilleurs travaux,
citons la conception systèmes
évolutifs à hautes
performances qui reposent sur des bases de données bien
structurées. Aujourd'hui, vous
apprendrez à faire de même. Dans ce module, nous nous
concentrons sur la modélisation des relations
dans Mongoose, ce qui est essentiel
pour toute application
impliquant des données interconnectées Voici ce que vous
apprendrez à modéliser les relations en référençant
et en incorporant des documents, en
gérant des tableaux de sous-documents
et en utilisant des transactions MongoAV Vous
découvrirez également comment valider les identifiants d' objets afin de préserver l'
intégrité de votre base de Cette classe est parfaite pour les développeurs
backend qui ont
déjà une certaine expérience avec Express Js et Mongo DB Si vous avez terminé
les modules précédents, vous êtes bien préparé pour cela. Vous n'aurez pas besoin d'installer Js,
Express, Mongo DB et mangos, ainsi que d'une compréhension
de base des opérations de foule Comprendre comment modéliser les relations entre les
données est essentiel
pour créer des applications évolutives, maintenables et
efficaces À la fin de ce module, vous
saurez non seulement comment structurer relations
complexes
dans Mongadib, mais vous aurez également acquis une
expérience pratique dans la conception d'
API qui fonctionnent parfaitement
dans des scénarios du monde réel Dans ce module, nous
travaillerons sur deux projets. Tout d'abord, vous allez créer l'API de la voiture pour gérer les
voitures dans notre système, apprenant à intégrer et à référencer efficacement
des documents Vous allez ensuite développer
l'API de location, qui inclut la création
et la récupération des locations, validation des
identifiants d'objets et la gestion transactions pour garantir la fiabilité
des données Ces projets vous permettront une expérience pratique mise en œuvre de techniques
de base de données avancées. Ce module est donc
rempli de
leçons pratiques et de projets qui amélioreront vos compétences en matière de
développement du backend Commençons, et je vous verrai lors de
la première conférence.
2. Modélisation de relations de données avec une manguste: Dans tous les exemples que nous
avons examinés jusqu'à présent, nous avons travaillé avec des documents individuels
autonomes. Mais dans le
monde réel, les entités et les concepts avec lesquels nous travaillons
sont associés d'une manière ou
d'une autre. Par exemple, vous pouvez avoir un objet de cours ou
un document de cours. Et, bien sûr, ce
cours a un auteur, mais un auteur est bien
plus qu'un nom. C'est bien plus qu'
une simple chaîne. Nous pouvons avoir une collection d' auteurs dans laquelle nous stockons les documents
rédigés, et dans chaque document créé, nous pouvons avoir des
propriétés telles que le nom, site Web, l'image, etc. Dans cette conférence,
je vais donc
parler de la façon de travailler
avec des objets connexes. En gros, nous avons
deux approches. L'une utilise des références, que nous appelons normalisation, et l'autre approche
utilise des documents intégrés, que nous
appelons dénormalisation. Voyons donc comment ils fonctionnent. Avec la première approche,
nous devrions avoir une collection séparée
pour stocker nos auteurs. Nous pouvons donc avoir un
objet d'auteur comme celui-ci. Ici, nous avons toutes
sortes de propriétés, puis nous aurons une collection
séparée laquelle nous stockerons
des objets de cours comme celui-ci. Nous avons donc ici un objet de cours. Nous attribuons à l'auteur l'identifiant d' un document d'auteur dans
la collection de l'auteur. Nous utilisons ici une référence. Maintenant, je dois clarifier
quelque chose. Dans les bases de données relationnelles,
nous avons ce concept de relation qui
renforce l'intégrité des données Mais dans les
bases de données Mongo DV ou sans SEQL en général, nous n'avons Donc, même si je définis
l'identifiant d'un auteur ici, il n'y a en fait
aucune association ou relation entre ces deux
documents dans la base de données. En d'autres termes, je peux définir
un identifiant non valide, et Mongo DV s'en
fiche Maintenant, nous pouvons faire passer cet
exemple au niveau suivant. Supposons qu'un cours puisse
avoir plusieurs auteurs. Ainsi, au lieu de la propriété
author, nous pourrions avoir des auteurs, que nous définirions sur un
tableau de références. Nous allons donc stocker ici
plusieurs identifiants. Maintenant, par souci de simplicité, travaillons avec
un seul auteur. Je vais donc
supprimer cette partie. Il s'agit donc de notre première approche, qui consiste à utiliser des références. Il existe une autre approche. Ainsi, au lieu d'avoir une
collection séparée d'auteurs, nous pouvons intégrer un document d'auteur
dans un document de cours Nous pouvons donc avoir ici un
objet de cours ou un document de cours. Dans ce document, nous avons la propriété author et
nous l'avons définie sur un objet. Nous allons donc avoir ici toutes les
propriétés d'un auteur. Nous intégrons donc un document
dans un autre document. OK. C'est ce que
nous appelons la dénormalisation. Maintenant, si nous n'avons jamais travaillé
avec des bases de données Nose Equal auparavant et que vous venez d'un milieu de
base de données relationnelle, vous pensez peut-être que la
première approche est le Vu Mais ce n'est pas nécessairement le cas lorsque vous travaillez avec des bases de données
Nose Equal. Chaque approche a ses
forces et ses faiblesses. L'approche que vous choisissez dépend
réellement de votre application et de ses exigences en matière de
requêtes Donc, en gros, vous devez
faire un compromis entre les performances des requêtes
et la cohérence. Permettez-moi de vous expliquer ce que
je veux dire par là. Avec la première approche, nous disposons d'un seul endroit
pour définir un auteur. Si demain je décide de changer le nom de cet auteur
de hewn à hewn, il y a un seul endroit
que je dois modifier, et tous les cours qui
font référence auteur
verront immédiatement l'auteur Donc, avec la première approche,
nous avons de la cohérence. Cependant, chaque fois
que nous voulons interroger un cours, nous devons effectuer une requête supplémentaire
pour charger l'auteur correspondant. Maintenant, parfois, cette
requête supplémentaire peut ne pas être un gros problème. Mais dans certaines situations, vous devez vous assurer que vos requêtes s'exécutent le plus
rapidement possible. Si tel est le cas,
vous devez envisager
la deuxième approche utilisant des documents
intégrés. Ainsi, avec cette
approche, nous pouvons charger un objet de cours et son
auteur à l'aide d'une seule requête. Nous n'avons pas besoin de faire de requête
supplémentaire pour charger l'auteur, car celui-ci
se trouve dans
l' objet du cours ou dans
le document de cours. Cependant, avec cette approche, si demain je décide de
changer le nom de cet auteur de
hewn en Shevin, il y a de
fortes chances que
plusieurs documents de cours aient besoin d'être mis à Et si notre opération de mise à jour
échoue, il est possible que certains documents
de cours ne soient pas mis à jour. Nous allons donc nous retrouver avec des données
incohérentes. La première approche nous
donne donc de la cohérence. La deuxième approche nous
donne de la performance. C'est pourquoi je vous ai dit qu'
il fallait trouver un
compromis entre cohérence
et performance. Tu ne peux pas avoir
les deux en même temps. Ainsi, dans chaque partie de
votre application, vous devez
réfléchir à l'
avance aux requêtes que vous allez exécuter,
et vous allez concevoir votre
base de données en fonction de ces requêtes. Voici donc les principes
généraux. Nous avons maintenant une troisième approche. C'est ce que nous appelons l'approche
hybride. Par exemple, imaginez que chaque
auteur possède 50 propriétés. Nous ne voulons pas dupliquer toutes ces propriétés dans
chaque cours de notre base de données, afin de disposer d'une
collection d'auteurs distincte. Mais au lieu d'utiliser
une référence ici, nous pouvons intégrer un document d'auteur
dans un document de cours, mais pas la
représentation complète de cet auteur Peut-être voulons-nous uniquement
la propriété du nom. Ainsi, avec l'approche hybride, notre base de données
ressemblera à ceci. Nous avons donc une
collection d'auteurs. Dans cette collection, nous aurons des objets d'
auteur comme celui-ci. Nous avons le nom Chevan, et nous aurons ici
50 autres propriétés Nous aurons maintenant une
collection séparée de cours. Dans cette collection, nous
aurons des documents de cours comme celui-ci. Donc, auteur, nous l'avons défini
comme document, et dans ce document, nous
n'aurons que deux propriétés. L'un d'eux est ID. Il s'agit d'une référence à
un document de l'auteur. Nous avons également des ongles. Cette approche
nous permet de
lire rapidement un objet de cours en
même temps
que son auteur, afin d'optimiser les performances de nos
requêtes, sans avoir à stocker toutes les propriétés d' un auteur dans un document de
cours. Cette approche est désormais
particulièrement utile si vous souhaitez avoir un instantané de vos données à un moment donné. Par exemple, imaginez que vous concevez une application de
commerce électronique. Nous y aurons des
collections telles que des commandes, des produits,
des paniers d'achat, etc. Dans chaque commande, nous
devons enregistrer un instantané d' un produit car
nous voulons connaître le prix de ce produit
à un moment donné. C'est donc là que nous
utiliserons l'approche hybride. Encore une fois,
l'approche que vous choisissez dépend vraiment de l'application
que vous créez. Il n'y a ni bien ni mal. Chaque approche a
ses forces et ses faiblesses. Au cours des prochaines conférences, je vais vous montrer comment mettre en œuvre chacune de
ces approches.
3. Documents de référence dans Mongoose: Dans cette conférence, je
vais vous montrer comment référencer un document
dans un autre document. Si tu veux
me suivre, télécharge ce fichier. J'ai joint une pièce jointe à cette conférence. Dans ce fichier, renseignez les
Js. Nous avons deux modèles. Le premier est l'auteur
avec trois propriétés
: nom, biographie et site Web. L'autre modèle est celui des couleurs
avec un seul nom de propriété. Dans cette conférence, nous allons
ajouter un autre auteur de propriété, et nous y référencerons un document d'auteur
dans notre base de données. Nous avons également quelques fonctions
d'assistance. L'une est de créer un auteur. L'autre est de créer un cours, et le dernier
est de répertorier les cours. Toutes ces fonctions
sont similaires à ce que nous avons vu
plus haut dans cette section. Il n'y a donc rien de nouveau ici. Maintenant, avant de commencer, je veux que vous vous rendiez sur
Mongo DB Compass et que vous supprimiez la base de données du
terrain de jeu Nous voulons partir
d'une toile propre. Tapez donc playground ici
pour supprimer cette base de données. OK, maintenant au bas de
ce fichier, vous pouvez voir nous avons un appel pour
créer une fonction d'auteur, créer un auteur appelé
Chewn avec ces propriétés Ouvrez donc le terminal
et lancez node, opulate JS. Nous avons donc créé un auteur, et voici l'idée
de cet auteur. OK, maintenant
recopiez-le dans le code. Validons cette ligne, créons l'auteur et
activons la création de cours. Nous voulons donc
créer ici un cours appelé node course
pour ce nouvel auteur. Vous transmettez donc l'
identifiant de l'auteur sous forme de chaîne. Maintenant, si vous regardez l'
implémentation de cette fonction, nous créons
ici un objet de
cours avec deux propriétés, nom et auteur. Maintenant, enregistrez le fichier.
De retour dans le terminal. Exécutons ce programme
une fois de plus. Nous avons donc créé cet objet de
cours. Voici l'idée du cours, le nom du cours, mais
nous n'avons pas l'auteur. Cela s'explique par le fait que nous avons défini ce modèle de cours, nous avons uniquement ajouté la propriété name. Ainsi, lors de l'enregistrement d'un objet de cours, seules les propriétés que
vous avez définies dans votre modèle seront
conservées dans la base de données Nous devons donc ajouter ici
une autre propriété, l'auteur. Nous l'avons dit à un objet de type
schéma. Le type de cette propriété
doit être l'identifiant de l'objet. Nous utilisons donc le schéma Mongoose, les
dottypes, l'identifiant de l'objet. De plus, nous définissons une propriété appelée ref et nous ajoutons ici le nom de la collection cible.
Ainsi, dans cette propriété d'auteur, nous stockerons un identifiant d'objet qui fait référence à un document d'
auteur. Mais encore une fois, nous n'avons pas vraiment de vraie
relation. Ici, nous pouvons stocker un cours
dont l'auteur n'est pas valide, et MongoDB ne s'en
plaint pas Nous avons donc modifié notre modèle dans
le nœud terminal, OpulateJS. Voici donc
notre nouvel objet de cours Vous pouvez voir que
la propriété d'auteur maintenant de retour dans MongoDB Campus Regardons cette base de données
de terrains de jeu. Voici notre collection de cours. Vous pouvez donc voir que nous
avons deux documents. Le premier n'a
pas d'auteur, mais le second en a un. Nous avons donc ici un identifiant d'objet qui fait
référence à un auteur
4. Maîtriser la population chez les mangoustes: Il est maintenant temps de réunir tous les cours
avec leurs auteurs. Désactivons donc,
créons une fonction de cours et activons cette
fonction pour répertorier les cours. Donc, dans cette fonction, nous
appelons la méthode find. Nous recevons tous les cours, et nous ne sélectionnons que
leur propriété de nom. Disons les modifications, Bag dans le
nœud terminal, OpulateTJS Écoutez, nous n'avons que l'identifiant et le nom
soulignés. Maintenant, si j'ajoute un auteur et que je lance ce programme
une fois de plus, regardez, notre deuxième document
a un auteur, mais nous n'obtenons que la
référence ou l'identifiant de l'objet. Dans une application du monde réel, nous voulons charger ce document d'
auteur afin de pouvoir afficher son nom. C'est là que nous utilisons
la méthode populate. Voici donc une amende, nous pouvons appeler populate
comme premier argument, nous spécifierons le chemin auquel la propriété a
été attribuée Donc, dans ce cas, notre
propriété est l'auteur. Et parce que plus tôt,
lors
de la définition du modèle de cours,
jetons un coup d'œil ici. Voici donc notre modèle de cours. Lors de cette définition, nous définissons
l'auteur comme un identifiant d'objet et nous référençons la collection d'
auteurs. Ainsi, lorsque nous chargeons un objet de cours et que nous renseignons la propriété de
l'auteur, Mongoose sait qu'
il doit interroger la collection de l'auteur
dans Mongo DB Pour revenir à la fonction des cours de liste, il suffit d'appeler populate et pass author est le nom
de la propriété cible Voyons maintenant ce qui se passe. Donc, de retour dans le terminal,
relançons ça une fois de plus. OK, écoutez, notre premier document, notre premier cours n'ont pas d'auteur, donc nous
n'obtenons rien. Mais notre deuxième document, notre deuxième cours, a un auteur, et nous avons ici une représentation complète
d'un document d'auteur. Désormais, dans une application du monde réel, un auteur peut avoir
plusieurs propriétés. Peut-être que lorsque nous affichons
la liste des cours, nous ne voulons pas obtenir toutes
ces propriétés supplémentaires. Nous voulons juste obtenir
la propriété du nom. De retour au tableau, lorsque vous
appelez la méthode populate, en tant que deuxième argument,
vous pouvez spécifier les propriétés que vous
souhaitez inclure ou exclure Nous voulons donc inclure uniquement le nom. Maintenant, de retour dans le terminal, exécutons cette application
une fois de plus. Donc, cette fois, notre propriété d'
auteur est un objet avec seulement deux
propriétés ID et nom. Nous pouvons désormais également exclure
cette propriété d'identifiant de soulignement. De retour ici, nous ajoutons un tiret
pour exclure la propriété, et le nom de la
propriété cible est souligné ID. Disons, de retour dans le terminal, relançons ça une fois de plus. Et maintenant, notre propriété d'auteur est un objet avec une
seule propriété. Nom. Il est également possible de
renseigner plusieurs propriétés Imaginons par exemple que chaque cours possède une catégorie et qu'une catégorie fasse
référence à un document de catégorie. Nous pouvons donc appeler à nouveau
remplir par catégorie, et souvent sélectionner uniquement
la propriété de nom de chaque document
de Maintenant, permettez-moi de
vous montrer une dernière chose avant de terminer cette conférence. heure, je vous ai dit
que dans Mongo DB, nous n'avons pas de relations relatives à l'intégrité des données dans notre base de données Ici, dans notre collection de
cours,
il est donc possible de définir cet
auteur avec un document non valide. Changeons donc ces deux points
au lieu de deux C un, C. Nous n'avons pas d'auteur
avec cet identifiant dans cette base de données. Vous voyez, MongoDB
convient parfaitement à cette opération. Maintenant, de retour dans le terminal, relançons ce programme
une fois de plus. Vous voyez maintenant que notre auteur est nul car il n'y a aucun auteur avec un identifiant donné dans notre base de données.
5. Intégrer des documents avec des mangoustes: Au cours de la dernière conférence, vous avez appris à utiliser les
références pour relier des documents. Dans cette conférence, nous
allons examiner
une autre technique qui
consiste à intégrer des documents Donc, si vous voulez
citer avec moi, téléchargez ce fichier, que
j'ai joint à cette conférence, en utilisant point js Nous avons donc ici
ce schéma d'auteur exactement comme celui que nous avions
lors de la dernière conférence. Il a trois propriétés
: nom, biographie et site Web. Nous avons ce modèle d'auteur. En dessous, nous avons
le modèle de cours. Ici, nous n'avons pas
la propriété de l'auteur, et c'est ce que nous allons
ajouter dans cette conférence. Nous ajoutons donc la propriété de l'auteur. Dans la dernière conférence, nous avons attribué à l'auteur une idée d'objet. Jetons donc un coup d'œil. Voici notre modèle de cours
tiré de la dernière conférence. Regardez, voici la propriété de l'
auteur. Nous définissons le type de
cette propriété sur
un ID d' objet et référençons
la collection de l'auteur. Dans cette conférence,
nous allons intégrer un document d'auteur directement
dans un document de cours Nous avons donc défini le type de cette
propriété sur Author Schema. Cela est défini ici. OK, c'est le seul
changement que nous devons apporter. Examinons maintenant la fonction
de création de cours. Il faut un
nom de cours et un auteur, initialiser le cours et l'
enregistrer exactement comme avant Au bas de ce fichier,
nous avons donc un appel à
cette fonction pour créer un nouveau cours
avec cet auteur. Avant d'aller plus loin, ouvrons Mongoi B Compass
et supprimons cette base de données Nous voulons partir d'un canevas
propre afin de nous
assurer que nous sommes sur la
même longueur d'onde. C'est bon. Magnifique. Maintenant, dans le terminal, lançons node embedding dot js Voici donc notre nouveau document de
cours. Vous pouvez voir que l'auteur est un objet avec deux propriétés,
ID et nom. Il s'agit donc d'un document intégré
ou d'un sous-document. Ces sous-documents sont
similaires à des documents normaux. Ainsi, la plupart des
fonctionnalités disponibles sur les documents
normaux sont également
disponibles dans les sous-documents Par exemple, nous pouvons
implémenter la validation ici. Nous pouvons faire respecter cela.
Le nom de l'auteur peut être requis. Cependant, ces sous-documents ne peuvent pas être enregistrés seuls. Ils ne peuvent être enregistrés que dans
le contexte de leur parent. Supposons donc que je veuille changer
le nom de cet auteur. Voici l'identifiant du cours. Copions-le. Ici, je vais créer un nouveau fun ****. Auteur de LauncTudate Demandez à
BRSDGes d'Ecodblog. Ici, nous devons d'abord trouver
un cours avec un identifiant donné. Nous appelons donc cours point Fine BID, transmettons cet identifiant de cours. Maintenant, attendez le résultat et
suivez ce cours abject. D'accord ? Nous modifions maintenant l'auteur. Supposons que point soit l'auteur du nom, nous l'avons dit à Yvan Rebounci Maintenant, nous pouvons appeler force point C. Nous n'avons donc pas le point d'enregistrement de l'auteur du
cours. Cela n'existe pas. D'accord ? Allons-y donc
et exécutons cette fonction. Mettez à jour l'auteur, et
voici le numéro de mon porte-monnaie. Maintenant, de retour dans le terminal, lançons node embedding dot js Notre document est mis à jour. Jetons donc un coup d'œil à Compass. Rafraîchissez ceci est notre collection de
cours de terrain de jeu. Voici notre document de cours, autre objet, et vous pouvez voir les
propriétés du nom mises à jour. Nous pouvons également mettre à jour un
sous-document directement. Ainsi, au lieu de l'interroger d'abord, nous pouvons le mettre à jour directement
dans la base de données Alors voilà, je vais
modifier ce code et le remplacer fine by ID par une mise
à jour. Ici, comme premier argument, nous passons un objet de requête. Nous recherchons un
cours avec cet identifiant, l'identifiant de
force, et le deuxième
argument est notre objet de mise à jour. Nous utilisons donc ici un opérateur défini
que vous avez déjà vu. Nous lui attribuons un objet, et nous passons ici une
ou plusieurs paires de valeurs E. Donc, ici, pour accéder à
la propriété imbriquée, nous utilisons la notation de pensée Supposons que nous souhaitions mettre à jour le nom de l'
auteur d'un cours. Nous transmettons donc le nom à point de l'auteur. Nous l'avons attribué à
Peter Parker. OK. Ainsi, nous n'avons pas besoin
de modifier cet objet en mémoire et de l'enregistrer explicitement. Nous le mettons à jour directement
dans la base de données. Avant de lancer ce module, je me rends compte que j'ai
fait une erreur ici. Il devrait s'agir de la première mise à
jour. C'est bon. Refaisons-le. OK, allons vérifier Compass, actualisons-le ici. Voici donc l'objet de notre auteur. Et regardez, le nom est
devenu Io Parker. Si vous souhaitez
supprimer un sous-document, vous devez utiliser l'opérateur Sunset Laissez-moi vous montrer comment cela fonctionne. Nous utilisons l'opérateur unset. Nous pouvons maintenant utiliser un nom de point d'
auteur non défini pour supprimer cette propriété imbriquée. Nous pouvons également supprimer ce
sous-document dans son ensemble. Nous devons définir cela
sur une chaîne vide. D'accord ? Maintenant, exécutons-le à nouveau. Donc, les nœuds incorporant
les chiens englobent, rafraîchissent et regardent, nous n'
avons plus la propriété d'auteur Maintenant, comme je vous l'ai déjà dit, ces sous-documents sont
similaires aux documents normaux. Ici, nous pouvons donc
appliquer la validation. Nous pouvons faire respecter cela. Chaque
cours doit avoir un auteur. Mais voici la définition
de notre schéma de cours. Si vous souhaitez rendre cette propriété d'
auteur obligatoire, nous devons
ici transmettre
un objet de type schéma. Nous avons donc défini le type sur
Author Schema, puis nous lui avons demandé qu'il soit vrai exactement comme nous l'avons appris plus haut dans cette section. Ou si vous souhaitez rendre obligatoire
une propriété spécifique dans ce document d'auteur, vous devez appliquer cette validation au sous-document de l'
auteur lui-même Ici, vous transmettez un objet de type schéma et définissez la
propriété requise sur true. Dans la prochaine conférence,
je vais
vous montrer comment travailler avec un
ensemble de sous-documents.
6. Matières de sous-documents dans Mangouste: Ainsi, lors de la dernière conférence, nous avons ajouté l'auteur en
tant que sous-document dans
ce document de cours. Dans cette conférence, je
vais vous montrer
comment transformer cela en un
ensemble de sous-documents. Nous renommons donc d'abord cette
propriété en authors puis changeons sa valeur en
un schéma de tableau d'auteurs OK. Maintenant, lors de
la création d'un cours, nous voulons également transmettre
un tableau d'auteurs. Je vais donc renommer
ce paramètre en auteurs. OK. Enfin, c'est ici que nous
créons un cours. Ainsi, au lieu de transmettre un objet auteur,
nous passons un tableau. Voici le premier auteur, et voici le second. Disons mangeurs. Maintenant, revenons à Compass, je vais supprimer
cette collection, afin que nous puissions voir toutes les nouvelles données
sans aucune confusion, d'accord ? Revenons maintenant dans le
nœud terminal incorporant le point Gs. OK, voici notre nouveau document de
cours. Vous pouvez voir que les auteurs sont définis sur
un tableau de deux objets. Voici le premier auteur et
voici le second auteur. Et si vous regardez dans Compass,
actualisons-le ici. Voici la collection du cours. Voici notre document croisé avec de nombreux auteurs. Magnifique. Chaque auteur est un objet. Lorsque vous le développez, vous voyez
deux propriétés : l'ID et le nom. Magnifique. Maintenant, nous pouvons toujours ajouter un auteur à ce tableau
ultérieurement. Laisse-moi te montrer. Donc, revenons au code,
créons une nouvelle fonction, ajoutez
constamment author Async Nous transmettons donc
ici un identifiant de cours et un objet d'auteur. Maintenant, nous devons d'abord
trouver une pose. Force donc constante. Nous l'avons configuré pour attendre l'identifiant
ForstFineBy. Et nous rejetons ici cet argument relatif à
l'identifiant du cours . Nous avons le cours. Maintenant, les auteurs de force, comme
vous le savez, sont un tableau. Nous pouvons donc appeler la méthode
push pour placer cet
objet auteur dans ce tableau. Mais nos changements
ne sont que mémorisés. Ils ne sont pas enregistrés
dans la base de données, nous devons
donc appeler force.ca. Maintenant, permettez-moi de les supprimer
et d'appeler add author Ici, nous devons
transmettre l'identifiant du cours. Je vais donc y retourner englober et copier
cet identifiant de cours Alors collez-le ici, puis transmettez un nouvel objet d'auteur avec
le nom, disons, flash. De retour dans le terminal,
exécutons-le à nouveau. OK, nos modifications sont
enregistrées dans la base de données. Vérifions-les donc. Je vais me rafraîchir
ici. Voici les auteurs. Regardez, nous avons trois
objets dans ce tableau. Et voici notre nouvel auteur. Supprimer un auteur
est très similaire. Donc, revenons au code, ajoutons une nouvelle fonction, en supprimant
constamment l'auteur. Async ici, nous avons besoin de
deux paramètres, porte-monnaie et l'identifiant de l'auteur Donc, d'abord, nous chargeons le
cours comme avant. Passons maintenant aux auteurs de cours point. Ici, nous avons une méthode appelée ID, qui nous permet de
rechercher un objet enfant par son identifiant. Vous transmettez donc cet identifiant d'auteur qui nous donne l'objet auteur. Nous pouvons maintenant appeler la méthode Delete
one sur cet objet. Enfin, sauvegardez le cours. OK, alors appelons cette nouvelle
fonction, supprimons l'auteur. Permettez-moi de dupliquer cette ligne, supprimer le deuxième argument et de changer le nom
pour supprimer l'auteur. Nous avons maintenant besoin d'un identifiant d'auteur. Bref,
voici l'idée du flash. Je vais donc le coller ici. OK, allons-y. Nœud, intégration du point js. Magnifique. Jetons
un coup d'œil à nos données. Je vais donc
actualiser cette page. Auteurs, écoutez, nous
n'avons que deux auteurs maintenant. Flash a disparu. C'est ainsi que
nous travaillons avec les sous-documents.
7. Configurer MongoDB pour les transactions: Bon retour. Dans cette vidéo, nous configurons les ensembles
MangaibrPlica, essentiels pour exécuter
des
transactions Cette configuration garantit que Mangaib
est en mode réplicas, ce qui vous permet de travailler avec des transactions contenant
plusieurs documents Dans la prochaine conférence,
nous aborderons la réalisation de transactions à
l'aide de Mongoose Jetons donc les
bases aujourd'hui. Nous allons donc passer en revue deux options. Le premier est une réplique à nœud
unique installée sur le serveur Mangaib local Maintenant, cette approche est idéale
pour les tests et le développement. Et deuxièmement, les
ensembles de répliques avec l'atlas Mangaib
, idéal pour la production
car il est basé sur le cloud
et entièrement géré Commençons par
la configuration locale. Nous allons donc configurer Monger
I B pour qu'il s'exécute en mode Replica Set sur votre
machine locale avec un seul nœud Cette configuration nous permet de développer et de tester
des transactions localement. Nous devons donc configurer le mode Manga
IB ou Replica set, et pour cela, nous devons modifier la configuration de
Mongo DB Localisez le fichier de configuration. Par défaut, ce
fichier se trouve dans fichiers
du programme de voyage, sur le serveur de base de données
Mongo Ensuite, le dossier Virgin,
qui est 8.0 dans mon cas, puis le dossier bin, et ici c'est mongod point conf Ouvrez maintenant mongod point cfg avec un éditeur de texte
tel que le bloc-notes ou code
Visual Studio et localisez ou ajoutez une
section de réplication Ici c'est la réplication
RUPL de ce nom. Nous l'avons réglé sur RS
Zero. Et économisez. Un message d'erreur peut s'afficher car vous n'êtes pas en mode
administrateur. Voici donc une invite. Essayez simplement en tant qu'administrateur
et notre fichier sera enregistré. Vous pouvez utiliser n'importe quel nom
pour le jeu de répliques, mais R zéro est un choix courant. Nous allons maintenant redémarrer Mongo DB avec la configuration
mise à jour Ouvrez donc Power Shell en tant qu'
administrateur et exécutez lap service, ah, A Mongo DB.
Nous allons maintenant le redémarrer. Alors lancez le service, H A Mongo DB. Mongo I B étant désormais
en mode Replica Set, nous allons l'initialiser Pour cela, nous devons
installer le shell de base de données Mongo. Ainsi, Mongo B 6.0 et
les versions ultérieures fournissent Mongo Asch
sous forme de package distinct Il n'est plus fourni avec
l'installation du serveur
Mongo ib Si vous l'avez
déjà installé, c'est bien. Sinon, rendez-vous sur la page de téléchargement de Mongo
Debe Shell. Sélectionnez votre système d'exploitation pour télécharger la dernière version. Je préférerais l'installateur MS pour une installation plus propre. Bien que ce soit à vous de choisir, vous pouvez également choisir ZIP. Ouvrez le MSI et installez-le. Cliquez sur Suivant et notez que vous devez copier
le chemin d'installation. Alors copiez-le ensuite et installez-le. Une fois installé, ajoutez le
répertoire MongoSH au chemin du système. Ouvrons donc les variables d'
environnement. Vous devez rechercher les variables d'
environnement du système. Cliquez ici sur les variables d'
environnement. Dans la section des variables système, comme chemin, puis cliquez sur Modifier. Ajoutez le chemin que vous avez copié et cliquez sur OK
pour enregistrer les modifications. Donc encore une fois.
OK. OK. Génial. Nous allons maintenant redémarrer
PowerShell pour appliquer les modifications. Après avoir ajouté Mongo
SH au chemin, accédez au PowerShell
et exécutez Mongo Par défaut, Mongo SH se connecte
au port hôte local 27017. Si votre serveur Mongo DV
fonctionne localement sur
le port par défaut, il se connectera automatiquement Maintenant, initialisez
le jeu de répliques en saisissant le point Rs, lancez Ce
message d'erreur s'affiche parce que j'ai déjà lancé un jeu de répliques.
Vous pouvez donc l'ignorer. Vous recevrez le bon message. Enfin, nous vérifierons l'état et nous assurerons que le jeu de
répliques fonctionne. Donc le statut du point Rs. Magnifique. Tout
est correctement configuré, et MongoDB fonctionnera désormais en mode réplica set, et nous sommes prêts
à commencer à travailler avec des transactions localement Mais ce n'est pas le cas. Pour les environnements de production,
MongoDB Atlas est un excellent choix car il configure
automatiquement des ensembles de répliques à
nœuds multiples, ce qui signifie que le support des transactions est prêt à fonctionner dès la
sortie de la boîte Alors, tout d'abord, rendez-vous sur le site Web de MongoDB
Atlas Si vous n'avez
pas encore de compte, inscrivez-vous, c'est rapide et gratuit. Si vous en avez déjà
un, il vous suffit de vous connecter. Une fois connecté, cliquez sur
Nouveau projet dans le tableau de bord de l'
Atlas. Nommez maintenant le projet. Je vais choisir
Fair Wheels pour fair Wheels
, puis cliquer sur Suivant. Ici, créez le projet. Notre projet est donc créé. Nous devons créer un cluster. Cliquez donc sur Créer, puis ici, si vous testez des choses, le niveau zéro gratuit est parfait. Mais pour la production,
vous devez choisir un niveau supérieur pour plus de
puissance et de fonctionnalités. Une fois cela fait,
nommez votre cluster. La valeur par défaut est donc le cluster zéro, mais je vais
choisir une paire de roues. À présent, choisissez un fournisseur de cloud, AWS, Azure ou Google Cloud, et sélectionnez la région la
plus proche d'un utilisateur. Cela permet de réduire la latence
et d'améliorer les performances. Je vais choisir
AWS et la région comme Mumbai, puis
créer un déploiement. Et c'est ici que notre cluster est créé. Nous devons donc créer
un nom d'utilisateur et un mot de passe, que nous allons utiliser
dans notre chaîne de connexion pour assurer que vous copiez le
mot de passe et le nom d'utilisateur. Et puis créez un utilisateur de base de données. Ensuite, vous devez choisir
une méthode de connexion. Alors, choisissez ici les pilotes. Assurez-vous que le chauffeur est à proximité de Js. La version est 6.7 ou ultérieure. Et comme vous pouvez le constater, Fair
Wheels s'occupe de l'approvisionnement. Notre base de données est donc provisionnement et cela
prendra un certain temps. En attendant,
sécurisons notre chaîne de connexion. Accédez à Network Access et
ajoutez votre adresse IP. Cela permet à votre application de
se connecter au cluster. Si vous utilisez une adresse IP dynamique,
vous pouvez ajouter une large plage ou
autoriser l'accès depuis n'importe où,
mais soyez prudent lors vous pouvez ajouter une large plage ou
autoriser l'accès depuis n'importe où, mais soyez prudent la production. Non, c'est ça. Je reviens aux clusters. Cela prendra quelques minutes. Je vais
avancer rapidement, et voilà. Cliquez donc sur Connecter,
puis à nouveau,
pilotes, assurez-vous que Near Jasn
617 ou version ultérieure est sélectionné Et voici notre chaîne
de connexion. Cela
ressemblera à ceci. Manga V plus SRE Colen SlalSh et le nom d'utilisateur
et le mot de passe Ce n'est donc pas votre mot de passe. Vous devez vous
assurer de remplacer DVPassword par un mot de passe
pour votre nom d'utilisateur Copiez cette chaîne et remplacez la chaîne de connexion notre application par celle-ci. Assurez-vous donc de donner à
la base de données le nom du
filet à fléchettes, slash fair wheels Cela garantira que
votre base de données est connectée, ou s'il n'existe aucune base
de données nommée fair wheels,
elle sera créée. Assurez-vous également de
remplacer le mot de passe de base de données par un mot de passe que vous avez
copié et que vous avez généré de manière aléatoire,
et c'est tout. Avec l'atlas Mongerib, les
ensembles de répliques sont activés par défaut. Un cluster est donc prêt
à gérer les transactions sans aucune étape supplémentaire.
C'est aussi simple que cela. Dans la prochaine conférence,
nous nous appuierons sur cette configuration en nous plongeant dans
les transactions utilisant Mongoose
8. Effectuer des transactions en utilisant des mangues: Dans Mon Vov, nous avons le
concept de transactions, qui signifie essentiellement un groupe d' opérations qui doivent
être effectuées en tant qu'unité Ainsi, soit toutes
ces opérations se termineront,
soit modifieront
l'état de la base de données, soit si quelque chose
échoue au milieu toutes ces opérations appliquées
seront annulées,
et nos données
reviendront à leur appliquées
seront annulées, état initial. Les transactions MovaDB
dépassent vraiment le cadre de ce cours Mais si vous voulez
en savoir plus,
laissez-moi vous montrer la bonne
page de la documentation. Recherchez donc les transactions Mongo
DB. D'accord, voici donc le manuel des transactions
Mongo DB. Ce document
explique clairement comment effectuer des transactions
distribuées à
l'aide d'un exemple concret. Maintenant, dans cette conférence,
je vais vous
montrer les transactions
utilisant Mongoose Mais en interne, il implémente cette transaction en utilisant
les transactions Mongoiw Maintenant, revenons au code ici dans
Rentals, point js en haut, nous devons d'
abord charger Mongoose C'est une mangouste si constante. Nous l'avons configuré pour exiger Mongoose. Maintenant, il dispose d'une méthode de démarrage de
session que nous devons appeler ici. Attendez donc le démarrage de la session par
points de Monaco et stockez-la dans la session Séance de So Pons. Dans notre méthode de publication, c'est ici que nous créons
un objet de location. Maintenant, nous n'
allons plus créer cette location et
mettre à jour l'explicite. Au lieu de cela, nous allons
commencer une transaction. Ici, nous initions une
transaction en appelant session point start transaction. Toutes les requêtes mangos liées
à la transaction interrompent une option de session pour
les associer à la transaction Nous avons donc deux
opérations mongoles ici. Location de points d'économie et CV de voiture. Vous souhaitez donc enregistrer
cette nouvelle location dans
la collection de locations. Vous appelez donc enregistrer et
passez la session. OK, c'est donc notre
première opération, sauver la nouvelle location. Maintenant, dans le cadre de cette unité, nous voulons également mettre à jour
la collection de la voiture. Nous passons donc la session ici et
réduisons également cette opération. Il s'agit donc de deux opérations. Après avoir enchaîné toutes ces
opérations,
vous devez enfin appeler await
session point Comtransaction Et session point par session. Si vous ne codez pas la transaction de
validation, aucune de ces opérations ne
sera effectuée. C'est bon. Il est maintenant possible que quelque chose échoue lors de
cette transaction. Nous devons donc l'encapsuler
dans un bloc de cache try. Je vais donc
ajouter ici un bloc de tribus. Je vais déplacer tout ce
code dans le bloc tri. C'est donc pour notre scénario de
réussite. Maintenant, si quelque chose échoue, nous devrions détecter une
exception ici et renvoyer une erreur 500
avec le clin. Donc, le point de réponse 500, qui signifie une
erreur interne du serveur accompagnée d'un mensonge, votre véhicule n'est pas sur écoute Quelque chose s'est mal passé.
Mais avant cela, nous devons annuler
la transaction. Attendez donc le point de session intégré à la transaction, puis
la session point de session. Maintenant, dans une application du monde réel, à ce stade, vous
souhaitez enregistrer cette exception. Plus tard, vous pourrez revenir
et voir ce qui n'a pas fonctionné. Nous allons avoir
une section distincte dans le cours sur la
gestion des erreurs et la journalisation. Donc, pour l'instant, ne nous
inquiétons pas de ça. De retour sur Mongo DB Campus, je vais supprimer les
locations de collecte des locations Maintenant, de retour dans le terminal, l'
application est lancée. Plus rien. Notre application est
en cours d'exécution. Magnifique. De retour dans notre base de données, jetez un œil à notre collection de voitures. Nous avons donc ici une voiture et
le numéro en stock est cinq. Je vais créer
une nouvelle location. Ensuite, nous allons
revenir ici, et ce numéro devrait être f.
Donc revenons à Postman Je vais donc
envoyer une demande de courrier à notre terminal de location, et ici, dans le corps
de la demande, j'ai un identifiant client
et un identifiant de voiture valides. Alors, envoyons-nous. OK, voici notre
réponse. Magnifique. Voici donc notre nouvel objet
de locataire. Vous pouvez voir que vous le louez
sur votre carte d'identité, votre client et votre voiture. Maintenant, de retour dans la base
de données de la collection de voitures, je vais actualiser cette liste. Écoutez, le numéro en
stock est maintenant de quatre. Cela permet donc de vérifier que notre transaction s'est
terminée avec succès Maintenant j'ai une question pour toi. Nous créons donc ici
cet objet de location. Nous ne définissons que le client et la voiture. Ensuite, nous transmettons la session aux opérations Mongo Di
et envoyons cet
objet de location au client Dans ce code, nous n'avons donc pas défini d'identifiant ni ne l'avons
loué pour les propriétés. Mais dans le corps de la réponse, vous pouvez voir que ces deux
propriétés sont définies. Alors, comment est-ce arrivé ? Nulle part dans ce code après avoir
effectué cette transaction, nous n'avons réinitialisé l'objet de location. Alors, comment avons-nous obtenu les propriétés
d'identification et de date ? Peut-être vous attendez-vous
à ce que Mongo DB définisse ces valeurs pour nous. Mais en fait, non. Dans Mongo B, nous n'avons pas ces valeurs
par défaut Nous les définissons dans
notre schéma Mongoose. Ainsi, lorsque nous créons une
nouvelle location ou un nouvel objet, Mongoose connaît le
schéma de cet objet Il examine différentes propriétés et définit les valeurs par défaut. Il en va de même pour
la propriété IE. Donc, plus précisément, Mongo
DB ne définit pas cela. Cette propriété est définie avant l'enregistrement de ce
document dans la base de données. Je ne vous l'ai pas dit
plus tôt parce que je ne
voulais pas vous embrouiller
avec trop de détails. Il y a d'autres points à identifier que
nous aborderons
lors de la prochaine conférence.
9. ObjectID dans MongoDB: Dans cette conférence, nous
allons
examiner les identifiants d'objets dans Mongo Di Bi Vous avez donc remarqué que lorsque vous stockez un document
dans Mongadib, Mongo Debi définit la valeur de
la propriété ID sur une
longue chaîne comme celle-ci Nous avons donc ici 24 caractères, et tous les deux caractères
représentent un octet. Donc, essentiellement, nous
avons 12 octets pour identifier de manière unique un
document dans Mongo Deb Maintenant, sur ces 12 octets, les quatre premiers octets
représentent un horodatage, c'est-à-dire l'heure à laquelle ce
document a été créé Plus tard, je vais vous
montrer comment
extraire cet horodatage
de cet identifiant d'objet Ainsi, avec ces quatre octets, vous n'avez pas besoin de créer une propriété distincte dans votre
document, comme celle créée à, car cet horodatage est
inclus dans l'ID de l'objet De même,
si vous souhaitez trier vos documents en fonction de
leur date de création, vous pouvez simplement les trier
en fonction de leur propriété ID. Les trois octets suivants représentent
un identifiant de machine. Ainsi, deux machines différentes auront deux identifiants
différents Les deux octets suivants représentent
un identifiant de processus. Donc, si nous générons deux
identifiants d'objets sur la même machine, mais dans des processus différents, ces deux octets
seront différents. Enfin, les trois derniers
octets représentent un compteur. Si vous êtes sur la
même machine effectuez le même processus à
la même seconde, mais que vous générez deux documents
différents, les Canter Bites
seront différents Ainsi, avec ces 12 octets, nous pouvons identifier de manière unique
un document dans Mongadib Il y a très,
très peu de chances que nous
générions deux
identifiants d'objets identiques. Laissez-moi vous montrer comment
cela peut se produire. Vous savez donc que dans un octet, nous avons huit bits. Dans chaque bit, nous avons
un zéro ou un. Alors, combien de nombres pouvons-nous représenter sur un
octet ou huit bits ? Eh bien, c'est deux fois la
puissance de huit, soit 256. Ainsi, avec un octet, nous pouvons
stocker 256 nombres différents. Maintenant, je vous ai dit que
les trois derniers octets représentent un compteur. C'est comme le
compteur que vous avez probablement vu dans SQL Server,
MySQL et d'autres bases de données. Donc, un
nombre à incrémentation automatique comme un, deux, trois, quatre, etc. Alors, combien de nombres
pouvez-vous stocker sur trois octets ? C'est deux fois plus que 24. Cela représente 16 millions. Donc, si à la même seconde sur la même machine dans
le même processus, nous générons plus de
16 millions de documents, ce compteur débordera Et c'est là que
nous pouvons nous retrouver avec deux documents portant
le même identifiant d'objet. Mais vous pouvez constater que ce scénario
est très improbable pour
la plupart des applications disponibles. Tout ce que je veux que vous sachiez,
c'est que cet
identifiant d'objet est presque unique,
mais pas à 100 %. Maintenant, vous êtes peut-être
curieux de savoir pourquoi Mongo Dew
n' a pas de mécanisme
garantissant l'unicité Par exemple, dans les systèmes de
gestion de base tels que SQL Server ou MySQL, dans la table E, nous avons un nombre à incrémentation automatique
qui garantit La prochaine fois que nous voulons stocker un enregistrement de cours dans notre base de données, l'idée de ce cours sera du dernier
cours plus un. Cette approche garantit l'unicité de
ces identifiants, mais elle nuit à l'
évolutivité Cet identifiant que nous avons ici n'
est pas généré par
Mongo DB elle-même. Il est en fait généré
par le pilote Mongo DB. Nous avons donc ce
pilote Mongo Dew qui parle à Mongo Div. Cet identifiant est donc
généré par le pilote, qui signifie que nous
n'avons pas à attendre Mongo Dew génère un
nouvel identifiant unique C'est pourquoi
les applications basées sur Mongo DB sont
hautement évolutives Nous pouvons avoir plusieurs
instances de Mongo DB et nous
n'avons pas besoin de parler
à un point central
pour obtenir un identifiant unique Le pilote lui-même peut générer un identifiant presque unique
en utilisant ces 12 octets. Ainsi, lorsque nous créons une
application avec Node et Express,
nous utilisons Mongoose Comme je vous l'ai déjà dit, mongoose est une abstraction du pilote de base
de données Mongo. Ainsi, lorsque nous créons un nouvel identifiant d'
objet et un nouveau document, Mongoose communique avec le
pilote de base de données Mongo pour générer un nouvel Désormais, vous pouvez également générer
explicitement un identifiant si vous le
souhaitez. Laisse-moi te montrer. Je vais clarifier
tout cela par le haut. Chargeons les mongos, il
faut des mangues. Ici, nous pouvons créer
un nouvel identifiant d'objet. Réglons donc cela sur les nouveaux types de points Mongos
point Object IDE. Ensuite, enregistrons
cela sur la console. Et ici, dans le terminal, exécutons ce programme qui
est node object ID point js. Donc, regardez, nous avons un identifiant
unique, et nous n'avons
rien stocké dans Mongoib Nous avons généré cet identifiant d'
objet en mémoire. Maintenant, je vous ai dit que
les quatre premiers octets représentent un horodatage Cet identifiant d'objet a donc une
méthode appelée GTs Stamp, enregistrer dans le terminal Refaisons-le. Écoutez, c'est à ce moment que j'ai généré
cet identifiant d'objet. Nous avons également une méthode statique sur cette classe d'ID d'objet pour
valider les ID d'objet Le point de type de point
mangos est donc valide. Je peux donc passer une chaîne
ici, 12, trois, quatre. Il ne s'agit évidemment pas
d'un identifiant d'objet valide. Donc, lorsque nous enregistrons cela sur la
console, nous devrions obtenir une valeur fausse. Le journal des points de la console est valide. Refaisons-le.
Et voici le résultat. Maintenant que vous comprenez les identifiants d'
objets plus en détail,
dans la prochaine conférence, nous allons revenir à notre
application Fair Wheels et apporter quelques modifications pour l'améliorer.
10. Valider l'ID d'objet en utilisant Joi: Pour en revenir à notre application Fair
Wheels, j'ai ouvert un postier, et je vais
envoyer une demande de publication à notre point de vente. Et ici, dans le corps
de la demande, nous avons un numéro de
client et un identifiant de voiture valides. Maintenant, laissez-moi vous montrer ce qui
se passe si nous changeons cet ID d'objet par
une valeur telle que 1234. Il ne s'agit donc pas d'un identifiant d'objet
valide. Envoyons cette demande. Vous pouvez voir que nous avons obtenu
le statut 500, ce qui est une erreur interne du serveur. Cependant, ce n'est pas le cas, car nous avons envoyé un numéro de client
non valide. Comme je vous l'ai déjà dit, nous avons une section distincte sur la gestion des
erreurs et la
connexion au cours. Ne nous
inquiétons donc pas de cette partie. Pour l'instant, enregistrons cette erreur sur la console pour voir ce qui s'est
exactement passé là-bas. Donc, revenons au code ici
dans le bloc de cache, consigner les points de la
console par
renvoyons la demande. Maintenant, si vous regardez
dans le terminal, convertissez le champ ID de l'objet
pour les valeurs un, deux, trois, quatre, tapez une chaîne dans chemin souligné par l'ID
du client modèle. Ce message peut sembler un
peu trop technique ou confus, mais je vais vous le simplifier
vraiment. Nous parlons donc ici client
ou de
cette classe de clients modèle. Nous parlons de
la propriété ID. Dans Mongoose, le mot chemin apparaît car le chemin peut représenter
une chaîne de propriétés Par exemple, un client
peut avoir une adresse, et l'adresse peut avoir une rue. C'est pourquoi nous utilisons des chemins. Maintenant, Mangus se
plaint ne pas
avoir pu convertir la
valeur 1234 en identifiant d'objet Évidemment, car 1234 n'
est pas un identifiant d'objet valide. Mais le problème que nous avons dans notre implémentation est
que, tout d'abord, nous obtenons une réponse
générique ici, et nous recevons cette
erreur dans le terminal. Dans ce cas, lorsque nous
envoyons un numéro de client non valide, nous devrions recevoir une erreur 400. C'est une mauvaise demande car un serveur ne peut pas
répondre à cette demande. Donc, de retour dans RentoStrgs c'est le gestionnaire pour
créer une nouvelle En plus, nous
validons la demande, ce
qui garantit que
nous avons dans notre demande un
identifiant client et un identifiant de voiture Mais peu importe que ces
valeurs soient des identifiants d'objet valides. Cette exception a été émise
sur cette ligne à la ligne 21. Lorsque nous essayons de trouver
un client par identifiant, si vous transmettez un identifiant d'objet
non valide, nous obtenons
cette exception. Donc, une façon de résoudre ce
problème est la suivante. Si les types de points Mangus correspondent à
un identifiant d'objet valide. Nous transmettons donc l'identifiant client request
body point. Maintenant, si ce n'est pas valide, nous allons renvoyer
l'erreur 400. Donc statut 400 avec un message comme « client non valide ». Ensuite, nous devons
répéter la même chose pour
valider la propriété de l'identifiant de la voiture Cependant, il s'agit d'une
mauvaise implémentation. Il s'agit d'une mauvaise approche pour résoudre ce problème, car
nous avions précédemment défini cette fonction
pour valider notre demande. Cette logique
appartient donc vraiment à cette fonction. Dans cette fonction,
nous voulons donc nous
assurer que l'
ID client est une chaîne. Il possède une valeur et il s'agit
d'un identifiant d'objet valide. Donc, si l'entrée est
dans la bonne forme, nous allons dans la base de données
pour trouver ce client. OK ? Je vais donc supprimer
ces deux lignes à partir d'ici. Revenons à notre fonction de
validation. C'est donc dans le point JS de location. Voici notre fonction de validation
de location. Maintenant, nous devons ajouter une validation
personnalisée car nous
devons parler à Mongoose Nous devons appeler une
méthode valide de type ID d'objet. Maintenant, étendre cette validation
est un peu complexe, et vous ne voulez pas le répéter
à
chaque fois que vous avez
une fonction de validation. Il existe en fait
un package NPM pour ajouter un support à la validation des identifiants d'
objets, Alors, de retour dans le terminal, installons Joy Object ID. Donc pas ça, la version actuelle j'utilise est la version 4.0 0.2. Maintenant, revenons au code
ici dans le point de location Gs, en haut, nous
devons charger ce module. Vous avez donc besoin de Joy Object ID. Maintenant, cela renvoie une fonction. Nous devons appeler cette
fonction et transmettre une référence à ce module Joy. Nous passons donc Joy ici, et d'ailleurs, vous n'
avez pas à le mémoriser. Vous pouvez simplement consulter
la documentation NPM. Un autre résultat est une fonction, nous pouvons
donc attribuer cette fonction à joy point
Object ID. Object ID est donc une méthode
sur cet objet Joy. Maintenant, revenons à notre
fonction de validation.
Je vais donc changer la
définition de cet identifiant client
de Joy Dot String
à Joy Dot Object ID. C'est la méthode que nous avons définie en haut de
ce module, n'est-ce pas ? Et c'est également obligatoire. Nous allons faire
la même modification
pour la propriété de l'identifiant de la voiture. Donc, ID de l'objet. Maintenant, de retour dans le terminal, relançons l'application. Je vais envoyer une demande avec ce numéro de client non valide. Pareil. OK, écoute, nous avons
reçu une mauvaise demande. L'ID client dont la valeur est
1234 ne correspond pas
au modèle requis. Et si vous regardez dans
le terminal, C, nous n'avons plus cette erreur d'échec
de conversion en identifiant d'objet. Aujourd'hui, il existe une bien meilleure implémentation de
cette approche. Donc, de retour dans rental point JS, il est probable que
nous utilisions
cette méthode à d'autres
endroits de notre application, comme dans le module voiture
ou le module client. Nous ne voulons pas redéfinir cette méthode d'identification d'objet
dans chaque module Donc, en haut du fichier, c'est ici que nous définissons la méthode d'identification de l'objet
dans l'objet Joy. Je vais le déplacer d'ici
vers le point d'index Gs. Nous le chargeons donc une fois et nous pouvons réutiliser partout
dans notre application. Alors
allons-y et passons à index point JS. En haut,
ajoutons cette ligne ici. Nous devrions également charger Joy. Une joie si constante. Nous l'avons défini pour exiger de la joie. OK ? C'est donc une
meilleure implémentation. Il y a un autre endroit
que nous devons modifier ici. Donc, dans notre dossier de modèles, regardez car point js. Ainsi, lors de la création d'une voiture, nous devons transmettre un identifiant d'entreprise
valide. Je vais donc le remplacer par Joy Dot Object ID. Maintenant, un dernier changement avant
de terminer cette conférence. Donc, dans notre dossier routes, jetons un coup d'
œil à cars point JS. Voici le gestionnaire pour
créer une nouvelle voiture. Ici, nous créons
un nouvel objet de voiture, enregistrons dans la base de données,
puis nous le renvoyons. Maintenant, dans cette implémentation, je réinitialise cette voiture après l'avoir enregistrée
dans la base de Cela visait uniquement à
démontrer que cette méthode de sauvegarde
renvoie un document de voiture. De plus, je ne
voulais pas vous distraire avec trop de détails sur le
fonctionnement des identifiants d'objets Maintenant que vous le savez, les identifiants d'objets sont en fait générés
par le pilote MongoDB, non par la base de données Mongo DB Vous savez que lorsque nous
créons un nouvel objet de voiture, Mongoose parle au
pilote MongoDB et définit l'ID ici avant d'enregistrer
cette voiture dans la base de Techniquement, nous
n'avons donc pas besoin de réinitialiser cette voiture pour rendre
cet identifiant au client. Nous pouvons donc le supprimer et changer la carte d'une
variable à une constante. Le même principe s'applique lors la création d'un nouveau client
et d'une nouvelle entreprise.