如何基于JSON Schema的allOf规则检测不应存在的数据字段？

我有一份用于数据验证的JSON Schema，使用jsonschema库能够正常验证基础信息与条件场景，但存在一个特定问题：无法基于allOf规则轻松判断数据中存在但不应出现的字段。针对简单场景可编写自定义Python代码处理，但复杂场景下难以扩展。请问是否有相关解决思路或工具推荐？

示例Schema #

{
    "$schema": "https://json-schema.org/draft/2019-09/schema",
    "type": "object",
    "properties": {
        "colours": {
            "type": "integer",
            "oneOf": [
                {
                    "title": "red",
                    "const": 1
                },
                {
                    "title": "yellow",
                    "const": 2
                },
                {
                    "title": "blue",
                    "const": 3
                },
                {
                    "title": "yellow (variant)",
                    "const": 19
                }
            ]
        },
        "years": {
            "type": "integer",
            "minimum": 1,
            "maximum": 10
        },
        "sleep": {
            "type": "integer",
            "oneOf": [
                {
                    "title": "always",
                    "const": 1
                },
                {
                    "title": "sometimes",
                    "const": 2
                },
                {
                    "title": "rarely",
                    "const": 5
                }
            ]
        },
        "shapes": {
            "type": "array",
            "items": {
                "type": "integer",
                "anyOf": [
                    {
                        "const": 1,
                        "title": "squares"
                    },
                    {
                        "const": 2,
                        "title": "circles"
                    },
                    {
                        "const": 3,
                        "title": "triangles"
                    }
                ]
            }
        },
        "gender": {
            "type": "integer",
            "oneOf": [
                {
                    "title": "male",
                    "const": 1
                },
                {
                    "title": "female",
                    "const": 2
                }
            ]
        }
    },
    "required": [
        "colours",
        "years"
    ],
    "allOf": [
        {
            "if": {
                "allOf": [
                    {
                        "properties": {
                            "colours": {
                                "const": 1
                            }
                        }
                    },
                    {
                        "properties": {
                            "years": {
                                "enum": [
                                    1,
                                    7,
                                    8,
                                    9
                                ]
                            }
                        }
                    }
                ]
            },
            "then": {
                "required": [
                    "shapes"
                ]
            }
        },
        {
            "if": {
                "allOf": [
                    {
                        "properties": {
                            "shapes": {
                                "anyOf": [
                                    {
                                        "const": 1
                                    },
                                    {
                                        "const": 3
                                    }
                                ]
                            }
                        }
                    },
                    {
                        "properties": {
                            "colours": {
                                "const": 19
                            }
                        }
                    }
                ]
            },
            "then": {
                "required": [
                    "gender"
                ]
            }
        },
        {
            "if": {
                "properties": {
                    "years": {
                        "not": {
                            "enum": [
                                1,
                                7,
                                9,
                                8
                            ]
                        }
                    }
                }
            },
            "then": {
                "required": [
                    "sleep"
                ]
            }
        }
    ]
}

示例数据 #

data_list = [
    {"id": "a", "colours": 1, "years": 9, "sleep": 4, "shapes": [1], "gender": 3}, # 逻辑合法，但sleep值无效
    {"id": "b", "colours": 1, "years": 6, "shapes": 3, "gender": 3}, # 无效：sleep应存在，gender不应存在，shapes不是数组
    {"id": "c", "colours": 1, "years": 9, "sleep": 3}, # 无效：shapes应存在
    {"id": "d", "colours": 1, "years": 1, "sleep": 5}, # 无效：sleep不应存在
]

示例代码 #

from jsonschema import validate, Draft7Validator, ValidationError

for data in data_list:
    validator = Draft7Validator(schema)
    errors = sorted(validator.iter_errors(data), key=lambda e: e.path)
    if errors:
        print(data.get("id"))
        for error in errors:
            print(f"Schema Error in {list(error.path)}: {error.message}")
            
# 未检测出id为d的数据中sleep字段不应存在

解决思路与方案 #

1. 结合JSON Schema原生规则限制字段 #

利用JSON Schema的additionalProperties和properties字段特性，在条件规则中明确禁止特定字段：

• 在then块中给禁止的字段赋值为false，表示该字段绝对不能存在
• 或者使用additionalProperties: false严格限制只允许properties中定义的字段（需确保所有合法字段都已定义）

修改后的条件规则示例：

{
  "if": {
    "allOf": [
      {"properties": {"colours": {"const": 1}}},
      {"properties": {"years": {"enum": [1,7,8,9]}}}
    ]
  },
  "then": {
    "required": ["shapes"],
    "properties": {
      "sleep": false  // 明确禁止sleep字段存在
    }
  }
}

2. 扩展jsonschema库的自定义验证器 #

通过扩展jsonschema的验证逻辑，添加自定义关键字（比如forbiddenProperties）来检测不应存在的字段：

from jsonschema import Draft7Validator, validators

def extend_with_forbidden(validator_class):
    def forbidden_properties(validator, forbidden, instance, schema):
        if not isinstance(instance, dict):
            return
        for prop in forbidden:
            if prop in instance:
                yield ValidationError(f"字段 '{prop}' 不应存在")

    return validators.extend(
        validator_class,
        {"forbiddenProperties": forbidden_properties},
    )

# 使用扩展后的验证器
ForbiddenValidator = extend_with_forbidden(Draft7Validator)

然后在Schema的then块中添加自定义规则：

"then": {
  "required": ["shapes"],
  "forbiddenProperties": ["sleep"]
}

3. 切换验证框架 #

如果场景足够复杂，可考虑使用pydantic框架，它支持更直观的条件字段控制：

• 通过Field的参数或依赖函数动态控制字段是否允许存在
• 结合模型的验证方法，轻松实现复杂场景下的字段禁用逻辑

注意事项 #

• 使用additionalProperties: false时，务必确保所有合法字段都已在properties中定义，避免误判
• 自定义验证器需考虑嵌套对象的字段检测，可递归遍历实例结构

内容的提问来源于stack exchange，提问作者b101