MongoDB 怎么使用事务？

事务是一组数据库操作（例如读写操作），这些操作按顺序执行，并以全有或全无的方式完成。这意味着，只有当所有单个操作都成功时，这些操作的结果才会被保存到数据库中，并对事务外部的其他数据库客户端可见。如果任何操作未能正确执行，事务将中止，从事务开始所做的所有更改都会被撤销。数据库将恢复到之前的状态，就好像这些操作从未发生过。

为了说明事务对数据库系统的重要性，想象一下你在银行工作，需要从客户 A 向客户 B 转账。这意味着你必须同时减少源账户的余额并增加目标账户的余额。

如果两个操作中的任何一个单独失败而另一个成功，银行记录就会变得不一致。要么客户 B 无缘无故收到钱（如果客户 A 的账户余额没有减少），要么客户 A 无缘无故损失钱（如果他们的余额减少了，但客户 B 没有收到贷记）。为了确保结果始终一致，两个操作必须都成功，或者都失败。事务在这种情况下特别有用，确保全有或全无的执行。

数据库事务的四个属性确保此类复杂操作能够安全可靠地执行，即使在发生错误或中断时也能保证数据有效性，这些属性统称为 ACID： 原子性、一致性、隔离性 和 持久性。如果数据库系统能够为一组分组在事务中的操作保证所有四个属性，即使在执行过程中出现意外错误，也能保证数据库处于有效状态。

原子性 表示事务中的所有操作被视为一个单一的工作单元，要么全部执行，要么一个都不执行，没有中间状态。先前的转账示例突显了原子性原则。请注意，在 MongoDB 中，单个文档内的更新（无论文档结构多么复杂和嵌套）始终是 原子性 的，即使不使用事务。只有在处理多个文档的情况下，事务才能提供更强的原子性保证。
一致性 表示对数据库所做的任何更改必须遵守数据库的现有约束，否则整个事务将失败。例如，如果某个操作违反了唯一索引或 schema 验证规则，MongoDB 将中止事务。
隔离性 是指单独运行的并发事务相互隔离，彼此不会影响对方的结果。如果两个事务同时执行，隔离性规则保证最终结果与它们按顺序逐一执行相同。
持久性 保证一旦事务成功，客户端就可以确信数据已被正确持久化。即使发生硬件故障或电源中断，也不会使事务失效。

MongoDB 中的事务遵守这些 ACID 原则，可以可靠地用于需要在一次操作中更改多个文档的情况。

步骤 1 — 将您的独立 MongoDB 实例转换为副本集

如前所述，由于 MongoDB 中的实现方式，事务只能在作为更大集群一部分运行的数据库上执行。这个集群可以是分片数据库集群或副本集。

如果您已经配置了一个可用于练习运行事务的副本集或分片集群，可以跳过此步骤，并在步骤 2 中使用该集群。如果没有，本步骤将介绍如何将独立 MongoDB 实例转换为单节点副本集。

警告：像本步骤中将要配置的单节点副本集适用于测试用途，但不适合在生产环境中使用。原因是副本集旨在运行在多个分布式节点上，这有助于保持数据库的高可用性：如果任何一个节点失败，客户端仍可以连接到集合中的其他节点。这个单节点集合没有这种冗余，仅应在需要使用副本集的测试情况下使用。

如果您想了解更多关于 MongoDB 中复制及其涉及的安全含义的信息，我们强烈建议您查看我们的教程 How To Configure a MongoDB Replica Set on Ubuntu 20.04。

要将您的独立 MongoDB 实例转换为副本集，首先使用您喜欢的文本编辑器打开 MongoDB 配置文件。本示例使用 nano：

sudo nano /etc/mongod.conf

在文件底部找到读取 #replication: 的部分：

/etc/mongod.conf

. . .
#replication:
. . .

通过删除井号（#）来取消注释此行。然后在此行下方添加 replSetName 指令，后跟 MongoDB 用于识别副本集的名称：

/etc/mongod.conf

. . .
replication:
  replSetName: "rs0"
. . .

在本示例中，replSetName 指令的值为 "rs0"。您可以在这里提供任何您喜欢的名称，但使用描述性名称可能会有所帮助。

注意：启用复制时，MongoDB 还要求您配置除密码认证之外的其他认证方式，例如 keyfile 认证或设置 x.509 证书。如果您遵循了我们的 How To Secure MongoDB on Ubuntu 20.04 教程并在 MongoDB 实例上启用了认证，则您只会启用密码认证。

与其设置更高级的安全措施，对于本教程的目的，更明智的做法是禁用 mongod.conf 文件中的 security 块。通过为 security 块中的每一行添加井号来注释它们：

/etc/mongod.conf

. . .

#security:
#  authorization: enabled

. . .

只要您只计划将此数据库用于练习事务或其他测试目的，这不会构成安全风险。但是，如果您计划在未来使用此 MongoDB 实例存储任何敏感数据，请务必取消注释这些行以重新启用认证。

这些是您需要对该文件进行的唯一更改，因此可以保存并关闭它。如果您使用 nano 编辑文件，可以按 CTRL + X、Y，然后 ENTER 来完成。

之后，重启 mongod 服务以应用新的配置更改：

sudo systemctl restart mongod

重启服务后，打开 MongoDB shell 以连接到服务器上运行的 MongoDB 实例：

mongo

在 MongoDB 提示符下，运行以下 rs.initiate() 方法。这将把您的独立 MongoDB 实例转换为可用于测试的单节点副本集：

rs.initiate()

如果此方法输出中返回 "ok" : 1，则表示副本集已成功启动：

Output{
. . .
	"ok" : 1,
. . .

假设情况如此，您的 MongoDB shell 提示符将更改，以指示 shell 连接的实例现在是 rs0 副本集的成员：

请注意，此示例提示符反映了此 MongoDB 实例是副本集的 secondary 成员。这是预料之中的，因为通常在副本集初始化和其中一个成员被提升为主节点之间存在时间差。

如果您在等待片刻后运行命令甚至只是按 ENTER，提示符将更新以反映您已连接到副本集的主节点：

您的独立 MongoDB 实例现在作为单节点副本集运行，您可以用于测试事务。目前保持提示符打开，因为您将在下一步中使用 MongoDB shell 创建示例 collection 并向其中插入一些示例数据。

步骤 2 — 准备示例数据

为了解释 MongoDB 中的事务如何工作以及如何使用它们，本步骤概述了如何打开 MongoDB shell 以连接到您的副本集的主节点。它还解释了如何创建一个示例集合并向其中插入几个示例文档。本指南将使用这些示例数据来说明如何发起和执行事务。

如果您因为已有现有的分片 MongoDB 集群或副本集而跳过了上一步，请连接到任何可以写入数据的节点：

mongo

注意： 在新连接中，MongoDB shell 将默认自动连接到 test 数据库。您可以安全地使用此数据库来实验 MongoDB 和 MongoDB shell。

或者，您也可以切换到另一个数据库来运行本教程中给出的所有示例命令。要切换到另一个数据库，请运行 use 命令后跟数据库名称：

use database_name

要理解事务的行为，您需要一组可以操作的文档。本指南将使用一个代表世界上几个最人口稠密城市的集合文档。作为示例，以下示例文档代表东京：

东京文档

{
    "name": "Tokyo",
    "country": "Japan",
    "continent": "Asia",
    "population": 37.400
}

此文档包含以下信息：

name：城市的名称。
country：城市所在的国家。
continent：城市所在的洲。
population：城市的人口（以百万为单位）。

运行以下 insertMany() 方法，它将同时创建一个名为 cities 的集合并向其中插入三个文档：

db.cities.insertMany([
    {"name": "Tokyo", "country": "Japan", "continent": "Asia", "population": 37.400 },
    {"name": "Delhi", "country": "India", "continent": "Asia", "population": 28.514 },
    {"name": "Seoul", "country": "South Korea", "continent": "Asia", "population": 25.674 }
])

输出将包含分配给新插入对象的对象标识符列表：

输出{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("61646915c66c110cc07ca59b"),
                ObjectId("61646915c66c110cc07ca59c"),
                ObjectId("61646915c66c110cc07ca59d")
        ]
}

您可以通过运行不带参数的 find() 方法来验证文档是否正确插入，该方法将检索 cities 集合中的每个文档：

db.cities.find()

输出{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }

最后，使用 createIndex() 方法创建一个索引，确保集合中的每个文档都有唯一的 name 字段值。这将在本指南后面运行事务时测试一致性要求时很有帮助：

db.cities.createIndex( { "name": 1 }, { "unique": true } )

MongoDB 将确认索引已成功创建：

输出{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "commitQuorum" : "votingMembers",
        "ok" : 1,
        . . .
}

至此，您已成功创建了世界上最人口稠密城市的示例文档列表，这些文档将作为测试事务使用的测试数据。接下来，您将学习如何设置事务。

步骤 3 — 创建您的第一个完整事务

本步骤概述如何创建一个包含单个操作的事务，该操作将向上一歩中的示例集合插入一个新文档。

首先打开两个独立的 MongoDB shell 会话。其中一个用于执行事务中的命令，另一个允许您检查事务外部其他数据库用户在不同时间点可见的数据。

注意：为了保持清晰，本指南将使用不同颜色的代码块来区分这两个环境。您用于执行事务的第一个实例将具有蓝色背景，如下所示：

第二个实例将位于事务外部，允许您检查事务内部所做的任何更改对外部客户端的可见性。这个第二个环境将具有红色背景，如下所示：

此时，如果您在两个 shell 会话中查询 cities 集合，都应该列出您之前插入的三个城市。通过在两个 shell 会话中执行 find() 查询来验证这一点，首先从第一个会话开始：

db.cities.find()

输出{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }

然后在您的第二个 shell 会话中运行相同的查询：

db.cities.find()

输出{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }

确认两个会话中的查询输出一致后，尝试向集合中插入一个新文档。但是，您将不使用 insertOne() 方法，而是将其作为事务的一部分插入。

通常，事务不是像本指南所述那样在 MongoDB Shell 中编写和执行的。更常见的是，事务由外部应用程序使用。为了确保其运行的事务保持 atomic、consistent、isolated 和 durable，应用程序必须启动一个 session。

在 MongoDB 中，session 是由应用程序通过适当的 MongoDB driver 管理的数据库对象。这允许 driver 将一系列数据库语句相互关联，从而共享上下文，并可以作为一组应用额外的配置，例如启用事务的使用。单个 session 内部发生的事情可能不会立即对外部世界可见，本步骤将对此进行说明。

本教程没有设置外部应用程序，而是概述了在 MongoDB shell 中直接使用简化 JavaScript 语法处理事务所需的概念和单个步骤。

注意：您可以在官方 MongoDB 文档中了解更多关于使用不同编程语言处理事务的信息。官方文档中描述的代码示例将比本指南中的更复杂，但两种方法遵循相同的原则。

尽管本指南概述了如何通过 MongoDB shell 而不是在应用程序中使用事务，但为了将一组操作作为事务执行，仍需要启动一个 session。您可以使用以下命令启动 session：

var session = db.getMongo().startSession()

此命令创建一个 session 变量，用于存储 session 对象。在接下来的示例中，每次引用 session 对象时，都指的是您刚刚启动的 session。

有了这个 session 对象，您可以通过调用 startTransaction 方法来启动事务，如下所示：

session.startTransaction({
    "readConcern": { "level": "snapshot" },
    "writeConcern": { "w": "majority" }
})

请注意，此方法是在 session 变量上调用的，而不是像上一歩中的命令那样在 db 上调用。

startTransaction() 方法接受两个选项：readConcern 和 writeConcern。writeConcern 设置可以接受几个选项，但本示例仅包含 w 选项，该选项要求集群确认事务的写操作已被集群中指定数量的节点接受。本示例不是使用单个数字，而是指定只有当集群中的 majority 节点确认写操作时，事务才被视为保存成功。

假设您启动了一个事务，但在此之后另一个用户在集群的另一个节点上向您使用的集合添加了一个文档。您的交易应该读取这个新数据，还是只读取事务启动时节点上写入的数据？设置 readConcern 级别允许您指定提交事务时事务应该读取哪些数据。将它设置为 snapshot 意味着事务将读取集群中大多数节点已提交的数据快照。

请注意，设置事务的 readConcern 级别要求您将 writeConcern 设置为 majority。这些读写关注点的值在大多数情况下是安全的默认值。除非您对性能和副本集中的写确认有非常特殊的要求，否则它们提供了可靠的数据持久性保证。您可以在官方 MongoDB 文档中了解更多 MongoDB 为事务提供的不同写关注点和读关注点。

如果 startTransaction 方法执行正确，它不会返回任何输出。如果此方法成功，您将处于运行中的事务内部，并可以开始执行将成为事务一部分的语句。

警告： 默认情况下，MongoDB 将自动中止运行超过 60 秒的事务。其原因是事务并非设计为在 MongoDB shell 中交互式构建，而是用于真实世界的应用程序。

因此，如果您不在 60 秒时间限制内执行每个命令，在跟随本教程时可能会遇到意外错误。如果您遇到如下错误，这意味着 MongoDB 已因超时而中止事务：

错误消息

Error: error: {
        "errorLabels" : [
                "TransientTransactionError"
        ],
        "operationTime" : Timestamp(1634032826, 1),
        "ok" : 0,
        "errmsg" : "Transaction 1 has been aborted.",
        "code" : 251,
        "codeName" : "NoSuchTransaction",
        "$clusterTime" : {
                "clusterTime" : Timestamp(1634032826, 1),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
}

如果发生这种情况，您必须通过运行 abortTransaction() 方法将事务标记为已终止，如下所示：

session.abortTransaction()

然后，您必须使用之前运行的相同的 startTransaction() 方法重新初始化事务：

session.startTransaction({
    "readConcern": { "level": "snapshot" },
    "writeConcern": { "w": "majority" }
})

之后，您需要从头开始重新执行事务中的每个语句。考虑到这一点，您可以先阅读本步骤的其余内容，然后在更好地理解相关概念后，在 60 秒时间限制内执行命令，这可能会有所帮助。

在运行的事务中工作时，您作为事务一部分运行的任何语句都必须在您之前创建的 session 变量表示的 session 共享上下文中。

同样，在运行的事务中工作时，创建一个表示您想在 session 上下文中处理的集合的另一个变量可能会有所帮助。以下操作将通过从 test 数据库返回 cities 集合来创建一个名为 cities 的变量。但是，它不是直接从 db 对象获取，而是引用 session 对象，以确保该变量表示运行 session 上下文中的 cities 集合：

var cities = session.getDatabase('test').getCollection('cities')

从现在直到您提交事务，您可以像使用 db.cities 引用 cities 集合一样使用 cities 变量。这个新分配的变量将保证您在 session 中运行语句，同样也在启动的事务中。

通过检查该对象是否可以用于查找集合中的文档来测试这一点：

cities.find()

由于数据尚未更改，该命令将返回与之前相同的文档列表：

输出{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }

接下来，作为运行事务的一部分，向集合中插入一个代表纽约市的文档。使用 insertOne 方法，但在其上执行 cities 变量以确保它将在 session 中运行：

cities.insertOne({"name": "New York", "country": "United States", "continent": "North America", "population": 18.819 })

MongoDB 将返回成功消息：

输出{
        "acknowledged" : true,
        "insertedId" : ObjectId("6164849d53abeea9d9dd10cf")
}

如果您再次执行 cities.find()，您会注意到新插入的文档在同一 session 中立即可见：

cities.find()

输出{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }
{ "_id" : ObjectId("6164822453abeea9d9dd10cf"), "name" : "New York", "country" : "United States", "continent" : "North America", "population" : 18.819 }

但是，如果您在第二个 MongoDB shell 实例中运行 db.cities.find()，代表纽约的文档将不存在：

db.cities.find()

输出{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }

原因是插入语句已在运行的事务中执行，但事务本身尚未提交。此时，事务仍然可以成功并持久化数据，或者失败，这将撤销所有更改，并使数据库恢复到启动事务之前的状态。

要提交事务并将插入的文档永久保存到数据库，请在 session 对象上运行 commitTransaction 方法：

session.commitTransaction()

与 startTransaction 一样，如果成功，此命令不会产生输出。

现在，在两个 MongoDB shell 中列出 cities 集合中的文档。从运行 session 中的 cities 变量查询开始：

cities.find()

输出{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }
{ "_id" : ObjectId("6164822453abeea9d9dd10cf"), "name" : "New York", "country" : "United States", "continent" : "North America", "population" : 18.819 }

然后在事务外部运行的第二个 shell 中查询 cities 集合：

db.cities.find()

输出{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }
{ "_id" : ObjectId("6164849d53abeea9d9dd10cf"), "name" : "New York", "country" : "United States", "continent" : "North America", "population" : 18.819 }

这一次，新插入的文档在 session 内部和外部都可见。事务已成功提交并结束，持久化了它对数据库所做的更改。现在，您可以在事务外部和所有后续事务内部访问 New York 对象。

现在您知道如何启动和执行事务，可以继续下一步，该步骤概述了在启动事务后如何中止事务以回滚执行之前所做的任何更改。请确保保持两个 MongoDB shell 环境打开，因为您将在本教程的剩余部分继续使用它们。

步骤 4 — 终止事务

本步骤与前一个步骤类似，都以相同方式启动事务。不过，本步骤介绍如何终止事务而不是提交更改。这样做时，事务引入的所有更改都会被回滚，数据库将恢复到之前的状态，就好像事务从未发生过一样。

按照前一个步骤操作后，集合中将有四个城市，包括新添加的代表 New York 的记录。

在第一个 MongoDB shell 中，启动会话并再次将其赋值给 session 变量：

var session = db.getMongo().startSession()

然后启动事务：

session.startTransaction({
    "readConcern": { "level": "snapshot" },
    "writeConcern": { "w": "majority" }
})

同样，如果成功，此方法不会返回任何输出。如果成功，你将处于运行中的事务内。

你需要在会话上下文中访问 cities 集合。为此，可以再次创建一个 cities 变量来表示会话内的 cities 集合：

var cities = session.getDatabase('test').getCollection('cities')

从现在起，你可以使用 cities 变量在会话上下文中操作 cities 集合。

现在事务已启动，作为运行中事务的一部分，向该集合插入另一个新文档。本示例中的文档将代表 Buenos Aires。使用 insertOne 方法，但要在 cities 变量上执行它，以确保在会话中运行：

cities.insertOne({"name": "Buenos Aires", "country": "Argentina", "continent": "South America", "population": 14.967 })

MongoDB 将返回成功消息：

Output{
        "acknowledged" : true,
        "insertedId" : ObjectId("6164887e322518cf706858b5")
}

接下来，运行 cities.find() 查询：

cities.find()

注意，新插入的文档在同一会话的事务中立即可见：

Output{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }
{ "_id" : ObjectId("6164849d53abeea9d9dd10cf"), "name" : "New York", "country" : "United States", "continent" : "North America", "population" : 18.819 }
{ "_id" : ObjectId("6164887e322518cf706858b5"), "name" : "Buenos Aires", "country" : "Argentina", "continent" : "South America", "population" : 14.967 }

然而，如果你查询第二个 MongoDB shell 实例中的 cities 集合（该实例不在事务中运行），返回的列表不会包含 Buenos Aires 文档，因为事务尚未提交：

db.cities.find()

Output{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }
{ "_id" : ObjectId("6164849d53abeea9d9dd10cf"), "name" : "New York", "country" : "United States", "continent" : "North America", "population" : 18.819 }

假设你犯了错误，不再想提交事务。相反，你想取消在此会话中运行的所有语句并完全终止事务。为此，运行 abortTransaction() 方法：

session.abortTransaction()

abortTransaction() 方法告诉 MongoDB 丢弃事务中引入的所有更改，并将数据库恢复到之前的状态。与 startTransaction 和 commitTransaction 一样，如果成功，此命令不会输出任何内容。

成功终止事务后，在两个 MongoDB shell 中列出 cities 集合的文档。首先，在运行中的会话中运行以下操作：

cities.find()

Output{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }
{ "_id" : ObjectId("6164849d53abeea9d9dd10cf"), "name" : "New York", "country" : "United States", "continent" : "North America", "population" : 18.819 }

然后在第二个 shell 实例中运行以下查询，该实例在会话外运行：

db.cities.find()

Output{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }
{ "_id" : ObjectId("6164849d53abeea9d9dd10cf"), "name" : "New York", "country" : "United States", "continent" : "North America", "population" : 18.819 }

两个列表中都没有 Buenos Aires。在文档插入后但事务提交前终止事务，就好像从未插入过一样。

在本步骤中，你学习了如何终止事务并回滚其存在期间引入的更改。不过，并非总是像这样手动终止事务。通常，MongoDB 在事务执行前终止事务的原因是事务内的某个操作导致了错误。

步骤 5 — 由于错误中止事务

这一步与前一步类似，但这次你将了解当事务内部执行的任何语句发生错误时会发生什么。

此时你应该仍然有两个打开的 shell 会话。你的 collection 中有四个城市，包括新添加的代表 New York 的文档。然而，代表 Buenos Aires 的文档并未插入，因为你在前一步中止了事务而被丢弃。

在第一个 MongoDB shell 中，启动 session 并将其赋值给 session 变量：

var session = db.getMongo().startSession()

然后启动事务：

session.startTransaction({
    "readConcern": { "level": "snapshot" },
    "writeConcern": { "w": "majority" }
})

再次创建 cities 变量：

var cities = session.getDatabase('test').getCollection('cities')

接下来，作为正在运行的事务的一部分，向该 collection 中插入另一个新文档。此示例插入一个代表日本大阪的文档：

cities.insertOne({"name": "Osaka", "country": "Japan", "continent": "Asia", "population": 19.281 })

MongoDB 将返回成功消息：

Output{
        "acknowledged" : true,
        "insertedId" : ObjectId("61648bb3322518cf706858b6")
}

新插入的城市将在事务内部立即可见：

cities.find()

Output{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }
{ "_id" : ObjectId("6164849d53abeea9d9dd10cf"), "name" : "New York", "country" : "United States", "continent" : "North America", "population" : 18.819 }
{ "_id" : ObjectId("61648bb3322518cf706858b6"), "name" : "Osaka", "country" : "Japan", "continent" : "Asia", "population" : 19.281 }

然而，在第二个 shell 中（事务外部），Osaka 文档不可见：

db.cities.find()

Output{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }
{ "_id" : ObjectId("6164849d53abeea9d9dd10cf"), "name" : "New York", "country" : "United States", "continent" : "North America", "population" : 18.819 }

事务仍在运行，可以用于对数据库进行进一步更改。

运行以下操作，尝试作为此事务的一部分向 collection 中插入另一个文档。此命令将创建另一个代表纽约市的文档。然而，由于你在设置此 collection 时对 name 字段应用了唯一性约束，并且该 collection 中已经有一个 name 字段值为 New York 的文档，此 insertOne 操作将与该约束冲突并导致错误：

cities.insertOne({"name": "New York", "country": "United States", "continent": "North America", "population": 18.819 })

MongoDB 将返回错误消息，指出此操作违反了唯一性约束：

OutputWriteError({
        "index" : 0,
        "code" : 11000,
        "errmsg" : "E11000 duplicate key error collection: test.cities index: name_1 dup key: { name: \"New York\" }",
        "op" : {
                "_id" : ObjectId("61648bdc322518cf706858b7"),
                "name" : "New York",
                "country" : "United States",
                "continent" : "North America",
                "population" : 18.819
        }
})
. . .

此输出表明，这个代表纽约的新文档并未插入到数据库中。然而，这并未解释你之前作为事务一部分添加的代表大阪的文档发生了什么。

假设尝试添加第二个纽约文档是一个错误，但你确实打算保留大阪文档在 collection 中。你可能会尝试提交事务以持久化大阪文档：

session.commitTransaction()

MongoDB 将不允许此操作，而是抛出错误：

Outputuncaught exception: Error: command failed: {
        "errorLabels" : [
                "TransientTransactionError"
        ],
        "operationTime" : Timestamp(1633979403, 1),
        "ok" : 0,
        "errmsg" : "Transaction 0 has been aborted.",
        "code" : 251,
        "codeName" : "NoSuchTransaction",
        "$clusterTime" : {
                "clusterTime" : Timestamp(1633979403, 1),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
}
. . .

事务内部发生错误时，MongoDB 会自动中止事务。而且，由于事务以全有或全无的方式执行，在这种情况下事务内部的任何更改都不会被持久化。添加第二个代表纽约的文档导致的错误使 MongoDB 中止了事务并丢弃了代表大阪的文档。

你可以通过在两个 shell 中运行 find() 查询来验证这一点。在第一个 shell 中，在 session 上下文中运行查询：

cities.find()

Output{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }
{ "_id" : ObjectId("6164849d53abeea9d9dd10cf"), "name" : "New York", "country" : "United States", "continent" : "North America", "population" : 18.819 }

然后在第二个 shell 中，在 session 外部运行针对 db.cities 的 find()：

db.cities.find()

Output{ "_id" : ObjectId("61646915c66c110cc07ca59b"), "name" : "Tokyo", "country" : "Japan", "continent" : "Asia", "population" : 37.4 }
{ "_id" : ObjectId("61646915c66c110cc07ca59c"), "name" : "Delhi", "country" : "India", "continent" : "Asia", "population" : 28.514 }
{ "_id" : ObjectId("61646915c66c110cc07ca59d"), "name" : "Seoul", "country" : "South Korea", "continent" : "Asia", "population" : 25.674 }
{ "_id" : ObjectId("6164849d53abeea9d9dd10cf"), "name" : "New York", "country" : "United States", "continent" : "North America", "population" : 18.819 }

两者都不会显示 Osaka 或重复的 New York 条目。当 MongoDB 自动中止事务时，它还确保所有更改都被回滚。大阪在事务上下文中短暂可见，但从未在事务外部对其他数据库用户可用。

结论

通过阅读本文，您已经熟悉了 MongoDB 中的 ACID 原则和多文档事务。您启动了一个事务，作为该事务的一部分插入了文档，并了解了文档在事务内部和外部何时变得可见。您学习了如何提交事务、如何中止事务并回滚任何更改，以及事务内部发生错误时会发生什么。

掌握了这些新技能后，您可以在需要时利用多文档事务的 ACID 保证来开发应用程序。不过，请记住，MongoDB 是一个面向文档的数据库。在许多场景中，文档模型本身以及仔细的 schema 设计，就可以减少对多文档事务的需求。

本教程仅对 MongoDB 中的事务进行了简要介绍。我们鼓励您学习官方的 MongoDB 文档，以深入了解事务的工作原理。

感谢与 Community 一起学习。请查看我们的计算、存储、网络和管理数据库产品。

了解更多我们的产品

教程系列：如何使用 MongoDB 管理数据

MongoDB 是一个面向文档的 NoSQL 数据库管理系统 (DBMS)。与传统的关系型 DBMS 不同，后者将数据存储在由行和列组成的表中，MongoDB 将数据存储在称为 documents 的类似 JSON 的结构中。

本系列提供了 MongoDB 功能的概述，以及如何使用它们来管理和交互您的数据。

MongoDB

NoSQL

Databases

访问系列页面

浏览系列：16 个教程

1/16 - 面向文档数据库简介
2/16 - 如何使用 MongoDB 访问控制
3/16 - 如何使用 MongoDB Shell

软件工程师，Makimo CTO

See author profile

定制软件开发 ◦ Makimo CTO 及联合创始人。我是一名软件工程师和极客。我喜欢让不可能的事情成为可能。而且我需要茶。

相关问答