Swagger继承和组合

95
在我的“简化”API中,所有的响应都是从一个基本的“响应”类中派生(继承)而来。响应类由一个包含元数据的头部和包含用户请求的核心数据的主体组成。响应(以JSON格式)的布局是这样的:所有元数据都在第一个“层”上,主体是一个名为“body”的单个属性。
response
|--metadata attribute 1 (string/int/object)
|--metadata attribute 2 (string/int/object)
|--body (object)
    |--body attribute 1 (string/int/object)
    |--body attribute 2 (string/int/object)

我已经尝试使用以下JSON在Swagger中定义了这个关系:

{
    ...
    "definitions": {
        "response": {
            "allOf": [
                {
                    "$ref": "#/definitions/response_header"
                },
                {
                    "properties": {
                        "body": {
                            "description": "The body of the response (not metadata)",
                            "schema": {
                                "$ref": "#/definitions/response_body"
                            }
                        }
                    }
                }
            ]
        },
        "response_header": {
            "type": "object",
            "required": [
                "result"
            ],
            "properties": {
                "result": {
                    "type": "string",
                    "description": "value of 'success', for a successful response, or 'error' if there is an error",
                    "enum": [
                        "error",
                        "success"
                    ]
                },
                "message": {
                    "type": "string",
                    "description": "A suitable error message if something went wrong."
                }
            }
        },
        "response_body": {
            "type": "object"
        }
    }
}

我尝试通过创建继承自body/header的不同body/header类来创建不同的响应,然后创建由相关header/body类组成的子响应类(在源代码底部显示)来创建不同的响应。但是,我确定这要么是做事情的错误方式,要么是我的实现有误。我一直无法找到swagger 2.0规范中继承的示例(如下所示),但已找到一个组合的示例

enter image description here

我相当确信这个"鉴别器"起着很大的作用,但不确定我需要做什么。

问题

是否有人能向我展示如何在swagger 2.0(JSON)中实现组合+继承,最好通过“修复”下面的示例代码。如果我可以指定一个ErrorResponse类,它继承自response,其中header中的“result”属性始终设置为“error”,那就太好了。

{
    "swagger": "2.0",
    "info": {
        "title": "Test API",
        "description": "Request data from the system.",
        "version": "1.0.0"
    },
    "host": "xxx.xxx.com",
    "schemes": [
        "https"
    ],
    "basePath": "/",
    "produces": [
        "application/json"
    ],
    "paths": {
        "/request_filename": {
            "post": {
                "summary": "Request Filename",
                "description": "Generates an appropriate filename for a given data request.",
                "responses": {
                    "200": {
                        "description": "A JSON response with the generated filename",
                        "schema": {
                            "$ref": "#/definitions/filename_response"
                        }
                    }
                }
            }
        }
    },
    "definitions": {
        "response": {
            "allOf": [
                {
                    "$ref": "#/definitions/response_header"
                },
                {
                    "properties": {
                        "body": {
                            "description": "The body of the response (not metadata)",
                            "schema": {
                                "$ref": "#/definitions/response_body"
                            }
                        }
                    }
                }
            ]
        },
        "response_header": {
            "type": "object",
            "required": [
                "result"
            ],
            "properties": {
                "result": {
                    "type": "string",
                    "description": "value of 'success', for a successful response, or 'error' if there is an error",
                    "enum": [
                        "error",
                        "success"
                    ]
                },
                "message": {
                    "type": "string",
                    "description": "A suitable error message if something went wrong."
                }
            }
        },
        "response_body": {
            "type": "object"
        },
        "filename_response": {
            "extends": "response",
            "allOf": [
                {
                    "$ref": "#definitions/response_header"
                },
                {
                    "properties": {
                        "body": {
                            "schema": {
                                "$ref": "#definitions/filename_response_body"
                            }
                        }
                    }
                }
            ]
        },
        "filename_response_body": {
            "extends": "#/definitions/response_body",
            "properties": {
                "filename": {
                    "type": "string",
                    "description": "The automatically generated filename"
                }
            }
        }
    }
}

图示更新

为了更好地阐明我的想法,我创建了下面这个非常基本的图示,旨在表明所有响应都是“响应”对象的实例,这些对象是通过(组合)使用任何响应头和响应体对象构建的。响应头和响应体对象可以扩展并插入到任何响应对象中,在文件名响应的情况下会使用基础响应体类的filename_response_body子对象。无论是错误响应还是成功响应都使用“响应”对象。

enter image description here


1
有一个组合的示例,但它太糟糕了,不值得分享。我会制定规范的具体要求。请记住,当前界面不支持它,但在完全支持2.0时会加入支持。 - Ron
1
在我开始之前,还有一件事 - 你是在寻找组合还是继承?组合基本上意味着“我拥有X的属性和我的自己的属性”。继承则表明了一个关系,“X是我的父类。我拥有它的属性和我的自己的属性。”如果你想说某个模型集只适用于父类被使用时,那么继承很有用。 - Ron
1
我原本希望通过这个例子一次性演示继承和组合的使用。显然,我意识到可以单独使用其中任何一个,但在这种情况下,所有响应都是基础“响应”类的子类。而响应类由另外两个对象——头部和正文——“组成”。 - Programster
2
我可能没有表达清楚。继承是组合的一种扩展。如果有继承,就会有组合。如果有组合,则不一定有继承。此外,在您的示例中,“response”模型未在任何地方使用。我应该忽略它并展示它应该如何看吗? - Ron
规格已经更新,附带了样例。如果需要的话,我可以回答这个问题。 - Ron
显示剩余8条评论
4个回答

132
作为Swagger的初学者,我发现关于多态和组合的官方文档不易理解,因为它缺少一个示例。当我在网上搜索时,有很多好的示例是参考Swagger 1.2时使用extends有效的。
对于Swagger 2.0,我在GitHub上的Swagger规范源代码中找到了一个很好的示例,通过这个Google小组
基于上述来源,这里是一个简短的有效继承示例,使用YAML格式:
definitions:
  Pet:
    discriminator: petType
    required:
      - name
      - petType # required for inheritance to work
    properties:
      name: 
        type: string
      petType:
        type: string
  Cat:
    allOf:
      - $ref: '#/definitions/Pet' # Cat has all properties of a Pet
      - properties: # extra properties only for cats
          huntingSkill:
            type: string
            default: lazy
            enum:
              - lazy
              - aggressive
  Dog:
    allOf:
      - $ref: '#/definitions/Pet' # Dog has all properties of a Pet
      - properties: # extra properties only for dogs
          packSize:
            description: The size of the pack the dog is from
            type: integer

非常感谢!这对我有用。在 editor.swagger.io 中,我看到一个小错误:在模型部分,我看到了多次出现的 Pet 模型。这些模型的内容是正确的。只有名称是错的。 - schellingerht
@schellingerht 在 editor2.swagger.io 中,您不会看到这个问题。 - Shiplu Mokaddim
我发现这种定义继承的方式唯一的问题是,petType属性在生成的类中有点无用。它将为空。但至少它确实生成了我认为应该生成的类层次结构。谢谢! - xarlymg89
为了创建如上所示的继承JSON,您必须按照以下方式注释父类和子类:@ApiModel(discriminator="type", subTypes ={Cat.class, Dog.class}) public abstract class Animal {} @ApiModel(parent = Animal.class) public calss Cat extends Animal{} - Janet
判别器仅在实现接口“Pet”时使用,如果A类扩展B类,我们是否也应该使用它?谢谢。 - Bionix1441
有没有办法在没有鉴别器的情况下实现继承? - user2441441

26

我发现即使没有定义鉴别器,组合仍然可以正常工作。

例如,基本的响应(Response)

definitions:
  Response:
    description: Default API response
    properties:
      status:
        description: Response status `success` or `error`
        type: string
        enum: ["success", "error"]
      error_details:
        description: Exception message if called
        type: ["string", "object", "null"]
      error_message:
        description: Human readable error message
        type: ["string", "null"]
      result:
        description: Result body
        type: ["object", "null"]
      timestamp:
        description: UTC timestamp in ISO 8601 format
        type: string
    required:
      - status
      - timestamp
      - error_details
      - error_message
      - result

被渲染为:

响应可视化

我们可以扩展它以完善result字段的自定义模式:

  FooServiceResponse:
    description: Response for Foo service
    allOf:
      - $ref: '#/definitions/Response'
      - properties:
          result:
            type: object
            properties:
              foo_field:
                type: integer
                format: int32
              bar_field:
                type: string
        required:
          - result

它将被正确地呈现为:

FooServiceResponse 可视化

请注意,allOf 足以使其工作,并且没有使用 discriminator 字段。这很好,因为它可以正常工作,这一点非常重要,我认为工具可以在没有 discriminator 字段的情况下生成代码。


我也使用过allOf,但是在openapi.yaml中,我发现子类以冗余的方式包含了超类的属性,这样正确吗? - Bionix1441

10
所有这里的答案都已经很好了,但我想补充一点关于组合与继承的小注释。根据Swagger/OpenAPI规范,要实现组合,只需使用allOf属性就足够了,正如@oblalex正确指出的那样。然而,要实现继承,你需要使用带有discriminatorallOf,就像@TomaszSętkowski的示例中所示。

另外,我在API Handyman上找到了一些关于组合继承的Swagger示例。它们是由Arnaud Lauret创建的优秀的Swagger/OpenAPI教程系列的一部分,我认为每个人都应该查看。


1
虽然发布相关链接是一个好的开始,但要成为一个有用的答案,您还应该引用在链接中找到的相关文本。仅提供链接的答案是不被鼓励的,因为链接经常会失效。 - Stijn de Witt

2
您分享的Swagger 2.0标准示例描述了一个组合关系,具体来说,它捕获了“是种类”的超类型/子类型关系,但本身并不是多态性。如果您可以将Pet的基本定义作为输入参数进行引用,然后选择Cat或输入Cat JSON对象作为输入请求的值,并使其适用于Swagger UI,则会更好。我无法直接实现这一点。我能够让它起作用的最佳方法是在基本对象上设置additionalProperties为true(例如Pet),使用JSON指针引用指定Pet作为输入模式,最后将我的Cat JSON值对象复制并粘贴到Swagger UI中。由于允许使用其他属性,Swagger UI生成了有效的输入请求负载。

除非你想要紧密耦合到特定的黑客方式使其工作,否则不要在网络上进行多态性(或公开数据实体)。 - user1496062
多态性是通过继承实现的,但不需要使用继承。从逻辑上讲,继承是一种“is-a”关系,而组合是一种“has-a”关系。两者之间的界限取决于实现语言和领域用例。但这是起点。顺便说一下,鉴别器使多态类型的反序列化成为可能。还有其他方法(例如包括Java类名)。但是,同意的是,这些方法可能很笨拙并且不可移植。例如,Python客户端如何处理Java类名? - Charlie Reitzel

网页内容由stack overflow 提供, 点击上面的
可以查看英文原文,
原文链接