Swagger Schema:oneOf,anyOf,allOf同时有效吗?

时间:2018-04-02 02:07:14

标签: schema swagger

我只是阅读Swagger规范Schema定义中更高级的验证器:

{
   "Schema":{
      "type":"object",
      "properties":{
         "title":{
            "type":"string"
         },
         "multipleOf":{
            "type":"number",
            "minimum":0,
            "exclusiveMinimum":true
         },
         "maximum":{
            "type":"number"
         },
         "exclusiveMaximum":{
            "type":"boolean",
            "default":false
         },
         "minimum":{
            "type":"number"
         },
         "exclusiveMinimum":{
            "type":"boolean",
            "default":false
         },
         "maxLength":{
            "type":"integer",
            "minimum":0
         },
         "minLength":{
            "type":"integer",
            "minimum":0,
            "default":0
         },
         "pattern":{
            "type":"string",
            "format":"regex"
         },
         "maxItems":{
            "type":"integer",
            "minimum":0
         },
         "minItems":{
            "type":"integer",
            "minimum":0,
            "default":0
         },
         "uniqueItems":{
            "type":"boolean",
            "default":false
         },
         "maxProperties":{
            "type":"integer",
            "minimum":0
         },
         "minProperties":{
            "type":"integer",
            "minimum":0,
            "default":0
         },
         "required":{
            "type":"array",
            "items":{
               "type":"string"
            },
            "minItems":1,
            "uniqueItems":true
         },
         "enum":{
            "type":"array",
            "items":{

            },
            "minItems":1,
            "uniqueItems":true
         },
         "type":{
            "type":"string",
            "enum":[
               "array",
               "boolean",
               "integer",
               "number",
               "object",
               "string"
            ]
         },
         "not":{
            "oneOf":[
               {
                  "$ref":"#/definitions/Schema"
               },
               {
                  "$ref":"#/definitions/Reference"
               }
            ]
         },
         "allOf":{
            "type":"array",
            "items":{
               "oneOf":[
                  {
                     "$ref":"#/definitions/Schema"
                  },
                  {
                     "$ref":"#/definitions/Reference"
                  }
               ]
            }
         },
         "oneOf":{
            "type":"array",
            "items":{
               "oneOf":[
                  {
                     "$ref":"#/definitions/Schema"
                  },
                  {
                     "$ref":"#/definitions/Reference"
                  }
               ]
            }
         },
         "anyOf":{
            "type":"array",
            "items":{
               "oneOf":[
                  {
                     "$ref":"#/definitions/Schema"
                  },
                  {
                     "$ref":"#/definitions/Reference"
                  }
               ]
            }
         },
         "items":{
            "oneOf":[
               {
                  "$ref":"#/definitions/Schema"
               },
               {
                  "$ref":"#/definitions/Reference"
               }
            ]
         },
         "properties":{
            "type":"object",
            "additionalProperties":{
               "oneOf":[
                  {
                     "$ref":"#/definitions/Schema"
                  },
                  {
                     "$ref":"#/definitions/Reference"
                  }
               ]
            }
         },
         "additionalProperties":{
            "oneOf":[
               {
                  "$ref":"#/definitions/Schema"
               },
               {
                  "$ref":"#/definitions/Reference"
               },
               {
                  "type":"boolean"
               }
            ],
            "default":true
         },
         "description":{
            "type":"string"
         },
         "format":{
            "type":"string"
         },
         "default":{

         },
         "nullable":{
            "type":"boolean",
            "default":false
         },
         "discriminator":{
            "$ref":"#/definitions/Discriminator"
         },
         "readOnly":{
            "type":"boolean",
            "default":false
         },
         "writeOnly":{
            "type":"boolean",
            "default":false
         },
         "example":{

         },
         "externalDocs":{
            "$ref":"#/definitions/ExternalDocumentation"
         },
         "deprecated":{
            "type":"boolean",
            "default":false
         },
         "xml":{
            "$ref":"#/definitions/XML"
         }
      },
      "patternProperties":{
         "^x-":{

         }
      },
      "additionalProperties":false
   }
}

我正在考虑的是anyOf,allOf,oneOf和not keywords的组合。我有两个问题。

第一个问题是:“它们可以结合使用吗?”像这样:

{
   "allOf" : [
      {
         "minItems" : 0
      },
      {
         "maxItems" : 10
      }
   ],
   "anyOf" : [
      {
         "type" : "array",
         "items" : {
            "type" : "string"
         }
      },
      {
         "type" : "array",
         "items" : {
            "type" : "integer"
         }
      }
   ]
}

这个例子当然是不必要的复杂。但它有效吗?或者你只能使用一个修饰语但不能使用其他修饰语吗?

第二个问题是,有人能指出一个真实世界的例子,其中一个运算符已经结合使用了吗?

1 个答案:

答案 0 :(得分:1)

  

我正在考虑的事情是anyOf,allOf,oneOf而不是关键字的组合。我有两个问题。

     

第一个问题是:“它们可以结合使用吗?”

是的,allOfanyOfoneOfnot可以结合使用。 OpenAPI规范在此遵循JSON Schema的规则,在JSON Schema中,相邻的关键字充当隐式allOfsource)的分支。因此,您的示例等效于:

{
  "allOf": [
    {
      "allOf": [
        {
          "minItems": 0
        },
        {
          "maxItems": 10
        }
      ]
    },
    {
      "anyOf": [
        {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        {
          "type": "array",
          "items": {
            "type": "integer"
          }
        }
      ]
    }
  ]
}

也就是说,这个示例太复杂了,可以简化为:

{
  "minItems": 0,
  "maxItems": 10,
  "type": "array",
  "items": {
    "oneOf": [
      {
        "type": "string"
      },
      {
        "type": "integer"
      }
    ]
  }
}