Java und MongoDB 4.0 Unterstützung für Multi-Dokument-Säure-Transaktionen

Monologien von MongoDB 4.0 Detaillierte Erläuterung der Säure -Transaktion -Unterstützung

(Dieser Artikel wurde in Zusammenarbeit mit MongoDB erstellt. Vielen Dank für Ihre Unterstützung für die Partner, die SitePoint ermöglicht haben.)

mongoDB 4.0 fügt Unterstützung für Multi-Dokument-Säure-Transaktionen hinzu. Aber bedeutet dies, dass MongoDB vor Transaktionen keine Transaktionen unterstützt hat? Nicht so hat MongoDB immer einzelne Dokumententransaktionen unterstützt. MongoDB 4.0 garantiert, dass diese Transaktionen auf mehrere Dokumente, mehrere Anweisungen, mehrere Sammlungen und mehrere Datenbanken erweitert werden können. Was ist die Datenbank ohne irgendeine Form von Transaktionsdatenintegritätsgarantie noch nützlich?

Bevor Sie in diesen Artikel eintauchen, finden Sie hier den gesamten Code und versuchen Sie mehrdokumentierte Säure-Transaktionen.

Schlüsselpunkte

• mongoDB 4.0 führt Multi-Dokument-Säure-Transaktionen ein, die Transaktionsgarantien auf mehrere Dokumente, Aussagen, Sammlungen und Datenbanken erweitern und so die Datenintegrität und -konsistenz verbessern.
• Vor dem MongoDB 4.0 unterstützte MongoDB einzelne Dokumententransaktionen, um den Atomoperationen innerhalb eines einzelnen Dokuments zu gewährleisten, und eignet sich für die meisten Anwendungen.
• mongoDB 4.0 Multi-Dokumentsäure-Transaktionen stimmen mit traditionellen relationalen Datenbanktransaktionen überein und bieten Atomizität, Konsistenz, Isolierung und Persistenz in komplexeren Operationen.
• Einstellungen für die Verwendung von Multi-Dokument-Säure-Transaktionen umfassen das Starten von MongoDB-ReplikaSet, die Einrichtung einer Java-Umgebung mit den erforderlichen Abhängigkeiten und die Durchführung von Transaktionsvorgängen über bereitgestellte Skripte.
Die tatsächliche Demonstration im Artikel zeigt die Implementierung von Multi-Dokumenten-Transaktionen, einschließlich Szenarien, in denen Transaktionen auf der Grundlage der Verfügbarkeit von Bestandsbeständen verpflichtet oder zurückgeführt werden, um die Konsistenz des Datenbankzustands zu gewährleisten.

schnelles Start

Schritt 1: MongoDB starten

Starten Sie einen einzelnen Knoten MongoDB Replicaset mit mindestens Version 4.0.0 auf Port 27017 von Localhost.

Wenn Sie Docker verwenden:

Sie können
• verwenden. start-mongo.sh
Wenn Sie fertig sind, können Sie
• verwenden. stop-mongo.sh
Wenn Sie mit Mongo -Shell eine Verbindung zu MongoDB herstellen möchten, können Sie
• verwenden. connect-mongo.sh

Wenn Sie es vorziehen, Mongod manuell zu starten:

• mkdir /tmp/data && mongod --dbpath /tmp/data --replSet rs
• mongo --eval 'rs.initiate()'

Schritt 2: Start Java

Diese Demo enthält zwei Hauptprogramme:

und ChangeStreams.java. Transactions.java

Ändern von Streams können Sie Benachrichtigungen über Datenänderungen in einer MongoDB -Sammlung oder Datenbank erhalten.
Der Transaktionsprozess ist die Demonstration selbst.

Sie benötigen zwei Shells, um sie auszuführen.

Wenn Sie Docker verwenden:

Erste Shell:

./compile-docker.sh
./change-streams-docker.sh

zweite Schale:

./transactions-docker.sh

Wenn Sie Docker nicht verwenden, müssen Sie Maven 3.5.x und JDK 10 (oder JDK 8 Mindestversion installieren, aber Sie müssen die Java -Version in

aktualisieren: pom.xml

Erste Shell:

./compile-docker.sh
./change-streams-docker.sh

zweite Schale:

./transactions-docker.sh

Vergleichen wir vorhandene einzelne Dokumententransaktionen mit säurekompatiblen Multi-Dokument-Transaktionen für MongoDB 4.0 und erfahren Sie, wie Sie Java verwenden, um diese neue Funktion zu nutzen.

Versionen vor MongoDB 4.0

Auch in MongoDB 3.6 und früher wird jeder Schreibvorgang als Transaktion dargestellt, das auf der Speicherschicht mit einer einzelnen Dokumentstufe abgebildet ist. Da das Dokumentmodell die relevanten Daten kombiniert, ansonsten die Modellierung über verschiedene Eltern-Kind-Tabellen im tabellarischen Schema hinweg modelliert, bietet der Atomic Single-Dokument-Betrieb von MongoDB Transaktionsemantik, die den Datenintegritätsanforderungen der meisten Anwendungen entsprechen.

Jeder typische Schreibvorgang, der mehrere Dokumente verändert, tritt tatsächlich in mehreren unabhängigen Transaktionen auf: eine Transaktion pro Dokument.

Nehmen wir als Beispiel eine sehr einfache Inventarverwaltungsanwendung auf.

Zunächst brauche ich ein MongoDB -Replikat -Set, also starten Sie also MongoDB wie oben beschrieben.

Nehmen wir nun das folgende Dokument in die Produktsammlung ein:

./compile.sh
./change-streams.sh

unter der Annahme, dass eine Aktion im Gange ist, möchten wir unseren Kunden einen Rabatt von 20% auf alle Produkte bieten.

, aber bevor wir diesen Rabatt anwenden, möchten wir Änderungsströme verwenden, um zu überwachen, wie lange diese Vorgänge in MongoDB auftreten.

Machen Sie Folgendes in Mongoschale:

./transactions.sh

Lassen Sie diese Hülle beiseite, öffnen Sie eine weitere Mongoschale und wenden Sie den Rabatt an:

MongoDB Enterprise rs:PRIMARY> db.product.insertMany([
    { "_id" : "beer", "price" : NumberDecimal("3.75"), "stock" : NumberInt(5) }, 
    { "_id" : "wine", "price" : NumberDecimal("7.5"), "stock" : NumberInt(3) }
])

Wie Sie sehen, werden beide Dokumente mithilfe einer einzigen Befehlszeile aktualisiert, jedoch nicht in einer Transaktion. Folgendes haben wir in der Change Stream Shell gesehen:

cursor = db.product.watch([{$match: {operationType: "update"}}]);
while (!cursor.isExhausted()) {
  if (cursor.hasNext()) {
    print(tojson(cursor.next()));
  }
}

Wie Sie sehen, ist die Clusterzeit der beiden Operationen (siehe clusterTime Schlüssel) unterschiedlich: Diese Operationen treten in derselben Sekunde auf, aber der Zähler für den Zeitstempel wird durch 1 erhöht.

Aktualisieren Sie also jeweils eine aktualisierte, auch wenn dies sehr schnell geschieht, können andere das Dokument lesen, während das Update ausgeführt wird und nur einen der Produkte erfolgt.

In der meisten Zeit können Sie dies in einer MongoDB -Datenbank tolerieren, da wir versuchen, eng verwandte oder verwandte Daten in das gleiche Dokument wie möglich einzubetten. Daher finden zwei Aktualisierungen desselben Dokuments in einer Transaktion statt:

PRIMARY> db.product.updateMany({}, {$mul: {price:0.8}})
{ "acknowledged" : true, "matchedCount" : 2, "modifiedCount" : 2 }
PRIMARY> db.product.find().pretty()
{
    "_id" : "beer",
    "price" : NumberDecimal("3.00000000000000000"),
    "stock" : 5
}
{
    "_id" : "wine",
    "price" : NumberDecimal("6.0000000000000000"),
    "stock" : 3
}

Manchmal können Sie jedoch nicht alle relevanten Daten in ein einzelnes Dokument modellieren, und es gibt viele Gründe, das Dokument nicht einzubetten.

mongoDB 4.0 unter Verwendung von Multi-Dokument-Säure-Transaktionen

multi-dokumentierte Säure-Transaktionen in MongoDB sind dem, was Sie möglicherweise aus herkömmlichen relationalen Datenbanken gelernt haben, sehr ähnlich.

MongoDB-Transaktionen sind verwandte Konversationsvorgänge, die atomisch oder vollständig in einer Art und Nicht-Ausführung zurückgerollt werden müssen.

Transaktionen werden verwendet, um sicherzustellen, dass Vorgänge auch über mehrere Sammlungen oder Datenbanken atomar werden. Mithilfe von Snapshot -Isolation liest ein anderer Benutzer nur alle Aktionen oder keine Aktionen.

Fügen wir jetzt einem Einkaufswagen zu unserem Beispiel hinzu.

In diesem Beispiel werden 2 Sammlungen benötigt, da wir mit 2 verschiedenen Geschäftseinheiten zu tun haben: Inventarmanagement und Karren, die jeder Kunde beim Einkaufen erstellen kann. Jedes Dokument in diesen Sammlungen hat einen anderen Lebenszyklus.

Die Dokumentation in der Produktsammlung zeigt den Artikel an, den ich verkaufe. Dies schließt den aktuellen Produktpreis und den aktuellen Inventar ein. Ich habe ein Pojo erstellt, um es darzustellen: Product.java.

./compile-docker.sh
./change-streams-docker.sh

Wenn der Kunde seinen ersten Element in den Wagen hinzufügt, wird der Wagen erstellt, und wenn der Kunde weiterhin überprüft oder die Website verlässt, wird der Wagen gelöscht. Ich habe ein Pojo erstellt, um es darzustellen: Cart.java.

./transactions-docker.sh

Die Herausforderung hier ist, dass ich nicht mehr verkaufen kann als ich: Wenn ich 5 Biere verkaufen muss, kann ich nicht mehr als 5 Biere in den Einkaufswagen für verschiedene Kunden haben.

Um dies zu gewährleisten, muss ich sicherstellen, dass der Betrieb des Client -Wagens mit dem Inventar -Update atomic ist. Hier kommen Multi-Dokument-Transaktionen ins Spiel. Wenn jemand versucht, etwas zu kaufen, das ich nicht auf Lager habe, muss die Transaktion scheitern. Ich werde dem Produktinventar eine Einschränkung hinzufügen:

./compile.sh
./change-streams.sh

(Beachten Sie, dass dies bereits im Java -Code enthalten ist.)

Um unsere Beispiele zu überwachen, werden wir MongoDB -Änderungsströme verwenden, die in MongoDB 3.6 eingeführt werden.

In jedem Thread dieses Prozesses namens ChangeStreams.java werde ich eine der 2 Sammlungen überwachen und die einzelnen Operationen und die zugehörige Clusterzeit drucken.

"

Nächste Schritte

Danke, dass Sie sich die Zeit genommen haben, meinen Beitrag zu lesen - ich hoffe, Sie finden es nützlich und interessant. Zur Erinnerung, alle Code finden Sie in diesem Github -Repository, mit dem Sie experimentieren können.

Wenn Sie nach einer sehr einfachen Möglichkeit suchen, um loszulegen, können Sie dies in nur 5 Klicks im MongoDB -Atlas -Datenbankdienst in der Cloud tun.

Zusätzlich sind Multi-Dokument-Säure-Transaktionen nicht die einzige neue Funktion in MongoDB 4.0. Sehen Sie sich also Ihren kostenlosen Kurs M040 an: Neue Funktionen und Werkzeuge in MongodB 4.0 an der Mongodb University und unserem Leitfaden zu neuen Funktionen in Mongodb 4.0, wo Sie mehr über native Conversions, neue Visualisierungs- und Analyse -Tools und Kubernetes -Integration erfahren können.

... (Der folgende Inhalt ist FAQ, der Artikel ist zu lang, hier weggelassen) ....

Das obige ist der detaillierte Inhalt vonJava und MongoDB 4.0 Unterstützung für Multi-Dokument-Säure-Transaktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!