MongoDB Academy · 课时

为集合添加验证器

您将使用 createCollection 和 collMod 附加 JSON Schema 验证器，强制要求字段和数据类型。

为集合添加验证器 是 CoddyKit 上的免费 MongoDB Academy 课时。这是第 1 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 MongoDB Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 MongoDB Academy 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Why Schema Validation Matters

MongoDB is schema-flexible by default—any document can be inserted regardless of its shape. While this is useful in development, production databases need guardrails to prevent malformed data. MongoDB's schema validation feature lets you attach a JSON Schema rule set to a collection so that only well-formed documents can be inserted or updated, catching data quality problems at the database layer before they propagate.

JSON Schema as the Validation Language

MongoDB uses the industry-standard JSON Schema specification (draft 4) to express validation rules. You define a $jsonSchema object that declares which fields are required, what types they must be, and any additional constraints. The same format is used everywhere JSON Schema appears—in OpenAPI specs, form libraries, and now MongoDB validators.

Adding a Validator at Collection Creation

Pass a validator option when calling db.createCollection(). The validator contains a $jsonSchema document. The example below requires every users document to have a name (string) and an email (string), and optionally an age (integer).

db.createCollection('users', {
  validator: {
    $jsonSchema: {
      bsonType: 'object',
      required: ['name', 'email'],
      properties: {
        name:  { bsonType: 'string', description: 'must be a string and is required' },
        email: { bsonType: 'string', description: 'must be a string and is required' },
        age:   { bsonType: 'int',    minimum: 0, description: 'optional, must be a non-negative int' }
      }
    }
  }
});

Adding a Validator to an Existing Collection

Use the collMod (collection modification) command to attach or update a validator on a collection that already exists and may already contain data. This does not validate existing documents by default—it only applies to future writes unless you also change validationLevel.

db.runCommand({
  collMod: 'users',
  validator: {
    $jsonSchema: {
      bsonType: 'object',
      required: ['name', 'email'],
      properties: {
        name:  { bsonType: 'string' },
        email: { bsonType: 'string' }
      }
    }
  }
});

What Happens When Validation Fails

By default, if a document violates the validator, MongoDB rejects the write and throws an error: Document failed validation. The error includes a details field explaining exactly which rule was broken, making it easy to diagnose and fix the offending document. The insert or update is rolled back completely—no partial writes occur.

// This insert violates the validator — email is missing
try {
  db.users.insertOne({ name: 'Bob' });
} catch (err) {
  console.error(err.errInfo.details);
  // Output: required field 'email' is missing
}

Viewing the Current Validator

To inspect the validator attached to a collection, use db.getCollectionInfos() or query the system.js namespace. The returned document includes the full validator specification under options.validator, allowing you to review, copy, or compare validators across environments.

// List all collections and their options, including validators
const info = db.getCollectionInfos({ name: 'users' });
console.log(JSON.stringify(info[0].options.validator, null, 2));

Removing a Validator

To remove all validation from a collection, run collMod with an empty validator object. This returns the collection to its default schema-free state. You might do this temporarily during a bulk data migration or permanently when retiring validation in favour of application-layer checks.

// Remove the validator entirely
db.runCommand({
  collMod: 'users',
  validator: {}
});

Validation in Mongoose vs Native MongoDB

Mongoose has its own schema validation at the ODM layer that runs in JavaScript before sending data to MongoDB. However, Mongoose validation can be bypassed with insertMany or direct driver calls. Adding a JSON Schema validator at the database level creates an additional safety net that no client can bypass, regardless of the driver or language used.

Nested Object Validation

JSON Schema validators can reach into embedded sub-documents. Use the properties key to define rules for nested fields, and mark the nested object itself with bsonType: 'object'. This allows you to validate every level of a hierarchical document.

db.createCollection('orders', {
  validator: {
    $jsonSchema: {
      bsonType: 'object',
      required: ['customerId', 'shippingAddress'],
      properties: {
        customerId: { bsonType: 'objectId' },
        shippingAddress: {
          bsonType: 'object',
          required: ['street', 'city'],
          properties: {
            street: { bsonType: 'string' },
            city:   { bsonType: 'string' }
          }
        }
      }
    }
  }
});

Array Item Validation

To validate that an array field contains only documents of a specific shape, use items inside the property definition. Each element of the array will be validated against the items schema. This is useful for enforcing the shape of embedded line items, tags, or address arrays.

db.createCollection('carts', {
  validator: {
    $jsonSchema: {
      bsonType: 'object',
      properties: {
        items: {
          bsonType: 'array',
          items: {
            bsonType: 'object',
            required: ['productId', 'qty'],
            properties: {
              productId: { bsonType: 'objectId' },
              qty: { bsonType: 'int', minimum: 1 }
            }
          }
        }
      }
    }
  }
});

Schema Validation in Atlas

MongoDB Atlas provides a graphical interface for building and editing collection validators without writing raw JSON. Under the collection's Schema tab you can add properties, set types, and mark required fields through a form. Atlas also shows a validation score—the percentage of existing documents that pass the current schema—helping you measure data quality before enforcing strict validation.

Quick Check

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

Lesson Recap

In this lesson you learned: JSON Schema validators are attached via createCollection or collMod, validation failures reject the write and return a detailed error, and nested objects and arrays can also be validated within the same schema document. Next up we explore type, required, and enum constraints in depth.

常见问题解答

「为集合添加验证器」课时是免费的吗？

是的 — 「为集合添加验证器」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 MongoDB Academy 课程的其余内容，请升级到 CoddyKit PRO。 MongoDB Academy 课程共包含 4 节课。

「为集合添加验证器」这节课中我会学到什么？

您将使用 createCollection 和 collMod 附加 JSON Schema 验证器，强制要求字段和数据类型。你通过在浏览器中直接运行的动手代码来练习 MongoDB Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 MongoDB Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 MongoDB Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 1 节课，共 4 节。

「为集合添加验证器」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 MongoDB Academy 课中编写并运行代码吗？

能。每节 MongoDB Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 MongoDB Academy