Transactions MongoDB: garantir la cohérence des données

MongoDB prend en charge les transactions. Les étapes de l'utilisation des transactions MongoDB incluent: 1. Démarrez la session, 2. Démarrez la transaction, 3. Effectuez l'opération, 4. Soumettre ou annuler la transaction. Les transactions garantissent la cohérence des données et l'atomicité grâce aux mécanismes de verrouillage et à l'exploitation forestière.

introduction

À cette époque de suprématie des données, garantissant la cohérence et l'intégrité des données est devenue particulièrement importante. En tant que base de données NOSQL populaire, MongoDB a introduit des fonctions de transaction ces dernières années pour faire face aux besoins de cohérence des données dans la logique métier complexe et les environnements de concurrence élevés. Cet article explorera des moyens approfondis d'utiliser les transactions MongoDB et les meilleures pratiques pour vous aider à mieux comprendre et appliquer cette fonctionnalité. En lisant cet article, vous apprendrez à utiliser les transactions dans MongoDB pour assurer la cohérence des données et en savoir plus sur certains pièges et stratégies d'optimisation courantes.

Examen des connaissances de base

Les fonctions de transaction de MongoDB sont conçues sur la base des principes de l'atomicité, de la cohérence, de l'isolement et de la persistance (acide) des opérations multi-documents. Avant MongoDB 4.0, MongoDB ne prenait pas en charge les transactions multi-documents, ce qui signifie que lors de l'exécution d'opérations impliquant plusieurs documents, il n'y a aucune garantie que toutes les opérations seraient réussies ou que tous échouent. Pour comprendre les transactions MongoDB, vous devez d'abord comprendre certains concepts de base:

• Transaction : un ensemble d'opérations de base de données, qui réussissent ou échouent.
• Principes acides : atomicité, cohérence, isolement et durabilité.
• Session : les transactions de MongoDB sont basées sur la session et chaque transaction doit être effectuée en une seule session.

Analyse du concept de base ou de la fonction

Définition et fonction des transactions MongoDB

Les transactions MongoDB vous permettent d'effectuer plusieurs opérations de lecture et d'écriture dans une seule opération atomique, garantissant que ces opérations réussissent ou que toutes échouent. Ceci est très important pour les scénarios d'application qui nécessitent des opérations sur plusieurs documents ou collections. Par exemple, dans le système de commerce électronique, lorsqu'un utilisateur passe une commande, les informations d'inventaire et de commande doivent être mises à jour en même temps et les transactions sont particulièrement importantes.

 const Session = client.startSession ();
essayer {
  session.startTransaction ();
  const InventoryDoc = Await InventoryCollection.FindOnDupdate (
    {sku: "ABC123", Qté: {$ gte: 10}},
    {$ inc: {Qté: -10}},
    { session }
  ));
  attendre orderscollection.insertone (
    {
      SKU: "ABC123",
      Qté: 10
    },
    { session }
  ));
  Await Session.ComMitTransaction ();
} catch (erreur) {
  attendre session.AbortTransaction ();
  lancer une erreur;
} enfin {
  Session.endSession ();
}

Cet exemple montre comment mettre à jour l'inventaire et créer des commandes dans une transaction, assurant l'atomicité des deux opérations.

Comment ça marche

Les transactions MongoDB sont mises en œuvre par le biais de mécanismes de verrouillage et de journalisation. Lorsque vous démarrez une transaction, MongoDB verrouille toutes les opérations de la transaction, en veillant à ce que d'autres opérations ne puissent pas interférer avec l'exécution de la transaction. Dans le même temps, MongoDB enregistre toutes les opérations de la transaction afin qu'elle puisse revenir à l'état avant le début de la transaction lorsque la transaction échoue.

• Mécanisme de verrouillage : MongoDB utilise des verrous optimistes et des verrous pessimistes pour gérer l'accès simultané dans les transactions.
• Journalisation : MongoDB utilise la journalisation de l'écriture (WAL) pour enregistrer les opérations dans les transactions pour assurer la persistance des données et la cohérence.

Exemple d'utilisation

Utilisation de base

Les étapes de base de l'utilisation des transactions dans MongoDB incluent le démarrage d'une session, le démarrage d'une transaction, l'exécution d'une opération, la validation ou le retrait d'une transaction. Voici un exemple simple:

 const Session = client.startSession ();
essayer {
  session.startTransaction ();
  // Exécuter les opérations en transaction Await Session.CommitTransaction ();
} catch (erreur) {
  attendre session.AbortTransaction ();
  lancer une erreur;
} enfin {
  Session.endSession ();
}

Cet exemple montre comment effectuer une opération dans une transaction et soumettre une transaction lorsque l'opération réussit et reculer la transaction en cas d'échec.

Utilisation avancée

Dans certains scénarios complexes, vous devrez peut-être effectuer des jugements conditionnels ou des opérations de boucle dans une transaction. Par exemple, dans un système de gestion des stocks, vous devrez peut-être vérifier si l'inventaire est suffisant dans la transaction avant d'effectuer l'opération de déduction:

 const Session = client.startSession ();
essayer {
  session.startTransaction ();
  const InventoryDoc = Await InventoryCollection.FindOne (
    {sku: "ABC123", Qté: {$ gte: 10}},
    { session }
  ));
  if (inventorydoc) {
    attendre l'inventaire collection.updateOne (
      {_id: inventorydoc._id},
      {$ inc: {Qté: -10}},
      { session }
    ));
    attendre orderscollection.insertone (
      {
        SKU: "ABC123",
        Qté: 10
      },
      { session }
    ));
  } autre {
    lancer une nouvelle erreur ("inventaire");
  }
  Await Session.ComMitTransaction ();
} catch (erreur) {
  attendre session.AbortTransaction ();
  lancer une erreur;
} enfin {
  Session.endSession ();
}

Cet exemple montre comment porter des jugements conditionnels dans une transaction et faire reculer la transaction si la condition n'est pas remplie.

Erreurs courantes et conseils de débogage

Les erreurs courantes lors de l'utilisation des transactions MongoDB incluent:

• Timeout des transactions : les transactions MongoDB ont un délai de temps mort par défaut. Si la transaction s'exécute trop longtemps, le délai d'expiration de la transaction provoquera le délai d'attente de la transaction. Vous pouvez ajuster le délai d'expiration de la transaction en définissant le paramètre maxTimeMS .
• Conflit de verrouillage : Dans des environnements de concurrence élevés, les transactions peuvent échouer en raison du conflit de verrouillage. Vous pouvez réduire les conflits de verrouillage en optimisant l'ordre des opérations dans les transactions ou en utilisant des verrous optimistes.
• Fuite de ressources : si la session n'est pas close correctement, elle peut entraîner des fuites de ressources. Vous devez vous assurer que la session est close une fois la transaction terminée.

Les méthodes pour déboguer ces problèmes comprennent:

• Analyse des journaux : Vérifiez les journaux de MongoDB pour comprendre les raisons de l'échec des transactions.
• Suivi des performances : utilisez les outils de surveillance des performances de MongoDB pour analyser le temps d'exécution des transactions et la consommation de ressources.
• Examen du code : examinez attentivement le code dans la transaction pour s'assurer que toutes les opérations sont exécutées dans la transaction et que la transaction est logiquement correcte.

Optimisation des performances et meilleures pratiques

Dans les applications pratiques, il est très important d'optimiser les performances des transactions MongoDB. Voici quelques stratégies d'optimisation et meilleures pratiques:

• Réduire les opérations dans les transactions : minimiser le nombre d'opérations dans les transactions, réduire le temps de maintien des verrous et améliorer les performances de la concurrence.
• Utilisation de verrous optimistes : utilisez des verrous optimistes au lieu de serrures pessimistes pour réduire la survenue de conflits de verrouillage lorsque cela est possible.
• Fonctionnement par lots : combinez plusieurs petites opérations en une opération par lots, réduisant le nombre de transactions et le temps de maintien de verrouillage.

Par exemple, ce qui suit est un exemple optimisé:

 const Session = client.startSession ();
essayer {
  session.startTransaction ();
  const InventoryDocs = Await InventoryCollection.Find (
    {sku: {$ in: ["ABC123", "Def456"]}, Qté: {$ gte: 10}},
    { session }
  ) .toArray ();
  const updates = inventorydocs.map (doc => ({{
    UpdateOne: {
      filtre: {_id: doc._id},
      Mise à jour: {$ Inc: {Qté: -10}}
    }
  }));
  Await InventoryCollection.BulkWrite (mises à jour, {session});
  const Orders = InventoryDocs.map (doc => ({{
    sku: doc.sku,
    Qté: 10
  }));
  attendre orderscollection.insertMany (ordres, {session});
  Await Session.ComMitTransaction ();
} catch (erreur) {
  attendre session.AbortTransaction ();
  lancer une erreur;
} enfin {
  Session.endSession ();
}

Cet exemple montre comment optimiser les performances des transactions via les opérations par lots, réduisant le temps de maintien de verrouillage et les temps de transaction.

Lorsque vous utilisez des transactions MongoDB, vous devez également prêter attention aux points suivants:

• Coût d'une transaction : les transactions augmentent la charge et la consommation de ressources de la base de données, donc lors de la conception d'une application, vous devez peser la relation entre l'utilisation des transactions et les performances.
• Niveau d'isolement des transactions : MongoDB prend en charge plusieurs niveaux d'isolement des transactions, et différents niveaux d'isolement affecteront les performances et la cohérence des transactions. Vous devez choisir le niveau d'isolement approprié en fonction de vos besoins commerciaux spécifiques.
• Rollback of Transactions : MongoDB annulera automatiquement la transaction lorsque la transaction échoue, mais cela peut entraîner une dégradation des performances. Vous pouvez réduire le nombre de reculs en optimisant l'ordre des opérations dans les transactions.

En bref, les capacités transactionnelles de MongoDB fournissent des outils puissants pour assurer la cohérence des données, mais lorsque vous l'utilisez, vous devez prêter attention à l'optimisation des performances et aux meilleures pratiques. Grâce à l'introduction et aux exemples de cet article, vous devriez être en mesure de mieux comprendre et appliquer les capacités de transaction de MongoDB, en vous assurant que votre application peut maintenir la cohérence des données et l'intégrité dans des environnements de concurrence élevés.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!