---

MongoDB 入门教程：从零开始掌握 NoSQL 数据存储

引言：踏入 NoSQL 的世界

在传统的数据库世界里，关系型数据库（如 MySQL, PostgreSQL, SQL Server）统治了数十年。它们以其严格的结构化模式（Schema）和强大的事务处理能力而闻名。然而，随着互联网应用的发展，数据变得越来越复杂、非结构化和海量，传统的固定模式有时显得不够灵活，难以应对快速变化的需求和大规模的分布式场景。

正是在这样的背景下，NoSQL（Not Only SQL）数据库应运而生。NoSQL 数据库提供了一种不同于关系型数据库的数据存储方式，它们通常具有灵活的模式、更高的可伸缩性和更好的性能，适用于特定的应用场景。MongoDB 是最流行的 NoSQL 数据库之一，属于文档型数据库。

本教程将带你从零开始，详细了解 MongoDB 的核心概念、安装、基本操作以及一些重要特性，帮助你快速入门并掌握这个强大的数据库。

第一部分：认识 MongoDB – 它是什么以及为何选择它？

1.1 什么是 MongoDB？

MongoDB 是一个开源的、高性能、高可用性、易于扩展的面向文档（Document-Oriented）的数据库。与关系型数据库将数据存储在表格中不同，MongoDB 将数据存储在被称为“文档”（Document）的 JSON-like（更准确地说是 BSON）结构中。

• 面向文档： 数据以文档形式存储，文档是一个由键值对组成的集合。
• 无模式（Schema-less）： 同一个集合中的文档可以有不同的结构，这提供了极大的灵活性，特别适合快速开发和处理结构多变的数据。
• 高性能： 支持索引，提供丰富的查询功能。
• 高可用性： 通过副本集（Replica Set）实现自动故障转移。
• 易于扩展： 通过分片（Sharding）实现横向扩展，处理海量数据。

1.2 为什么选择 MongoDB？

选择 MongoDB 通常是基于以下考虑：

• 灵活的模式： 应用需求变化快，数据结构不固定，MongoDB 可以轻松应对。
• 快速开发： 无需预先定义复杂的表结构，可以直接存储数据。
• 易于理解： 文档结构与许多编程语言的数据结构（如 JSON 对象）非常相似，开发者容易上手。
• 高吞吐量和低延迟： 适用于需要快速读写数据的应用。
• 云原生友好： MongoDB Atlas 等云服务使得部署和管理变得简单。
• 强大的社区和生态系统： 拥有庞大的用户基础、丰富的驱动程序和工具。

1.3 MongoDB 与关系型数据库的对比（概念映射）

为了方便从关系型数据库转型的用户理解，可以将 MongoDB 的一些概念类比为关系型数据库：

关系型数据库（如 MySQL）	MongoDB	描述
数据库 (Database)	数据库 (Database)	物理上隔离的数据集合容器
表 (Table)	集合 (Collection)	存储文档的容器，类似于表的概念
行 (Row)	文档 (Document)	集合中的一条记录，类似于表中的一行
列 (Column)	字段 (Field)	文档中的一个键值对，类似于表中的一个列
主键 (Primary Key)	_id 字段	每个文档唯一的标识符，MongoDB 自动生成
JOIN 操作	内嵌 (Embedding) / 关联 (Referencing)	处理数据之间的关系，通常通过文档内嵌或存储关联文档的 _id
模式 (Schema)	无模式 / 动态模式	集合中的文档结构可以不一致

理解这些概念映射，将有助于你更快地适应 MongoDB 的数据模型。

第二部分：安装和启动 MongoDB

在使用 MongoDB 之前，需要先在你的系统上安装它。MongoDB 提供了适用于各种操作系统的安装包，包括 Windows、macOS 和 Linux。

2.1 获取 MongoDB

访问 MongoDB 官方网站的下载中心：https://www.mongodb.com/try/download/community

选择适合你操作系统的版本。对于初学者和开发使用，通常选择 Community Server 版本。

2.2 安装步骤（以 Ubuntu/Debian Linux 为例，其他系统请参考官方文档）

以下是基于 apt 包管理器的安装步骤，对于其他 Linux 发行版或操作系统，请查阅官方文档以获取最准确的指南。

1. 导入 MongoDB 公钥：
   bash
curl -fsSL https://www.mongodb.org/static/pgp/server/6.0/pgp-key.asc | sudo gpg --dearmor -o /usr/share/keyrings/mongodb-server-6.0.gpg
   (注: 这里的 6.0 是版本号，请根据你下载的版本修改)

2. 创建 MongoDB 的 list 文件：
   bash
echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-6.0.gpg ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
   (注: 这里的 focal 是你的 Ubuntu 版本代号，6.0 是 MongoDB 版本号，请根据实际情况修改)

3. 更新 apt 软件包列表：
   bash
sudo apt update

4. 安装 MongoDB：
   bash
sudo apt install mongodb-org

5. 启动 MongoDB 服务：
   bash
sudo systemctl start mongod

6. 验证服务是否启动：
   bash
sudo systemctl status mongod
   如果看到 “active (running)” 字样，说明服务已成功启动。

7. 设置 MongoDB 开机自启 (可选):
   bash
sudo systemctl enable mongod

2.3 连接到 MongoDB Shell

安装完成后，可以通过 MongoDB Shell 与数据库进行交互。打开终端或命令提示符，输入：

bash
mongosh

这将连接到本地运行的 MongoDB 实例。你将看到类似以下的提示符：

“`
Current Mongosh version: 2.0.1
Using MongoDB: 6.0.8
Using Node.js: v18.16.0

test>
“`

test> 表示当前连接的数据库是 test。如果本地没有运行 MongoDB 服务，mongosh 将无法连接。

至此，你已经成功安装并连接到了 MongoDB 数据库。

第三部分：MongoDB 基本概念与 Shell 操作

现在我们来深入了解 MongoDB 的一些核心概念，并通过 Shell 进行实际操作。

3.1 数据库、集合与文档的操作

• 列出数据库：
  javascript
show dbs
  这将显示当前 MongoDB 实例中的所有数据库。新安装的实例通常只有 admin 和 local 等系统数据库。

• 切换或创建数据库：
  javascript
use mynewdatabase
  如果 mynewdatabase 不存在，MongoDB 会在你向其中插入数据时自动创建它。如果存在，则切换到该数据库。Shell 提示符会随之改变。

• 查看当前数据库：
  javascript
db
  将显示当前你所在的数据库名称。

• 列出当前数据库中的集合：
  javascript
show collections
  对于一个新数据库，这将是空的。

3.2 文档（Document）

文档是 MongoDB 的核心数据单元。它是一个有序的键值对集合，类似于 JSON 对象。

json
{
"_id": ObjectId("..."), // 每个文档自动生成的唯一 ID
"name": "Alice",
"age": 30,
"city": "New York",
"interests": ["reading", "coding", "hiking"],
"address": { // 嵌套文档
"street": "123 Main St",
"zip": "10001"
},
"isActive": true,
"createdAt": ISODate("2023-10-26T10:00:00Z") // BSON 数据类型
}

• _id 字段： 每个文档必须有一个 _id 字段，它在集合中唯一标识文档。如果插入文档时没有指定 _id，MongoDB 会自动生成一个 ObjectId 作为其值。ObjectId 是一个 12 字节的唯一标识符，包含时间戳、机器 ID、进程 ID 和一个计数器。
• 键（Key）： 键是字符串。
• 值（Value）： 值可以是各种 BSON 数据类型，包括字符串、整数、浮点数、布尔值、数组、内嵌文档、日期、二进制数据等。BSON (Binary JSON) 是 JSON 的二进制序列化格式，扩展了 JSON 的数据类型支持。

3.3 集合（Collection）

集合是文档的分组，类似于关系型数据库中的表。同一个集合中的文档结构可以不同，这是 MongoDB 灵活模式的关键。

第四部分：CRUD 操作 – 数据的增删改查

这是数据库操作中最核心的部分。MongoDB Shell 提供了一系列方法来执行 CRUD 操作。所有这些方法都通过 db.collectionName 对象调用。

假设我们现在在 mynewdatabase 数据库下，创建一个名为 users 的集合来存储用户数据。

javascript
use mynewdatabase

4.1 创建 (Create) – 插入文档

• 插入单个文档：insertOne()
javascript
db.users.insertOne({
name: "Alice",
age: 30,
city: "New York"
})
  执行结果会返回一个对象，包含插入的 _id。

  json
{
acknowledged: true,
insertedId: ObjectId("...")
}

• 插入多个文档：insertMany()
insertMany() 方法接受一个文档数组作为参数。
  javascript
db.users.insertMany([
{ name: "Bob", age: 25, city: "London" },
{ name: "Charlie", age: 35, city: "Paris", occupation: "Engineer" },
{ name: "David", age: 28, city: "New York" }
])
  返回结果包含每个插入文档的 _id。

  json
{
acknowledged: true,
insertedIds: {
'0': ObjectId("..."),
'1': ObjectId("..."),
'2': ObjectId("...")
}
}

  注意：Charlie 的文档比 Alice 和 Bob 的多了一个 occupation 字段，这体现了模式的灵活性。

4.2 读取 (Read) – 查询文档

查询是数据库操作中最常用的功能。find() 方法用于查询集合中的文档。

• 查询所有文档：find()
javascript
db.users.find()
  这将返回 users 集合中的所有文档。默认情况下，结果会以比较友好的格式打印出来。

• 查询指定条件的文档：find(query)
find() 的第一个参数是一个查询条件对象，用于指定匹配文档的规则。
  “`javascript
  // 查询 age 等于 30 的用户
  db.users.find({ age: 30 })

  // 查询 city 是 “New York” 的用户
  db.users.find({ city: “New York” })

  // 查询 name 是 “Bob” 并且 age 是 25 的用户
  db.users.find({ name: “Bob”, age: 25 })
  “`

• 查询操作符 (Query Operators)： MongoDB 提供了丰富的查询操作符来构建更复杂的查询。操作符以 $ 开头。

  • 比较操作符： $eq (等于), $ne (不等于), $gt (大于), $lt (小于), $gte (大于等于), $lte (小于等于), $in (在数组中), $nin (不在数组中)。
    “`javascript
    // 查询 age 大于 30 的用户
    db.users.find({ age: { $gt: 30 } })

    // 查询 age 在 25 到 35 之间的用户 (含边界)
    db.users.find({ age: { $gte: 25, $lte: 35 } })

    // 查询 city 不是 “London” 的用户
    db.users.find({ city: { $ne: “London” } })

    // 查询 city 是 “New York” 或 “Paris” 的用户
    db.users.find({ city: { $in: [“New York”, “Paris”] } })
    - **逻辑操作符：** `$and`, `$or`, `$not`, `$nor`。javascript
    // 查询 age 小于 30 或者 city 是 “London” 的用户
    db.users.find({ $or: [{ age: { $lt: 30 } }, { city: “London” }] })

    // 查询 age 大于 20 并且 city 不是 “Paris” 的用户 ($and 通常可以省略，但复杂时明确写出更清晰)
    db.users.find({ $and: [{ age: { $gt: 20 } }, { city: { $ne: “Paris” } }] })
    // 等价于: db.users.find({ age: { $gt: 20 }, city: { $ne: “Paris” } })
    - **元素操作符：** `$exists` (字段是否存在), `$type` (字段类型)。javascript
    // 查询存在 occupation 字段的用户
    db.users.find({ occupation: { $exists: true } })

    // 查询 name 字段类型是 string 的用户 (类型编号 2 代表字符串)
    db.users.find({ name: { $type: 2 } })
    - **数组操作符：** `$all` (包含所有指定元素), `$elemMatch` (数组中至少有一个元素匹配所有指定条件), `$size` (数组长度)。
假设有一个文档 `{ hobbies: ["reading", "coding", "music"] }`javascript
    // 查询 hobbies 数组中包含 “reading” 的文档
    db.collection.find({ hobbies: “reading” }) // 直接匹配数组中的元素

    // 查询 hobbies 数组同时包含 “reading” 和 “music” 的文档
    db.collection.find({ hobbies: { $all: [“reading”, “music”] } })

    // 查询 tags 数组中，有一个元素同时满足 { name: “mongo”, score: { $gt: 5 } } 的文档
    // 文档示例: { _id: 1, tags: [ { name: “mongo”, score: 10 }, { name: “db”, score: 3 } ] }
    db.collection.find({ tags: { $elemMatch: { name: “mongo”, score: { $gt: 5 } } } })

    // 查询 hobbies 数组长度为 3 的文档
    db.collection.find({ hobbies: { $size: 3 } })
    - **内嵌文档查询：** 使用点号(`.`)来访问内嵌文档的字段。
假设文档结构是 `{ address: { city: "...", zip: "..." } }`javascript
    // 查询居住在 zip 为 “10001” 的城市用户
    db.users.find({ “address.zip”: “10001” })
    “`

• 投影 (Projection)：指定返回的字段
  find() 的第二个参数是一个投影对象，用于指定查询结果中包含或排除哪些字段。1 表示包含，0 表示排除。_id 字段默认包含，除非显式排除 (_id: 0)。
  “`javascript
  // 只返回 name 和 city 字段 (_id 默认包含)
  db.users.find({}, { name: 1, city: 1 })

  // 返回 name 和 city 字段，但不包含 _id
  db.users.find({}, { name: 1, city: 1, _id: 0 })

  // 返回所有字段，但排除 age (不能混合使用包含和排除，_id 除外)
  db.users.find({}, { age: 0 })
  “`

• 链式操作 (Chaining)：sort(), limit(), skip()
find() 返回一个游标 (cursor)，可以在其上链式调用方法来进一步处理结果。

  • sort({ field: 1/-1 }): 按字段排序，1 为升序，-1 为降序。
  • limit(n): 限制返回文档的数量。
  • skip(n): 跳过指定数量的文档。
    “`javascript
    // 查询所有用户，按年龄降序排序，只返回前 2 个
    db.users.find().sort({ age: -1 }).limit(2)

  // 查询居住在 New York 的用户，按姓名升序排序，跳过第一个，返回接下来的 5 个
  db.users.find({ city: “New York” }).sort({ name: 1 }).skip(1).limit(5)
  “`

• 查询单个文档：findOne()
findOne() 返回满足条件的第一个文档，而不是游标。如果没有匹配文档，返回 null。
  javascript
// 查询 name 是 "Alice" 的用户文档
db.users.findOne({ name: "Alice" })

4.3 更新 (Update) – 修改文档

更新操作用于修改集合中已有的文档。MongoDB 提供了多种更新操作符。

• 更新单个文档：updateOne(query, update, options)
  更新匹配查询条件的第一个文档。
  javascript
// 将 Alice 的年龄更新为 31
db.users.updateOne(
{ name: "Alice" }, // 查询条件
{ $set: { age: 31 } } // 更新操作符: $set 用于设置字段值
)
  结果会显示匹配和修改的数量：{ acknowledged: true, matchedCount: 1, modifiedCount: 1 }

  • $set: 设置字段值。如果字段不存在，则创建。
    javascript
// 给 Charlie 添加 city 字段
db.users.updateOne(
{ name: "Charlie" },
{ $set: { city: "Paris" } } // 如果 Charlie 没有 city 字段，则添加
)
  • $inc: 增加或减少字段值 (仅适用于数字类型)。
    javascript
// 给 Bob 的年龄增加 1
db.users.updateOne(
{ name: "Bob" },
{ $inc: { age: 1 } }
)
  • $unset: 删除字段。
    javascript
// 删除 Charlie 的 occupation 字段
db.users.updateOne(
{ name: "Charlie" },
{ $unset: { occupation: "" } } // 值可以是任意，通常用 "" 或 1
)

  • 数组更新操作符： $push, $addToSet, $pop, $pull 等。
    假设文档 { _id: 1, tags: ["a", "b"] }
    “`javascript
    // $push: 向数组末尾添加一个元素
    db.collection.updateOne({ _id: 1 }, { $push: { tags: “c” } }) // tags: [“a”, “b”, “c”]

    // $addToSet: 向数组添加一个元素，仅当该元素不在数组中时
    db.collection.updateOne({ _id: 1 }, { $addToSet: { tags: “b” } }) // tags: [“a”, “b”] (因为 “b” 已存在)
    db.collection.updateOne({ _id: 1 }, { $addToSet: { tags: “d” } }) // tags: [“a”, “b”, “d”]

    // $pop: 删除数组的第一个 ($-1) 或最后一个 ($1) 元素
    db.collection.updateOne({ _id: 1 }, { $pop: { tags: 1 } }) // 删除最后一个元素 “d”

    // $pull: 删除数组中所有匹配指定条件的元素
    db.collection.updateOne({ _id: 1 }, { $pull: { tags: “a” } }) // 删除所有值为 “a” 的元素
    “`

• 更新多个文档：updateMany(query, update, options)
  更新匹配查询条件的所有文档。
  javascript
// 给所有年龄大于 28 的用户添加 status 字段，值为 "active"
db.users.updateMany(
{ age: { $gt: 28 } },
{ $set: { status: "active" } }
)
  结果会显示匹配和修改的数量：{ acknowledged: true, matchedCount: 3, modifiedCount: 3 }

• Upsert：插入或更新
  在 updateOne 或 updateMany 中，可以传递 { upsert: true } 选项。如果查询条件匹配到文档，则执行更新；如果没有匹配到文档，则根据查询条件和更新文档新建一个文档。
  javascript
// 查询 name 为 "Eve" 的用户，如果不存在，则插入一个新文档
db.users.updateOne(
{ name: "Eve" },
{ $set: { age: 22, city: "Sydney" } },
{ upsert: true }
)
  如果 Eve 不存在，会插入一个文档 { _id: ..., name: "Eve", age: 22, city: "Sydney" }。

4.4 删除 (Delete) – 删除文档

删除操作用于从集合中移除文档。

• 删除单个文档：deleteOne(query)
  删除匹配查询条件的第一个文档。
  javascript
// 删除 name 是 "David" 的用户
db.users.deleteOne({ name: "David" })
  结果会显示删除的数量：{ acknowledged: true, deletedCount: 1 }

• 删除多个文档：deleteMany(query)
  删除匹配查询条件的所有文档。
  javascript
// 删除所有年龄小于等于 25 的用户
db.users.deleteMany({ age: { $lte: 25 } })
  结果会显示删除的数量：{ acknowledged: true, deletedCount: ... }

• 删除集合中的所有文档：
  javascript
db.users.deleteMany({}) // 使用空查询条件

• 删除集合：drop()
  完全删除一个集合及其所有索引。
  javascript
db.users.drop()
  返回 true 如果删除成功，false 如果集合不存在。

• 删除数据库：dropDatabase()
  删除当前所在的数据库。
  javascript
use mynewdatabase // 确保在要删除的数据库中
db.dropDatabase()
  返回 true 如果删除成功。

第五部分：更进一步 – 索引和聚合框架简介

完成基本的 CRUD 操作后，了解索引和聚合框架将帮助你构建更高效、功能更强大的应用。

5.1 索引 (Indexes)

索引是 MongoDB 中用来提高查询效率的关键。它像书的目录一样，允许数据库快速定位到包含特定字段值的文档，而无需扫描集合中的所有文档。

• 为什么使用索引？

  • 显著加快读取操作（find()）。
  • 支持更高效的排序（sort()）。
  • 支持唯一性约束。

• 创建索引：createIndex(key, options)
key 是一个对象，指定要建立索引的字段和排序方向 (1 升序，-1 降序)。
  “`javascript
  // 在 name 字段上创建升序索引
  db.users.createIndex({ name: 1 })

  // 在 age 字段上创建降序索引
  db.users.createIndex({ age: -1 })

  // 创建复合索引：先按 city 升序，再按 age 降序
  db.users.createIndex({ city: 1, age: -1 })

  // 创建唯一索引：确保 age 字段值唯一 (很少用于 age 字段，这里仅作示例)
  db.users.createIndex({ age: 1 }, { unique: true })
  “`
  注意：对频繁写入的字段创建索引会稍微降低写入性能，因为每次写入都需要更新索引。选择合适的字段创建索引非常重要。

• 查看集合中的索引：getIndexes()
javascript
db.users.getIndexes()
  这将列出集合中已存在的所有索引，包括默认创建的 _id 索引。

• 删除索引：dropIndex() / dropIndexes()
  “`javascript
  // 按索引名称删除 (索引名称通常是字段名和方向组合，如 name_1)
  db.users.dropIndex(“name_1”)

  // 删除所有非 _id 索引
  db.users.dropIndexes()
  “`

5.2 聚合框架 (Aggregation Framework)

聚合框架用于对文档进行高级的数据处理，如分组、计算平均值、连接数据（类似于 JOIN）等。它通过一个由多个阶段组成的管道（Pipeline）来处理文档流。每个阶段对输入文档进行处理，然后将结果传递给下一个阶段。

• 核心概念：管道 (Pipeline)
  管道由一系列阶段（Stage）组成，每个阶段是一个特定的操作符。
  db.collection.aggregate([ stage1, stage2, stage3, ... ])

• 常用聚合阶段：

  • $match: 过滤文档（类似于 find()）。
  • $project: 重塑文档结构，选择或排除字段（类似于 find() 的投影）。
  • $group: 对文档按一个或多个字段进行分组，并对每个组执行聚合计算（如 $sum, $avg, $max, $min）。
  • $sort: 对文档进行排序。
  • $limit: 限制通过管道的文档数量。
  • $skip: 跳过通过管道的文档数量。
  • $lookup: 执行左外连接，将来自另一个集合的文档连接到当前流中的文档。
  • $unwind: 分解文档中的数组字段，为数组中的每个元素输出一个新文档。

• 简单聚合示例：计算每个城市的平均年龄
  javascript
db.users.aggregate([
{
$group: { // 第一阶段: 按 city 字段分组
_id: "$city", // "$fieldName" 表示引用文档中的字段值
count: { $sum: 1 }, // 计算每个组的文档数量
averageAge: { $avg: "$age" } // 计算每个组的 age 平均值
}
},
{
$sort: { // 第二阶段: 按 averageAge 降序排序
averageAge: -1
}
},
{
$project: { // 第三阶段: 重新组织输出字段
_id: 0, // 排除 _id 字段 (这里 _id 是城市名)
city: "$_id", // 将 $group 阶段的 _id (城市名) 映射到 city 字段
numberOfUsers: "$count", // 将 count 映射到 numberOfUsers
avgUserAge: "$averageAge" // 将 averageAge 映射到 avgUserAge
}
}
])
  这个管道首先使用 $group 按城市分组并计算数量和平均年龄，然后使用 $sort 对结果排序，最后使用 $project 格式化输出。

聚合框架功能强大且复杂，深入学习需要更多实践，但上述示例展示了其基本结构和常用阶段。

第六部分：数据建模基础 (Embedding vs. Referencing)

虽然 MongoDB 是无模式的，但这不代表不需要进行数据设计。合理的数据建模对于应用性能和开发效率至关重要。在设计文档结构时，核心决策之一是如何处理数据之间的关系：是内嵌 (Embedding) 还是引用 (Referencing)？

• 内嵌 (Embedding)： 将相关联的数据作为子文档直接存储在父文档内部。
  “`json
  // 示例：用户文档内嵌地址信息
  {
  “_id”: ObjectId(…),
  “name”: “Alice”,
  “address”: {
  “street”: “123 Main St”,
  “city”: “New York”,
  “zip”: “10001”
  }
  }

  // 示例：帖子文档内嵌评论数组 (如果评论数量不多)
  {
  “_id”: ObjectId(…),
  “title”: “My First Post”,
  “content”: “…”,
  “comments”: [
  { “author”: “Bob”, “text”: “Great post!”, “date”: ISODate(…) },
  { “author”: “Charlie”, “text”: “Thanks for sharing.”, “date”: ISODate(…) }
  ]
  }
  “`
  优点： 读取相关数据只需一次查询，性能通常更好，原子性操作更容易（单个文档的更新通常是原子性的）。
  缺点： 文档大小有限制（目前是 16MB），内嵌数组过大时更新可能复杂，数据冗余（如果内嵌的数据在多个地方出现）。
  适用场景： “一对一”或“一对少量”关系，且相关数据经常与父文档一起被访问。

• 引用 (Referencing)： 在一个文档中存储另一个文档的 _id，类似于关系型数据库中的外键。需要通过多次查询来获取完整的相关数据。
  json
// 示例：用户文档引用订单文档 (如果一个用户有很多订单)
// 用户文档
{
"_id": ObjectId("user123"),
"name": "Alice"
// ... 其他用户信息
}
// 订单文档
{
"_id": ObjectId("orderabc"),
"userId": ObjectId("user123"), // 引用用户文档的 _id
"totalAmount": 100,
"items": [...]
}
// 获取 Alice 的订单需要先查询用户文档，然后用其 _id 查询订单集合
  优点： 避免文档大小限制，减少数据冗余，适用于“一对多”或“多对多”关系，相关数据独立更新更容易。
  缺点： 读取相关数据需要多次查询（性能开销），需要应用层处理“连接”逻辑。
  适用场景： “一对多”或“多对多”关系，或者内嵌数据可能变得非常大，或者相关数据需要频繁独立更新。

选择哪种模式取决于你的具体应用场景、数据访问模式和数据量。通常没有绝对的最佳实践，需要权衡利弊。

结论：继续你的 MongoDB 旅程

本教程详细介绍了 MongoDB 的基本概念、安装、连接、CRUD 操作以及索引和聚合框架的初步知识。你现在应该对 MongoDB 是什么、如何使用它进行基本的数据操作有了一个清晰的认识。

MongoDB 的世界远不止于此。还有更多高级特性等待你去探索，例如：

• 副本集 (Replica Set)： 实现数据冗余和高可用性。
• 分片 (Sharding)： 实现数据的水平扩展，处理海量数据。
• 事务 (Transactions)： 支持跨多个文档甚至多个集合的原子性操作。
• 地理空间索引和查询： 处理地理位置数据。
• 全文搜索： 内置文本搜索功能。
• 安全性配置： 用户认证、权限控制等。
• 驱动程序： 在各种编程语言中如何使用官方驱动连接和操作 MongoDB。

掌握这些基础知识只是开始。最好的学习方式是动手实践，尝试将这些知识应用于一个实际的项目中。利用 MongoDB Shell 进行练习，阅读官方文档，它们是获取最新、最权威信息的最佳来源。

祝你在 MongoDB 的学习和使用旅程中一切顺利！

---