MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

MongoDB ObjectId与_id字段详解

2022-11-124.3k 阅读

MongoDB ObjectId 基础

在 MongoDB 数据库中，_id 字段是集合中每个文档的唯一标识符。如果在插入文档时没有显式指定 _id 字段，MongoDB 会自动为文档生成一个 ObjectId 并赋值给 _id 字段。ObjectId 是一种特殊的数据类型，它具有以下几个重要的特点和用途。

ObjectId 的结构

ObjectId 是一个 12 字节的 BSON 类型数据，其结构如下：

  1. 时间戳（4 字节）：表示 ObjectId 创建的时间，以秒为单位。这个时间戳精确到秒，从 Unix 纪元开始计算。通过这个时间戳，我们可以大致了解文档创建的时间顺序，并且可以利用它进行基于时间范围的查询。
  2. 机器标识符（3 字节）：这部分标识了生成 ObjectId 的机器。在分布式环境中，不同机器生成的 ObjectId 可以通过这部分进行区分，有助于保证在多台机器同时生成 ObjectId 时的唯一性。
  3. 进程标识符（2 字节）：用于标识生成 ObjectId 的进程。在同一台机器上，如果有多个进程可能生成 ObjectId，通过进程标识符可以进一步区分，确保同一台机器上不同进程生成的 ObjectId 也是唯一的。
  4. 计数器（3 字节）：从一个随机值开始，每生成一个 ObjectId，计数器就会递增。这样在同一秒内，即使是同一台机器上的同一个进程，也能生成不同的 ObjectId。

下面通过一个具体的 ObjectId 示例来详细说明其结构。假设我们有一个 ObjectId 为 5f39f1e60c87f82c3c6d2588：

  1. 时间戳部分：前 8 位 5f39f1e6 转换为十进制是 1608043502，通过在线 Unix 时间戳转换工具可以得知，这个时间戳对应的日期时间大约是 2020-12-15 14:25:02，即该 ObjectId 创建的大致时间。
  2. 机器标识符部分：接下来的 6 位 0c87f8 是机器标识符。
  3. 进程标识符部分：再接下来的 4 位 2c3c 是进程标识符。
  4. 计数器部分：最后的 6 位 6d2588 是计数器的值。

ObjectId 的唯一性保证

由于 ObjectId 的结构包含了时间戳、机器标识符、进程标识符和计数器，它在很大程度上保证了唯一性。在实际应用中，要生成重复的 ObjectId 几乎是不可能的。即使在高并发环境下，同一秒内同一台机器上的同一个进程生成重复 ObjectId 的概率也非常低，因为计数器会不断递增。

在 MongoDB 中使用 ObjectId

创建文档时自动生成 ObjectId

在 MongoDB 中，当我们向集合中插入文档而不指定 _id 字段时，MongoDB 会自动为文档生成一个 ObjectId 并赋值给 _id 字段。下面是一个使用 Python 的 PyMongo 库插入文档并自动生成 ObjectId 的示例：

import pymongo

# 连接 MongoDB 数据库
client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["mydatabase"]
collection = db["mycollection"]

# 插入一个文档，不指定 _id 字段
document = {"name": "John", "age": 30}
result = collection.insert_one(document)

# 打印生成的 ObjectId
print(result.inserted_id)

在上述代码中，我们通过 insert_one 方法向 mycollection 集合中插入了一个文档，没有显式指定 _id 字段。insert_one 方法返回一个 InsertOneResult 对象，通过访问其 inserted_id 属性可以获取到自动生成的 ObjectId。

查询包含特定 ObjectId 的文档

要查询包含特定 ObjectId 的文档，我们需要先将表示 ObjectId 的字符串转换为 ObjectId 类型，然后再进行查询。以下是使用 PyMongo 进行查询的示例：

from bson.objectid import ObjectId

# 连接 MongoDB 数据库
client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["mydatabase"]
collection = db["mycollection"]

# 假设我们已知一个 ObjectId 的字符串表示
object_id_str = "5f39f1e60c87f82c3c6d2588"
object_id = ObjectId(object_id_str)

# 查询包含该 ObjectId 的文档
result = collection.find_one({"_id": object_id})
print(result)

在上述代码中，我们首先从 bson.objectid 模块导入 ObjectId 类。然后将 ObjectId 的字符串表示转换为 ObjectId 类型，最后使用 find_one 方法查询包含该 ObjectId 的文档。

使用 ObjectId 的时间戳进行查询

由于 ObjectId 包含时间戳信息，我们可以利用这一点进行基于时间范围的查询。例如，查询在某个时间之后创建的文档。以下是一个示例：

from bson.objectid import ObjectId
import pymongo
from datetime import datetime, timedelta

# 连接 MongoDB 数据库
client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["mydatabase"]
collection = db["mycollection"]

# 获取当前时间减去一天的时间
one_day_ago = datetime.now() - timedelta(days = 1)
# 将时间转换为时间戳（秒）
one_day_ago_timestamp = int(one_day_ago.timestamp())

# 创建一个最小的 ObjectId，其时间戳为 one_day_ago_timestamp
min_object_id = ObjectId.from_datetime(one_day_ago)

# 查询在一天之内创建的文档
results = collection.find({"_id": {"$gte": min_object_id}})
for result in results:
    print(result)

在上述代码中，我们首先计算出一天前的时间，并获取其时间戳。然后使用 ObjectId.from_datetime 方法创建一个 ObjectId，其时间戳为一天前的时间。最后，我们使用 $gte 操作符查询 _id 大于或等于这个最小 ObjectId 的文档，即查询在一天之内创建的文档。

手动指定 _id 字段

虽然 MongoDB 会自动为文档生成 ObjectId 作为 _id 字段，但在某些情况下，我们可能需要手动指定 _id 字段。

手动指定 _id 的场景

  1. 业务需求：在一些业务场景中，可能已经存在具有唯一性的业务标识符，例如用户的身份证号码、订单编号等。使用这些业务标识符作为 _id 字段可以方便与其他业务系统进行集成，并且在查询时可以直接使用业务标识符进行精确查询，提高查询效率。
  2. 数据迁移和整合：当从其他数据库迁移数据到 MongoDB 时，源数据库中的主键可能需要作为 MongoDB 文档的 _id 字段，以保持数据的一致性和关联性。

手动指定 _id 的注意事项

  1. 唯一性：手动指定的 _id 必须保证在集合中是唯一的。如果插入的文档 _id 与集合中已有的文档 _id 重复，MongoDB 会抛出错误。例如，在使用 PyMongo 插入文档时，如果指定的 _id 已存在，会抛出 DuplicateKeyError 异常。
  2. 数据类型：_id 字段的数据类型可以是多种，不仅仅局限于 ObjectId。常见的数据类型包括字符串、整数等。但是，建议使用与业务需求相匹配且在 MongoDB 中支持高效索引和查询的数据类型。例如，如果 _id 是基于字符串的业务标识符，那么使用字符串类型作为 _id 字段是合理的。

以下是一个手动指定 _id 为字符串类型的示例，使用 PyMongo 插入文档：

import pymongo

# 连接 MongoDB 数据库
client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["mydatabase"]
collection = db["mycollection"]

# 手动指定 _id 为字符串类型
document = {"_id": "user123", "name": "Alice", "age": 25}
result = collection.insert_one(document)
print(result.inserted_id)

在上述代码中，我们手动指定了 _id 字段为字符串 "user123"，然后插入文档。insert_one 方法返回的 inserted_id 就是我们手动指定的 _id 值。

ObjectId 与其他数据类型作为 _id 的比较

性能方面

  1. ObjectId：由于 ObjectId 的结构设计，它在插入操作时性能较好。因为 ObjectId 是按照时间顺序生成的，并且在分布式环境下具有较好的唯一性保证，所以在插入大量文档时，MongoDB 可以更高效地对其进行索引和存储。在查询方面，如果是基于时间范围的查询或者没有特定业务需求的查询，使用 ObjectId 作为 _id 字段可以利用其内部的时间戳信息进行快速查询。例如，查询最近一天创建的文档，通过 ObjectId 的时间戳可以直接构建查询条件，无需额外的时间字段。
  2. 其他数据类型：如果手动指定的 _id 是基于业务需求的字符串或整数等类型，在查询时如果是按照业务标识符进行精确查询，性能也可以很好，因为 MongoDB 可以为这些 _id 字段建立索引。但是，如果查询涉及到范围查询，并且手动指定的 _id 字段没有类似 ObjectId 的内置时间戳等结构，那么可能需要额外的字段来支持范围查询，这可能会增加查询的复杂性和索引的维护成本。

唯一性保证

  1. ObjectId：如前文所述，ObjectId 的结构从多个方面保证了唯一性，在绝大多数情况下，无需额外的逻辑来确保其唯一性。这对于分布式系统和高并发环境下的数据插入非常友好，减少了因为唯一性冲突导致的错误处理。
  2. 其他数据类型：手动指定的 _id 数据类型，如字符串或整数，需要在应用层保证其唯一性。例如，在插入文档前，需要先查询集合中是否已存在相同 _id 的文档。这增加了应用程序的逻辑复杂度，并且在高并发环境下，如果处理不当，可能会出现唯一性冲突。

数据迁移和集成

  1. ObjectId：如果应用程序是全新开发的，并且没有与其他系统的集成需求，使用 ObjectId 作为 _id 字段是一个简单且高效的选择。但是，如果需要与其他系统进行数据迁移或集成，并且其他系统有自己的主键体系，ObjectId 可能不太方便直接使用，可能需要进行额外的映射和转换。
  2. 其他数据类型：当手动指定 _id 字段为与其他系统主键匹配的数据类型时，数据迁移和集成会更加方便。例如，如果从关系型数据库迁移数据到 MongoDB，并且关系型数据库的主键是整数类型，将整数类型作为 MongoDB 文档的 _id 字段可以直接进行数据迁移，无需复杂的转换。

ObjectId 的序列化与反序列化

在实际应用中，我们经常需要将包含 ObjectId 的文档进行序列化（例如转换为 JSON 格式）以便在网络上传输或存储到文件中，同时在接收端需要进行反序列化（将 JSON 数据转换回包含 ObjectId 的文档对象）。

序列化

在 Python 中，使用 json 模块直接序列化包含 ObjectId 的文档会报错，因为 ObjectId 类型不是 JSON 可序列化的。我们可以通过自定义编码器来解决这个问题。以下是一个示例：

import json
from bson.objectid import ObjectId

class JSONEncoder(json.JSONEncoder):
    def default(self, o):
        if isinstance(o, ObjectId):
            return str(o)
        return super().default(o)

document = {"_id": ObjectId("5f39f1e60c87f82c3c6d2588"), "name": "Bob"}
serialized = json.dumps(document, cls = JSONEncoder)
print(serialized)

在上述代码中，我们定义了一个自定义的 JSONEncoder 类，继承自 json.JSONEncoder。在 default 方法中，我们检查对象是否为 ObjectId 类型，如果是，则将其转换为字符串。这样在调用 json.dumps 时，就可以成功序列化包含 ObjectId 的文档。

反序列化

在反序列化时，我们需要将字符串形式的 ObjectId 转换回 ObjectId 类型。以下是一个示例：

import json
from bson.objectid import ObjectId

serialized = '{"_id": "5f39f1e60c87f82c3c6d2588", "name": "Bob"}'
data = json.loads(serialized)
data["_id"] = ObjectId(data["_id"])
print(data)

在上述代码中，我们首先使用 json.loads 将 JSON 字符串反序列化为 Python 字典。然后将字典中 _id 字段的字符串值转换为 ObjectId 类型。

在分布式系统中的 ObjectId

在分布式 MongoDB 环境中，ObjectId 的唯一性和生成机制变得更加重要。

分片集群中的 ObjectId

在 MongoDB 分片集群中，不同的分片可能会同时接收插入请求。由于 ObjectId 包含机器标识符和进程标识符，即使不同分片在同一时间插入文档，生成的 ObjectId 也能保证唯一性。这有助于在分布式环境下高效地插入数据，并且避免了因为 _id 冲突导致的插入失败。

例如，假设我们有一个包含三个分片的 MongoDB 集群，三个分片分别在不同的机器上运行。当客户端向集群插入文档时，每个分片都会根据自己的机器和进程信息生成 ObjectId。由于机器标识符和进程标识符的不同，即使在同一秒内插入文档，生成的 ObjectId 也不会重复。

副本集中的 ObjectId

在 MongoDB 副本集中，主节点负责处理写操作并生成 ObjectId。当主节点将写操作复制到从节点时，从节点会保持 ObjectId 不变。这保证了副本集中数据的一致性，因为所有节点上的文档都具有相同的 ObjectId。

假设我们有一个三节点的副本集，主节点接收到一个插入文档的请求并生成了一个 ObjectId。然后主节点将这个写操作复制到两个从节点，从节点在应用这个写操作时，不会重新生成 ObjectId，而是直接使用主节点生成的 ObjectId。这样在整个副本集中，文档的 ObjectId 是一致的，确保了数据的完整性和一致性。

ObjectId 的索引与优化

ObjectId 索引的特点

MongoDB 默认会为 _id 字段（如果是 ObjectId 类型）创建唯一索引。这个索引对于查询操作非常重要，因为它可以快速定位到特定 ObjectId 的文档。由于 ObjectId 的结构设计，按照 ObjectId 进行查询时，MongoDB 可以利用其内部的时间戳、机器标识符等信息进行高效的索引查找。

例如，当我们执行 collection.find_one({"_id": ObjectId("5f39f1e60c87f82c3c6d2588")}) 这样的查询时，MongoDB 可以直接通过 _id 索引快速定位到对应的文档，而不需要全表扫描。

基于 ObjectId 的查询优化

  1. 范围查询：如前文提到的基于 ObjectId 时间戳的范围查询，可以通过合理构建查询条件来优化性能。例如，查询最近一周创建的文档，可以使用 {"_id": {"$gte": ObjectId.from_datetime(one_week_ago)}} 这样的条件，利用 _id 索引快速筛选出符合条件的文档。
  2. 复合索引：如果查询涉及到 ObjectId 和其他字段，可以考虑创建复合索引。例如，如果经常需要查询特定用户（通过用户 ID 字段）在某个时间范围内创建的文档，可以创建一个包含用户 ID 字段和 _id 字段的复合索引。这样在查询时，MongoDB 可以利用复合索引更高效地定位到文档。以下是使用 PyMongo 创建复合索引的示例：
import pymongo
from bson.objectid import ObjectId
from datetime import datetime, timedelta

# 连接 MongoDB 数据库
client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["mydatabase"]
collection = db["mycollection"]

# 创建复合索引
collection.create_index([("user_id", pymongo.ASCENDING), ("_id", pymongo.ASCENDING)])

# 查询特定用户在最近一周创建的文档
user_id = "user123"
one_week_ago = datetime.now() - timedelta(weeks = 1)
min_object_id = ObjectId.from_datetime(one_week_ago)

results = collection.find({"user_id": user_id, "_id": {"$gte": min_object_id}})
for result in results:
    print(result)

在上述代码中，我们首先使用 create_index 方法创建了一个包含 user_id 和 _id 字段的复合索引。然后在查询时，通过这个复合索引可以更高效地筛选出特定用户在最近一周创建的文档。

总结

ObjectId 作为 MongoDB 中 _id 字段的默认生成类型，具有独特的结构和诸多优点。它在保证唯一性、支持时间范围查询、分布式环境下的应用等方面都表现出色。同时，手动指定 _id 字段在某些业务场景下也有其必要性。了解 ObjectId 与 _id 字段的相关知识，对于优化 MongoDB 应用程序的性能、确保数据的一致性和唯一性以及实现高效的数据查询和存储都至关重要。在实际应用中，我们需要根据具体的业务需求和系统架构，合理选择使用 ObjectId 还是手动指定其他类型的 _id 字段，并充分利用它们的特性进行数据库的设计和优化。无论是在单节点环境还是分布式环境中，正确使用 ObjectId 和 _id 字段都能为 MongoDB 应用带来更好的体验和性能表现。通过对 ObjectId 的序列化与反序列化的掌握，以及在索引优化方面的合理运用，我们可以进一步提升 MongoDB 应用的整体质量和效率。