jsonschema校验设置默认值时oneOf场景无效子schema默认值误设问题

你当前实现的本质问题是：jsonschema 3.2.0的校验流程是按关键字独立递归执行的，oneOf/anyOf这类组合关键字的逻辑是先逐个遍历所有子schema做全量校验，最后再统计符合匹配规则的子schema数量。你把默认值写入逻辑直接绑定在properties校验阶段，相当于在子schema的试探性校验阶段就产生了修改实例的副作用，完全等不到上层组合关键字判断当前子schema是否真的有效，自然会把不匹配分支的默认值错误写入实例。

方案1：快照校验法（实现成本最低，适配3.2.0版本） #

核心思路是所有试探性的子schema校验都在原实例的深拷贝快照上执行，只有确认子schema符合匹配规则后，才把快照上写入的默认值合并回原实例，从根源避免脏写。

注意：深拷贝需要覆盖嵌套对象、数组类型，避免引用共享导致原实例被意外修改。

具体实现逻辑：

• 根节点默认值单独处理：校验入口判断如果传入实例为空/None，且根schema定义了default，直接用深拷贝的default值初始化实例。
• 重写oneOf校验逻辑：
  1. 遍历每个子schema时，先为当前节点生成深拷贝快照；
  2. 基于快照执行子schema的全量校验（包括properties阶段的默认值写入），记录校验结果；
  3. 收集所有校验通过的子schema对应的快照，按照oneOf的规则（恰好1个子schema匹配）判定合法性；
  4. 仅当子schema匹配合法时，递归将快照上的新增默认值合并回原实例。
• 原有properties的默认值写入逻辑保留，但是所有写入操作都只作用在当前传入的实例上（试探阶段就是快照，合并阶段就是原实例），不需要额外感知上层校验上下文。
• anyOf/allOf逻辑可以按相同思路扩展：allOf需要合并所有匹配子schema的默认值，anyOf如果出现多分支同路径default冲突，按业务规则定义优先级即可（通常取第一个匹配分支的值）。

最小可运行代码示例：

from collections import deque
from copy import deepcopy
from jsonschema import Draft7Validator

class DefaultSetValidator(Draft7Validator):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._origin_validators = dict(self.VALIDATORS)

    def validate(self, instance, schema):
        # 处理根级默认值
        if instance in (None, {}) and "default" in schema:
            instance = deepcopy(schema["default"])

        # 重写properties校验器：仅给当前传入的实例写默认值
        def properties_validator(validator, properties, inst, cur_schema):
            for prop_name, prop_schema in properties.items():
                if "default" in prop_schema:
                    inst.setdefault(prop_name, deepcopy(prop_schema["default"]))
            yield from self._origin_validators["properties"](validator, properties, inst, cur_schema)

        # 重写oneOf校验器：基于快照做试探校验
        def oneof_validator(validator, oneof_schemas, inst, cur_schema):
            valid_instances = []
            # 逐个校验子schema，所有操作在快照上执行
            for sub_schema in oneof_schemas:
                inst_snapshot = deepcopy(inst)
                sub_errors = list(validator.descend(
                    inst_snapshot, sub_schema, schema_path=deque(["oneOf"])
                ))
                if not sub_errors:
                    valid_instances.append(inst_snapshot)
            # 符合oneOf规则才合并默认值
            if len(valid_instances) == 1:
                def merge_default(target, source):
                    for k, v in source.items():
                        if k not in target:
                            target[k] = v
                        elif isinstance(v, dict) and isinstance(target[k], dict):
                            merge_default(target[k], v)
                merge_default(inst, valid_instances[0])
            # 执行原有oneOf的错误抛出逻辑
            yield from self._origin_validators["oneOf"](validator, oneof_schemas, inst, cur_schema)

        # 替换校验器映射执行校验
        custom_validators = dict(self.VALIDATORS)
        custom_validators["properties"] = properties_validator
        custom_validators["oneOf"] = oneof_validator
        runtime_validator = type(self).create(
            meta_schema=self.META_SCHEMA, validators=custom_validators
        )
        return super(runtime_validator, self).validate(instance, schema)

针对你给出的测试用例，这个实现会在第一个子schema校验时，把params.q=1写入快照，因为p字段校验失败，这个快照会直接丢弃；第二个子schema校验通过后，仅会把快照上的params.w=2合并回原实例，符合预期结果。

方案2：上下文缓存法（适合复杂schema场景） #

如果你的schema嵌套层级极深、数据量很大，深拷贝的性能开销不可接受，可以换用上下文缓存方案：

• 不在properties阶段直接修改实例，而是维护一个随校验上下文传递的临时字典，按节点路径记录每个分支下收集到的default值；
• 重写所有组合关键字的校验逻辑，记录每个子schema的校验状态，校验通过的分支才保留对应路径下的default记录，校验失败的分支直接删除对应收集到的default；
• 所有校验流程走完后，再把收集到的合法default值按路径批量写入实例。
  这个方案不需要深拷贝，但是需要维护校验上下文中的路径状态和分支映射，实现复杂度更高，适合对性能有明确要求的场景。

如果后续可以升级jsonschema到4.0+版本，官方已经提供了校验上下文的钩子能力，可以直接在iter_errors收集完所有校验错误、确认分支合法后再注入默认值，不需要自己实现快照或者上下文缓存，逻辑会更简洁。3.2.0版本没有开放相关钩子，优先用快照法即可满足需求。

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