处理 MongoDB 错误

介绍

在本实验中，你将学习如何处理各种 MongoDB 错误，包括连接错误、写入错误、查询错误和重复键问题。你将探索不同类型的连接错误，例如错误的连接字符串和身份验证问题，并学习如何诊断和解决它们。此外，你还将发现管理写入错误、处理查询错误以及重试失败操作的技术，以确保你的 MongoDB 应用程序的可靠性和健壮性。

Skills Graph

处理连接错误

在这一步骤中，你将学习如何处理 MongoDB 中的连接错误，这些错误在使用数据库时是常见的挑战。连接错误可能由于多种原因发生，例如错误的连接字符串、网络问题或身份验证问题。

理解 MongoDB 连接错误

让我们从探索不同类型的连接错误以及如何诊断和解决它们开始。我们将使用 MongoDB shell (mongosh) 来演示这些场景。

首先，打开终端并启动 MongoDB shell：

mongosh

模拟连接错误

1. 错误的连接字符串

尝试连接到一个不存在的 MongoDB 实例：

mongosh "mongodb://localhost:27018/testdb"

示例输出：

MongoNetworkError: failed to connect to server [localhost:27018] on first connect

当连接字符串指向一个没有运行 MongoDB 服务器的端口或主机时，会发生此错误。

2. 身份验证错误

让我们通过使用错误的用户名或密码来模拟身份验证错误：

mongosh "mongodb://wronguser:wrongpassword@localhost:27017/testdb"

示例输出：

MongoAuthenticationError: Authentication failed

实际中的连接错误处理

为了有效处理连接错误，你应该：

1. 验证连接详细信息
2. 检查网络连接
3. 确保 MongoDB 服务正在运行
4. 验证身份验证凭据

连接错误处理示例

创建一个简单的错误处理脚本（使用 Node.js）来演示稳健的连接管理：

const { MongoClient } = require("mongodb");

const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, {
  serverSelectionTimeoutMS: 5000,
  connectTimeoutMS: 5000
});

async function connectToMongoDB() {
  try {
    await client.connect();
    console.log("Successfully connected to MongoDB");
  } catch (error) {
    console.error("Connection error:", error.message);
    // 实现重试逻辑或回退机制
  } finally {
    await client.close();
  }
}

connectToMongoDB();

此脚本演示了：

• 设置连接超时
• 捕获连接错误
• 记录错误详细信息
• 正确关闭连接

连接错误处理的最佳实践

1. 始终使用连接超时
2. 实现重试机制
3. 记录详细的错误信息
4. 在连接之前验证连接字符串
5. 使用环境变量存储连接详细信息

管理写入错误

在这一步骤中，你将学习如何处理 MongoDB 中的写入错误，这些错误可能在文档插入、更新或删除操作期间发生。理解并管理这些错误对于维护数据完整性和防止数据库中的意外问题至关重要。

理解 MongoDB 中的写入错误

让我们探索不同类型的写入错误，以及如何使用 MongoDB shell (mongosh) 有效地处理它们。

首先，确保你已连接到 MongoDB shell：

mongosh

写入错误的类型

1. 重复键错误

创建一个具有唯一索引的集合来演示重复键错误：

use errorlab
db.users.createIndex({ email: 1 }, { unique: true })
db.users.insertMany([
  { name: "John Doe", email: "[email protected]" },
  { name: "Jane Doe", email: "[email protected]" }
])

示例输出：

MongoError: E11000 duplicate key error collection: errorlab.users index: email_1 dup key: { email: "[email protected]" }

2. 验证错误

创建一个模式验证以防止插入无效数据：

db.createCollection("products", {
   validator: {
      $jsonSchema: {
         bsonType: "object",
         required: ["name", "price"],
         properties: {
            name: {
               bsonType: "string",
               description: "must be a string and is required"
            },
            price: {
               bsonType: "number",
               minimum: 0,
               description: "must be a positive number and is required"
            }
         }
      }
   }
})

// 尝试插入一个无效文档
db.products.insertOne({ name: 123, price: -10 })

示例输出：

MongoError: Document failed validation

实际中的写入错误处理

使用 Node.js 处理错误

创建一个稳健的写入错误处理脚本：

const { MongoClient } = require("mongodb");

async function handleWriteErrors() {
  const uri = "mongodb://localhost:27017";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("errorlab");
    const users = database.collection("users");

    try {
      await users.insertOne({
        name: "Alice",
        email: "[email protected]"
      });
      console.log("Document inserted successfully");
    } catch (writeError) {
      if (writeError.code === 11000) {
        console.error("Duplicate key error:", writeError.message);
        // 实现自定义的重复键处理逻辑
      } else {
        console.error("Write error:", writeError);
      }
    }
  } catch (connectionError) {
    console.error("Connection error:", connectionError);
  } finally {
    await client.close();
  }
}

handleWriteErrors();

写入错误管理的最佳实践

1. 使用唯一索引防止重复条目
2. 实现模式验证
3. 使用 try-catch 块进行错误处理
4. 记录详细的错误信息
5. 实现重试或回退机制

处理查询错误

在这一步骤中，你将学习如何处理 MongoDB 中的各种查询错误，理解常见的陷阱，并为数据库查询实现稳健的错误处理策略。

理解 MongoDB 中的查询错误

让我们探索不同类型的查询错误，以及如何使用 MongoDB shell (mongosh) 有效地管理它们。

首先，确保你已连接到 MongoDB shell：

mongosh

准备示例数据

为我们的查询错误演示创建一个示例集合：

use querylab
db.products.insertMany([
  { name: "Laptop", price: 1000, category: "Electronics" },
  { name: "Smartphone", price: 500, category: "Electronics" },
  { name: "Headphones", price: 200, category: "Accessories" }
])

查询错误的类型

1. 无效的查询语法

演示一个常见的查询语法错误：

// 错误的比较操作符
db.products.find({ price: { $invalidOperator: 500 } })

示例输出：

MongoError: unknown top level operator: $invalidOperator

2. 查询不存在的字段

尝试查询一个不存在的字段：

// 查询一个不存在的字段
db.products.find({ nonexistentField: "value" })

这不会抛出错误，但会返回一个空的结果集。

3. 查询中的类型不匹配

演示与类型相关的查询挑战：

// 类型不匹配查询
db.products.find({ price: "500" })  // 字符串而不是数字

高级查询错误处理

创建一个 Node.js 脚本来演示稳健的查询错误处理：

const { MongoClient } = require("mongodb");

async function handleQueryErrors() {
  const uri = "mongodb://localhost:27017";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("querylab");
    const products = database.collection("products");

    try {
      // 带有错误处理的安全查询
      const query = { price: { $gt: 0 } };
      const options = {
        projection: { _id: 0, name: 1, price: 1 },
        limit: 10
      };

      const cursor = products.find(query, options);
      const results = await cursor.toArray();

      if (results.length === 0) {
        console.log("No matching documents found");
      } else {
        console.log("Query results:", results);
      }
    } catch (queryError) {
      // 特定的错误处理
      if (queryError.name === "MongoError") {
        console.error("MongoDB Query Error:", queryError.message);
      } else {
        console.error("Unexpected error:", queryError);
      }
    }
  } catch (connectionError) {
    console.error("Connection error:", connectionError);
  } finally {
    await client.close();
  }
}

handleQueryErrors();

查询错误处理的最佳实践

1. 在查询前始终验证输入
2. 使用 try-catch 块进行错误管理
3. 实现类型检查
4. 使用投影控制返回的字段
5. 添加适当的错误日志记录
6. 优雅地处理空结果集

修复重复键

在这一步骤中，你将学习如何识别、预防和解决 MongoDB 中的重复键错误，这是在维护数据完整性时常见的挑战。

理解重复键的挑战

让我们探索使用 MongoDB shell (mongosh) 处理重复键的策略。

首先，确保你已连接到 MongoDB shell：

mongosh

创建唯一索引

首先创建一个具有唯一约束的集合：

use duplicatelab
db.users.createIndex({ email: 1 }, { unique: true })

处理重复键场景

1. 防止重复插入

尝试插入重复文档：

db.users.insertMany([
  { name: "John Doe", email: "[email protected]" },
  { name: "Jane Doe", email: "[email protected]" }
])

示例输出：

MongoError: E11000 duplicate key error collection: duplicatelab.users index: email_1 dup key: { email: "[email protected]" }

2. 使用 Upsert 处理重复

使用带有 upsert 的 updateOne 方法来管理重复：

db.users.updateOne(
  { email: "[email protected]" },
  { $set: {
    name: "John Doe Updated",
    lastUpdated: new Date()
  }},
  { upsert: true }
)

高级重复键处理

创建一个 Node.js 脚本来演示稳健的重复键管理：

const { MongoClient } = require("mongodb");

async function handleDuplicateKeys() {
  const uri = "mongodb://localhost:27017";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("duplicatelab");
    const users = database.collection("users");

    // 确保唯一索引
    await users.createIndex({ email: 1 }, { unique: true });

    const userDocuments = [
      { name: "Alice", email: "[email protected]" },
      { name: "Bob", email: "[email protected]" }
    ];

    try {
      // 批量写入并处理重复
      const bulkOperations = userDocuments.map((user) => ({
        updateOne: {
          filter: { email: user.email },
          update: { $set: user },
          upsert: true
        }
      }));

      const result = await users.bulkWrite(bulkOperations);
      console.log("Bulk write result:", result);
    } catch (writeError) {
      if (writeError.code === 11000) {
        console.error("Duplicate key error:", writeError.message);
        // 实现自定义的重复处理逻辑
      } else {
        console.error("Unexpected write error:", writeError);
      }
    }
  } catch (connectionError) {
    console.error("Connection error:", connectionError);
  } finally {
    await client.close();
  }
}

handleDuplicateKeys();

重复键管理的最佳实践

1. 使用唯一索引防止重复
2. 实现 upsert 策略
3. 使用批量写入操作并小心处理
4. 记录和跟踪重复条目
5. 考虑替代的唯一标识符
6. 实现应用级别的去重逻辑

重试失败的操作

在这一步骤中，你将学习如何为失败的 MongoDB 操作实现稳健的重试机制，确保你的应用能够处理瞬态错误和网络问题。

理解操作重试策略

让我们探索使用 MongoDB shell (mongosh) 和 Node.js 重试失败数据库操作的不同方法。

首先，确保你已连接到 MongoDB shell：

mongosh

准备测试环境

创建一个示例集合来演示重试机制：

use retrylab
db.transactions.insertMany([
  { id: 1, amount: 100, status: "pending" },
  { id: 2, amount: 200, status: "pending" }
])

重试策略

1. 基本重试机制

创建一个带有简单重试逻辑的 Node.js 脚本：

const { MongoClient } = require("mongodb");

async function retryOperation(operation, maxRetries = 3) {
  let retries = 0;

  while (retries < maxRetries) {
    try {
      return await operation();
    } catch (error) {
      retries++;
      console.log(`Attempt ${retries} failed:`, error.message);

      // 指数退避
      const delay = Math.pow(2, retries) * 1000;
      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }

  throw new Error("Max retries exceeded");
}

async function performMongoOperation() {
  const uri = "mongodb://localhost:27017";
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const database = client.db("retrylab");
    const transactions = database.collection("transactions");

    // 模拟一个可能失败的操作
    await retryOperation(async () => {
      const result = await transactions.updateOne(
        { id: 1 },
        { $set: { status: "completed" } }
      );

      if (result.modifiedCount === 0) {
        throw new Error("Update failed");
      }

      console.log("Transaction updated successfully");
    });
  } catch (error) {
    console.error("Final operation failed:", error.message);
  } finally {
    await client.close();
  }
}

performMongoOperation();

2. 带有特定错误处理的高级重试

增强重试机制以处理特定错误类型：

async function advancedRetryOperation(operation, maxRetries = 3) {
  const retryableErrors = [
    "MongoNetworkError",
    "MongoTimeoutError",
    "MongoServerSelectionError"
  ];

  let retries = 0;

  while (retries < maxRetries) {
    try {
      return await operation();
    } catch (error) {
      // 检查错误是否可重试
      if (!retryableErrors.includes(error.name)) {
        throw error;
      }

      retries++;
      console.log(`Retryable error (${error.name}). Attempt ${retries}`);

      // 实现带抖动的指数退避
      const delay = Math.min(
        30000,
        Math.pow(2, retries) * 1000 * (1 + Math.random())
      );

      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }

  throw new Error("Max retries exceeded for retryable errors");
}

操作重试的最佳实践

1. 实现指数退避
2. 使用带抖动的延迟以防止惊群问题
3. 限制最大重试次数
4. 仅处理特定的可重试错误
5. 记录重试尝试和最终结果
6. 考虑事务一致性

总结

在本实验中，你学习了如何处理各种类型的 MongoDB 连接错误，包括错误的连接字符串、认证问题和网络问题。你通过 MongoDB shell 探索了不同的错误场景，并学习了诊断和解决连接错误的最佳实践，例如验证连接详细信息、检查网络连接、确保 MongoDB 服务正在运行以及验证认证凭据。你还实现了一个简单的 Node.js 错误处理脚本来演示稳健的连接管理，其中包括设置适当的超时时间并优雅地处理错误。