OpenAPI 规范 v3.1.0

版本 3.1.0

关于此文档的更多详细信息
此版本
https://spec.openapis.org.cn/oas/v3.1.0.html
最新发布版本
https://spec.openapis.org.cn/oas/latest.html
最新编辑草案
https://github.com/OAI/OpenAPI-Specification/
编辑
Darrel Miller
Jeremy Whitlock
Marsh Gardiner
Mike Ralphson
Ron Ratovsky
Uri Sarid
前任编辑
Jason Harmon
Tony Tam
参与
GitHub OAI/OpenAPI-Specification
提交错误
提交历史
拉取请求

什么是 OpenAPI 规范?

OpenAPI 规范 (OAS) 定义了一种标准的、与编程语言无关的 HTTP API 接口描述,使人和计算机都能够发现和理解服务的的能力,而无需访问源代码、其他文档或检查网络流量。当通过 OpenAPI 正确定义时,使用者只需最少的实现逻辑即可理解并与远程服务进行交互。类似于接口描述对较低级别编程的作用,OpenAPI 规范消除了调用服务的猜测。

本文档的状态

此规范的真实来源是上面引用的 HTML 文件,即“此版本”。

1. OpenAPI 规范

1.1 版本 3.1.0

本文档中的关键词“必须”、“禁止”、“需要”、“”、“不应”、“应该”、“不应该”、“推荐”、“不推荐”、“可以”和“可选”应按BCP 14 [RFC2119] [RFC8174] 中所述进行解释,当且仅当它们以全部大写字母出现时,如这里所示。

本文档根据Apache 许可证 2.0 版获得许可。

2. 简介

OpenAPI 规范 (OAS) 定义了一种标准的、与语言无关的 HTTP API 接口,使人和计算机都能够发现和理解服务的的能力,而无需访问源代码、文档或通过网络流量检查。如果正确定义,使用者只需最少的实现逻辑即可理解并与远程服务进行交互。

然后,OpenAPI 定义可用于文档生成工具来显示 API、代码生成工具来使用各种编程语言生成服务器和客户端、测试工具以及许多其他用例。

3. 定义

3.1 OpenAPI 文档

一个自包含或复合资源,用于定义或描述 API 或 API 的元素。OpenAPI 文档必须至少包含一个paths字段、一个components字段或一个webhooks字段。OpenAPI 文档使用并符合 OpenAPI 规范。

3.2 路径模板

路径模板指的是使用由花括号({})分隔的模板表达式来标记 URL 路径的一部分,以便使用路径参数替换。

路径中的每个模板表达式必须对应于包含在Path Item本身和/或其每个Operation中的路径参数。如果路径项为空,例如由于 ACL 约束,则不需要匹配路径参数。

这些路径参数的值禁止包含[RFC3986] 第 3 节中描述的任何未转义的“通用语法”字符:正斜杠 (/)、问号 (?) 或井号 (#)。

3.3 媒体类型

媒体类型定义分散在多个资源中。媒体类型定义应该符合[RFC6838]。

一些可能的媒体类型定义示例

  text/plain; charset=utf-8
  application/json
  application/vnd.github+json
  application/vnd.github.v3+json
  application/vnd.github.v3.raw+json
  application/vnd.github.v3.text+json
  application/vnd.github.v3.html+json
  application/vnd.github.v3.full+json
  application/vnd.github.v3.diff
  application/vnd.github.v3.patch

3.4 HTTP 状态码

HTTP 状态码用于指示执行的操作的状态。可用状态码由[RFC7231] 第 6 节定义,注册的状态码列在IANA 状态码注册表中。

4. 规范

4.1 版本

OpenAPI 规范使用 major.minor.patch 版本控制方案。版本字符串的 major.minor 部分(例如 3.1必须指定 OAS 功能集。.patch 版本解决此文档中的错误或提供澄清,而不是功能集。支持 OAS 3.1 的工具应该与所有 OAS 3.1.* 版本兼容。补丁版本不应该被工具考虑,例如不区分 3.1.03.1.1

偶尔,在 OAS 的 minor 版本中可能会进行不向后兼容的更改,如果认为更改对提供的好处的影响较小。

与 OAS 3.*.* 兼容的 OpenAPI 文档包含一个必需的 openapi 字段,该字段指定它使用的 OAS 版本。

4.2 格式

符合 OpenAPI 规范的 OpenAPI 文档本身是一个 JSON 对象,可以以JSONYAML 格式表示。

例如,如果某个字段具有数组值,则将使用 JSON 数组表示形式

{
   "field": [ 1, 2, 3 ]
}

规范中的所有字段名称都区分大小写。这包括用作映射中键的所有字段,除非明确指出键不区分大小写

架构公开两种类型的字段:固定字段,具有声明的名称;模式字段,为字段名称声明正则表达式模式。

模式字段必须在包含的对象中具有唯一的名称。

为了保留在 YAML 和 JSON 格式之间进行双向转换的能力,YAML 1.2 版本建议与一些其他约束一起使用

注意:虽然 API 可以通过 YAML 或 JSON 格式的 OpenAPI 文档来定义,但 API 请求和响应主体以及其他内容不需要是 JSON 或 YAML。

4.3 文档结构

OpenAPI 文档可以由单个文档组成,也可以根据作者的意愿划分为多个连接的部分。在后一种情况下,将使用 引用对象架构对象 $ref 关键字。

建议将根 OpenAPI 文档命名为:openapi.jsonopenapi.yaml

4.4 数据类型

OAS 中的数据类型基于 JSON 架构规范草案 2020-12 支持的类型。请注意,integer 作为一种类型也受支持,并且被定义为没有小数部分或指数部分的 JSON 数字。模型使用 架构对象 定义,它是 JSON 架构规范草案 2020-12 的超集。

JSON 架构验证词汇表 所定义,数据类型可以具有可选的修饰符属性:format。OAS 定义了其他格式,以便为基本数据类型提供更详细的信息。

OAS 定义的格式为

类型 格式 注释
整数 int32 带符号的 32 位
整数 int64 带符号的 64 位(又名长整型)
数字 float
数字 double
字符串 密码 提示 UI 隐藏输入。

4.5 富文本格式化

在整个规范中,description 字段都被注释为支持 [CommonMark] markdown 格式。在 OpenAPI 工具呈现富文本时,必须至少支持 [CommonMark-0.27] 中描述的 markdown 语法。工具可以选择忽略某些 CommonMark 功能以解决安全问题。

4.6 URI 中的相对引用

除非另有说明,否则所有作为 URI 的属性可以是 [RFC3986] 第 4.2 节 中定义的相对引用。

相对引用,包括 引用对象路径项对象 $ref 字段、链接对象 operationRef 字段和 示例对象 externalValue 字段中的相对引用,都使用引用文档作为根据 [RFC3986] 第 5.2 节 的基本 URI 进行解析。

如果 URI 包含片段标识符,则应根据引用文档的片段解析机制解析片段。如果引用文档的表示形式为 JSON 或 YAML,则片段标识符应该被解释为根据 [RFC6901] 的 JSON 指针。

架构对象 中的相对引用,包括任何作为 $id 值出现的相对引用,都使用最近的父级 $id 作为基本 URI,如 JSON 架构规范草案 2020-12 中所述。如果没有任何父架构包含 $id,则必须根据 [RFC3986] 第 5.1 节 确定基本 URI。

4.7 URL 中的相对引用

除非另有说明,否则所有作为 URL 的属性可以是 [RFC3986] 第 4.2 节 中定义的相对引用。除非另有说明,否则相对引用将使用 服务器对象 中定义的 URL 作为基本 URL 进行解析。请注意,这些 URL 本身可以相对于引用文档。

4.8 模式

在下述描述中,如果某个字段没有明确必需或使用 必须 或 应该 进行描述,则可以将其视为可选。

4.8.1 OpenAPI 对象

这是 OpenAPI 文档 的根对象。

4.8.1.1 固定字段
字段名称 类型 描述
openapi 字符串 必需。此字符串必须是 OpenAPI 文档使用的 OpenAPI 规范的 版本号openapi 字段应该被工具用来解释 OpenAPI 文档。这与 API info.version 字符串无关。
info 信息对象 必需。提供有关 API 的元数据。元数据可以根据需要由工具使用。
jsonSchemaDialect 字符串 此 OAS 文档中包含的 架构对象$schema 关键字的默认值。这必须采用 URI 的形式。
servers [服务器对象] 服务器对象的数组,提供到目标服务器的连接信息。如果未提供 servers 属性或其为一个空数组,则默认值为一个 服务器对象,其 url 值为 /
paths 路径对象 API 可用的路径和操作。
webhooks Map[string, 路径项对象 | 引用对象] ] 作为此 API 的一部分可以接收的传入 Webhook,以及 API 消费者可以选择实现的 Webhook。与 callbacks 功能密切相关,本节描述了由 API 调用以外的其他方式(例如,通过带外注册)发起的请求。键名称是引用每个 Webhook 的唯一字符串,而(可选地引用的)路径项对象描述了 API 提供者可能发起的请求以及预期的响应。 示例 可用。
components 组件对象 用于保存文档中各种架构的元素。
security [安全需求对象] 跨 API 可以使用哪些安全机制的声明。值的列表包括可以使用的替代安全需求对象。只需满足安全需求对象之一即可授权请求。各个操作可以覆盖此定义。若要使安全性可选,可以在数组中包含一个空的安全需求 ({})。
tags [标签对象] 文档使用的一系列标签以及其他元数据。标签的顺序可以用于反映解析工具对其的顺序。并非 操作对象 使用的所有标签都必须声明。未声明的标签可以随机组织或基于工具的逻辑组织。列表中的每个标签名称必须唯一。
externalDocs 外部文档对象 其他外部文档。

此对象可以使用 规范扩展 进行扩展。

4.8.2 Info 对象

该对象提供有关 API 的元数据。如果需要,客户端可以使用元数据,并且为了方便起见,可以在编辑或文档生成工具中呈现元数据。

4.8.2.1 固定字段
字段名称 类型 描述
title 字符串 必需。API 的标题。
summary 字符串 API 的简短摘要。
description 字符串 API 的描述。[CommonMark] 语法可以用于富文本表示。
termsOfService 字符串 API 的服务条款的 URL。这必须采用 URL 的形式。
contact 联系对象 公开 API 的联系信息。
license 许可证对象 公开 API 的许可证信息。
version 字符串 必需。OpenAPI 文档的版本(与 OpenAPI 规范版本 或 API 实现版本不同)。

此对象可以使用 规范扩展 进行扩展。

4.8.2.2 Info 对象示例
{
  "title": "Sample Pet Store App",
  "summary": "A pet store manager.",
  "description": "This is a sample server for a pet store.",
  "termsOfService": "https://example.com/terms/",
  "contact": {
    "name": "API Support",
    "url": "https://www.example.com/support",
    "email": "[email protected]"
  },
  "license": {
    "name": "Apache 2.0",
    "url": "https://www.apache.org/licenses/LICENSE-2.0.html"
  },
  "version": "1.0.1"
}
title: Sample Pet Store App
summary: A pet store manager.
description: This is a sample server for a pet store.
termsOfService: https://example.com/terms/
contact:
  name: API Support
  url: https://www.example.com/support
  email: [email protected]
license:
  name: Apache 2.0
  url: https://www.apache.org/licenses/LICENSE-2.0.html
version: 1.0.1

4.8.3 Contact 对象

公开 API 的联系信息。

4.8.3.1 固定字段
字段名称 类型 描述
name 字符串 联系人/组织的识别名称。
url 字符串 指向联系信息的 URL。这必须采用 URL 的形式。
email 字符串 联系人/组织的电子邮件地址。此地址必须为电子邮件地址格式。

此对象可以使用 规范扩展 进行扩展。

4.8.3.2 Contact 对象示例
{
  "name": "API Support",
  "url": "https://www.example.com/support",
  "email": "[email protected]"
}
name: API Support
url: https://www.example.com/support
email: [email protected]

4.8.4 License 对象

公开 API 的许可证信息。

4.8.4.1 固定字段
字段名称 类型 描述
名称 字符串 必需。API 使用的许可证名称。
标识符 字符串 API 的 [SPDX 许可证列表] 表达式。identifier 字段与 url 字段互斥。
URL 字符串 API 使用的许可证的 URL。此 URL必须为 URL 格式。url 字段与 identifier 字段互斥。

此对象可以使用 规范扩展 进行扩展。

4.8.4.2 License 对象示例
{
  "name": "Apache 2.0",
  "identifier": "Apache-2.0"
}
name: Apache 2.0
identifier: Apache-2.0

4.8.5 Server 对象

表示服务器的对象。

4.8.5.1 固定字段
字段名称 类型 描述
URL 字符串 必需。目标主机的 URL。此 URL 支持服务器变量,并且可以是相对的,以指示主机位置相对于 OpenAPI 文档正在提供服务的位置。当变量在 {括号}中命名时,将进行变量替换。
描述 字符串 一个可选字符串,描述 URL 指定的主机。[CommonMark 规范] 语法可以用于富文本表示。
变量 Map[string, 服务器变量对象] 变量名称与其值之间的映射。该值用于服务器的 URL 模板中的替换。

此对象可以使用 规范扩展 进行扩展。

4.8.5.2 Server 对象示例

单个服务器将描述为

{
  "url": "https://development.gigantic-server.com/v1",
  "description": "Development server"
}
url: https://development.gigantic-server.com/v1
description: Development server

以下显示了如何描述多个服务器,例如,在 OpenAPI 对象的 servers

{
  "servers": [
    {
      "url": "https://development.gigantic-server.com/v1",
      "description": "Development server"
    },
    {
      "url": "https://staging.gigantic-server.com/v1",
      "description": "Staging server"
    },
    {
      "url": "https://api.gigantic-server.com/v1",
      "description": "Production server"
    }
  ]
}
servers:
- url: https://development.gigantic-server.com/v1
  description: Development server
- url: https://staging.gigantic-server.com/v1
  description: Staging server
- url: https://api.gigantic-server.com/v1
  description: Production server

以下显示了如何将变量用于服务器配置

{
  "servers": [
    {
      "url": "https://{username}.gigantic-server.com:{port}/{basePath}",
      "description": "The production API server",
      "variables": {
        "username": {
          "default": "demo",
          "description": "this value is assigned by the service provider, in this example `gigantic-server.com`"
        },
        "port": {
          "enum": [
            "8443",
            "443"
          ],
          "default": "8443"
        },
        "basePath": {
          "default": "v2"
        }
      }
    }
  ]
}
servers:
- url: https://{username}.gigantic-server.com:{port}/{basePath}
  description: The production API server
  variables:
    username:
      # note! no enum here means it is an open value
      default: demo
      description: this value is assigned by the service provider, in this example `gigantic-server.com`
    port:
      enum:
        - '8443'
        - '443'
      default: '8443'
    basePath:
      # open meaning there is the opportunity to use special base paths as assigned by the provider, default is `v2`
      default: v2

4.8.6 Server Variable 对象

表示服务器 URL 模板替换的服务器变量的对象。

4.8.6.1 固定字段
字段名称 类型 描述
枚举 [string] 如果替换选项来自有限的集合,则要使用的字符串值的枚举。数组不得为空。
默认值 字符串 必需。要用于替换的默认值,如果提供备用值,则发送此值。请注意,此行为与Schema 对象处理默认值的方式不同,因为在这些情况下,参数值是可选的。如果定义了enum,则该值必须存在于枚举的值中。
描述 字符串 服务器变量的可选描述。[CommonMark 规范] 语法可以用于富文本表示。

此对象可以使用 规范扩展 进行扩展。

4.8.7 Components 对象

保存 OAS 不同方面的一组可重用对象。除非组件对象中定义的所有对象从组件对象外部的属性显式引用,否则它们对 API 没有任何影响。

4.8.7.1 固定字段
字段名称 类型 描述
模式 Map[string, Schema 对象] 一个对象,用于保存可重用的Schema 对象
响应 Map[string, 响应对象 | 引用对象] 一个对象,用于保存可重用的响应对象
参数 Map[string, 参数对象 | 引用对象] 一个对象,用于保存可重用的参数对象
示例 Map[string, 示例对象 | 引用对象] 一个对象,用于保存可重用的示例对象
请求体 Map[string, 请求体对象 | 引用对象] 一个对象,用于保存可重用的请求体对象
头部 Map[string, 头部对象 | 引用对象] 一个对象,用于保存可重用的头部对象
安全方案 Map[string, 安全方案对象 | 引用对象] 一个对象,用于保存可重用的安全方案对象
链接 Map[string, 链接对象 | 引用对象] 一个对象,用于保存可重用的链接对象
回调 Map[string, 回调对象 | 引用对象] 一个对象,用于保存可重用的回调对象
路径项 Map[string, 路径项对象 | 引用对象] 一个对象,用于保存可重用的路径项对象

此对象可以使用 规范扩展 进行扩展。

上面声明的所有固定字段都是对象,这些对象必须使用与正则表达式匹配的键:^[a-zA-Z0-9\.\-_]+$

字段名称示例

User
User_1
User_Name
user-name
my.org.User
4.8.7.2 Components 对象示例
"components": {
  "schemas": {
    "GeneralError": {
      "type": "object",
      "properties": {
        "code": {
          "type": "integer",
          "format": "int32"
        },
        "message": {
          "type": "string"
        }
      }
    },
    "Category": {
      "type": "object",
      "properties": {
        "id": {
          "type": "integer",
          "format": "int64"
        },
        "name": {
          "type": "string"
        }
      }
    },
    "Tag": {
      "type": "object",
      "properties": {
        "id": {
          "type": "integer",
          "format": "int64"
        },
        "name": {
          "type": "string"
        }
      }
    }
  },
  "parameters": {
    "skipParam": {
      "name": "skip",
      "in": "query",
      "description": "number of items to skip",
      "required": true,
      "schema": {
        "type": "integer",
        "format": "int32"
      }
    },
    "limitParam": {
      "name": "limit",
      "in": "query",
      "description": "max records to return",
      "required": true,
      "schema" : {
        "type": "integer",
        "format": "int32"
      }
    }
  },
  "responses": {
    "NotFound": {
      "description": "Entity not found."
    },
    "IllegalInput": {
      "description": "Illegal input for operation."
    },
    "GeneralError": {
      "description": "General Error",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/GeneralError"
          }
        }
      }
    }
  },
  "securitySchemes": {
    "api_key": {
      "type": "apiKey",
      "name": "api_key",
      "in": "header"
    },
    "petstore_auth": {
      "type": "oauth2",
      "flows": {
        "implicit": {
          "authorizationUrl": "https://example.org/api/oauth/dialog",
          "scopes": {
            "write:pets": "modify pets in your account",
            "read:pets": "read your pets"
          }
        }
      }
    }
  }
}
components:
  schemas:
    GeneralError:
      type: object
      properties:
        code:
          type: integer
          format: int32
        message:
          type: string
    Category:
      type: object
      properties:
        id:
          type: integer
          format: int64
        name:
          type: string
    Tag:
      type: object
      properties:
        id:
          type: integer
          format: int64
        name:
          type: string
  parameters:
    skipParam:
      name: skip
      in: query
      description: number of items to skip
      required: true
      schema:
        type: integer
        format: int32
    limitParam:
      name: limit
      in: query
      description: max records to return
      required: true
      schema:
        type: integer
        format: int32
  responses:
    NotFound:
      description: Entity not found.
    IllegalInput:
      description: Illegal input for operation.
    GeneralError:
      description: General Error
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/GeneralError'
  securitySchemes:
    api_key:
      type: apiKey
      name: api_key
      in: header
    petstore_auth:
      type: oauth2
      flows:
        implicit:
          authorizationUrl: https://example.org/api/oauth/dialog
          scopes:
            write:pets: modify pets in your account
            read:pets: read your pets

4.8.8 Paths 对象

保存到各个端点及其操作的相对路径。路径附加到Server 对象中的 URL 以构建完整 URL。由于访问控制列表 (ACL) 约束,路径可以为空。

4.8.8.1 模式化字段
字段模式 类型 描述
/{path} 路径项对象 到单个端点的相对路径。字段名称必须以正斜杠 (/) 开头。路径附加(无相对 URL 解析)到Server 对象url 字段中扩展的 URL 以构建完整 URL。路径模板是允许的。在匹配 URL 时,将先匹配具体的(非模板化的)路径,然后再匹配其模板化的对应路径。具有相同层次结构但不同模板名称的模板化路径不得存在,因为它们是相同的。在出现歧义匹配的情况下,由工具决定使用哪一个。

此对象可以使用 规范扩展 进行扩展。

4.8.8.2 路径模板匹配

假设以下路径,如果使用具体的定义 /pets/mine,则将首先匹配它

  /pets/{petId}
  /pets/mine

以下路径被认为是相同的且无效的

  /pets/{petId}
  /pets/{name}

以下可能导致歧义解析

  /{entity}/me
  /books/{id}
4.8.8.3 Paths 对象示例
{
  "/pets": {
    "get": {
      "description": "Returns all pets from the system that the user has access to",
      "responses": {
        "200": {         
          "description": "A list of pets.",
          "content": {
            "application/json": {
              "schema": {
                "type": "array",
                "items": {
                  "$ref": "#/components/schemas/pet"
                }
              }
            }
          }
        }
      }
    }
  }
}
/pets:
  get:
    description: Returns all pets from the system that the user has access to
    responses:
      '200':
        description: A list of pets.
        content:
          application/json:
            schema:
              type: array
              items:
                $ref: '#/components/schemas/pet'

4.8.9 Path Item 对象

描述单个路径上可用的操作。由于ACL 约束,路径项可以为空。路径本身仍然公开给文档查看器,但他们将不知道哪些操作和参数可用。

4.8.9.1 固定字段
字段名称 类型 描述
$ref 字符串 允许此路径项的引用定义。引用的结构必须路径项对象格式。如果定义的对象和引用的对象中都出现了路径项对象字段,则行为未定义。请参阅解析相对引用的规则。
摘要 字符串 一个可选的字符串摘要,旨在应用于此路径中的所有操作。
描述 字符串 一个可选的字符串描述,旨在应用于此路径中的所有操作。[CommonMark 规范] 语法可以用于富文本表示。
get 操作对象 在此路径上定义 GET 操作。
put 操作对象 在此路径上定义 PUT 操作。
post 操作对象 在此路径上定义 POST 操作。
delete 操作对象 在此路径上定义 DELETE 操作。
options 操作对象 在此路径上定义 OPTIONS 操作。
head 操作对象 在此路径上定义 HEAD 操作。
patch 操作对象 在此路径上定义 PATCH 操作。
trace 操作对象 在此路径上定义 TRACE 操作。
服务器 [服务器对象] 此路径中所有操作的服务的备用 server 数组。
参数 [参数对象 | 引用对象] 此路径下描述的所有操作都适用的参数列表。这些参数可以在操作级别覆盖,但不能在那里删除。列表不得包含重复的参数。唯一参数由名称位置的组合定义。该列表可以使用引用对象链接到在OpenAPI 对象的 components/parameters中定义的参数。

此对象可以使用 规范扩展 进行扩展。

4.8.9.2 Path Item 对象示例
{
  "get": {
    "description": "Returns pets based on ID",
    "summary": "Find pets by ID",
    "operationId": "getPetsById",
    "responses": {
      "200": {
        "description": "pet response",
        "content": {
          "*/*": {
            "schema": {
              "type": "array",
              "items": {
                "$ref": "#/components/schemas/Pet"
              }
            }
          }
        }
      },
      "default": {
        "description": "error payload",
        "content": {
          "text/html": {
            "schema": {
              "$ref": "#/components/schemas/ErrorModel"
            }
          }
        }
      }
    }
  },
  "parameters": [
    {
      "name": "id",
      "in": "path",
      "description": "ID of pet to use",
      "required": true,
      "schema": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "style": "simple"
    }
  ]
}
get:
  description: Returns pets based on ID
  summary: Find pets by ID
  operationId: getPetsById
  responses:
    '200':
      description: pet response
      content:
        '*/*' :
          schema:
            type: array
            items:
              $ref: '#/components/schemas/Pet'
    default:
      description: error payload
      content:
        'text/html':
          schema:
            $ref: '#/components/schemas/ErrorModel'
parameters:
- name: id
  in: path
  description: ID of pet to use
  required: true
  schema:
    type: array
    items:
      type: string 
  style: simple

4.8.10 Operation 对象

描述路径上的单个 API 操作。

4.8.10.1 固定字段
字段名称 类型 描述
标签 [string] 用于 API 文档控制的一组标签。标签可用于根据资源或任何其他限定符对操作进行逻辑分组。
摘要 字符串 操作作用的简短摘要。
描述 字符串 操作行为的详细说明。[CommonMark 规范] 语法可以用于富文本表示。
外部链接 外部文档对象 此操作的其他外部链接文档。
操作 ID 字符串 用于标识操作的唯一字符串。ID必须在 API 中描述的所有操作中唯一。operationId 值区分大小写。工具和库可以使用 operationId 唯一标识操作,因此,建议遵循常见的编程命名约定。
参数 [参数对象 | 引用对象] 适用于此操作的参数列表。如果参数已在路径项中定义,则新定义将覆盖它,但永远不会删除它。列表不得包含重复的参数。唯一参数由名称位置的组合定义。该列表可以使用引用对象链接到在OpenAPI 对象的 components/parameters中定义的参数。
请求体 请求体对象 | 引用对象 适用于此操作的请求体。requestBody 在 HTTP 1.1 规范 [RFC7231] 第 4.3.1 节 已明确定义请求体的语义的 HTTP 方法中得到完全支持。在 HTTP 规范含糊不清的其他情况下(例如 GETHEADDELETE),requestBody 是允许的,但没有明确定义的语义,并且如果可能,应该避免。
响应 响应对象 执行此操作后返回的可能响应列表。
回调 Map[string, 回调对象 | 引用对象] 与父操作相关的可能带外回调的映射。键是回调对象的唯一标识符。映射中的每个值都是一个回调对象,它描述了 API 提供者可能发起的请求以及预期的响应。
已弃用 布尔值 声明此操作已弃用。使用者应该避免使用声明的操作。默认值为 false
安全 [安全需求对象] 声明此操作可以使用哪些安全机制。值列表包含可使用的替代安全需求对象。只需要满足其中一个安全需求对象即可授权请求。若要使安全成为可选,可以在数组中包含一个空的安全需求 ({})。此定义会覆盖任何已声明的顶级 security。若要移除顶级安全声明,可以使用空数组。
服务器 [服务器对象] 此操作的服务替代 server 数组。如果在路径项对象或根级别指定了替代 server 对象,则此值将覆盖它。

此对象可以使用 规范扩展 进行扩展。

4.8.10.2 Operation 对象示例
{
  "tags": [
    "pet"
  ],
  "summary": "Updates a pet in the store with form data",
  "operationId": "updatePetWithForm",
  "parameters": [
    {
      "name": "petId",
      "in": "path",
      "description": "ID of pet that needs to be updated",
      "required": true,
      "schema": {
        "type": "string"
      }
    }
  ],
  "requestBody": {
    "content": {
      "application/x-www-form-urlencoded": {
        "schema": {
          "type": "object",
          "properties": {
            "name": {
              "description": "Updated name of the pet",
              "type": "string"
            },
            "status": {
              "description": "Updated status of the pet",
              "type": "string"
            }
          },
          "required": ["status"]
        }
      }
    }
  },
  "responses": {
    "200": {
      "description": "Pet updated.",
      "content": {
        "application/json": {},
        "application/xml": {}
      }
    },
    "405": {
      "description": "Method Not Allowed",
      "content": {
        "application/json": {},
        "application/xml": {}
      }
    }
  },
  "security": [
    {
      "petstore_auth": [
        "write:pets",
        "read:pets"
      ]
    }
  ]
}
tags:
- pet
summary: Updates a pet in the store with form data
operationId: updatePetWithForm
parameters:
- name: petId
  in: path
  description: ID of pet that needs to be updated
  required: true
  schema:
    type: string
requestBody:
  content:
    'application/x-www-form-urlencoded':
      schema:
       type: object
       properties:
          name:
            description: Updated name of the pet
            type: string
          status:
            description: Updated status of the pet
            type: string
       required:
         - status
responses:
  '200':
    description: Pet updated.
    content:
      'application/json': {}
      'application/xml': {}
  '405':
    description: Method Not Allowed
    content:
      'application/json': {}
      'application/xml': {}
security:
- petstore_auth:
  - write:pets
  - read:pets

4.8.11 External Documentation 对象

允许引用外部资源以获取扩展文档。

4.8.11.1 固定字段
字段名称 类型 描述
描述 字符串 目标文档的描述。[CommonMark 规范] 语法可以用于富文本表示。
URL 字符串 必需。目标文档的 URL。这必须采用 URL 的形式。

此对象可以使用 规范扩展 进行扩展。

4.8.11.2 External Documentation 对象示例
{
  "description": "Find more info here",
  "url": "https://example.com"
}
description: Find more info here
url: https://example.com

4.8.12 Parameter 对象

描述单个操作参数。

唯一参数由 名称位置 的组合定义。

4.8.12.1 参数位置

in 字段指定了四个可能的参数位置

  • path - 与 路径模板 一起使用,其中参数值实际上是操作 URL 的一部分。这并不包括 API 的主机或基本路径。例如,在 /items/{itemId} 中,路径参数为 itemId
  • query - 附加到 URL 的参数。例如,在 /items?id=### 中,查询参数为 id
  • header - 作为请求的一部分预期的自定义标头。请注意,[RFC7230] 第 22 页 指出标头名称不区分大小写。
  • cookie - 用于将特定的 cookie 值传递给 API。
4.8.12.2 固定字段
字段名称 类型 描述
名称 字符串 必需。参数的名称。参数名称区分大小写
  • 如果 in"path",则 name 字段必须对应于 路径 对象中 路径对象路径 字段中出现的模板表达式。有关更多信息,请参阅 路径模板
  • 如果 in"header"name 字段为 "Accept""Content-Type""Authorization",则忽略参数定义。
  • 对于所有其他情况,name 对应于 in 属性使用的参数名称。
in 字符串 必需。参数的位置。可能的值为 "query""header""path""cookie"
描述 字符串 参数的简要描述。这可能包含使用示例。[CommonMark 规范] 语法可以用于富文本表示。
必需 布尔值 确定此参数是否为必需。如果 参数位置"path",则此属性为必需,其值必须true。否则,可以包含此属性,其默认值为 false
已弃用 布尔值 指定参数已弃用,停止使用。默认值为 false
允许空值 布尔值 设置传递空值参数的能力。这仅对 query 参数有效,并允许发送具有空值的参数。默认值为 false。如果使用了 style,并且如果行为为 n/a(无法序列化),则忽略 allowEmptyValue 的值。不建议使用此属性,因为它可能会在以后的修订版中删除。

参数序列化的规则以两种方式之一指定。对于更简单的场景,schemastyle 可以描述参数的结构和语法。

字段名称 类型 描述
样式 字符串 根据参数值的类型描述参数值将如何序列化。默认值(基于 in 的值):对于 query - form;对于 path - simple;对于 header - simple;对于 cookie - form
展开 布尔值 当此值为 true 时,类型为 arrayobject 的参数值会为数组的每个值或映射的键值对生成单独的参数。对于其他类型的参数,此属性无效。当 styleform 时,默认值为 true。对于所有其他样式,默认值为 false
允许保留字符 布尔值 确定参数值否允许包含 [RFC3986] 第 2.2 节 定义的保留字符 :/?#[]@!$&'()*+,;=,而无需进行百分比编码。此属性仅适用于 in 值为 query 的参数。默认值为 false
模式 模式对象 定义用于参数的类型的模式。
示例 任何 参数潜在值的示例。如果存在,则示例与指定的模式和编码属性匹配。example 字段与 examples 字段互斥。此外,如果引用包含示例的 schema,则 example覆盖模式提供的示例。若要表示 JSON 或 YAML 中无法自然表示的媒体类型的示例,字符串值可以包含示例,并在必要时进行转义。
示例 Map[ string, 示例对象 | 引用对象] 参数潜在值的示例。每个示例包含以参数编码中指定的正确格式表示的值。examples 字段与 example 字段互斥。此外,如果引用包含示例的 schema,则 examples覆盖模式提供的示例。

对于更复杂的场景,content 属性可以定义参数的媒体类型和模式。参数必须包含 schema 属性或 content 属性,但不能同时包含两者。当与 schema 对象一起提供 exampleexamples 时,示例必须遵循参数规定的序列化策略。

字段名称 类型 描述
内容 Map[string, 媒体类型对象] 包含参数表示形式的映射。键是媒体类型,值描述它。映射必须仅包含一个条目。
4.8.12.3 样式值

为了支持序列化简单参数的常用方法,定义了一组 style 值。

样式 类型 in 注释
矩阵 primitivearrayobject 路径 [RFC6570] 第 3.2.7 节 定义的路径样式参数
标签 primitivearrayobject 路径 [RFC6570] 第 3.2.5 节 定义的标签样式参数
表单 primitivearrayobject querycookie [RFC6570] 第 3.2.8 节 定义的表单样式参数。此选项使用 csv(当 explode 为 false 时)或 multi(当 explode 为 true 时)值替换 OpenAPI 2.0 中的 collectionFormat
简单 数组 pathheader [RFC6570] 第 3.2.2 节 定义的简单样式参数。此选项使用 csv 值替换 OpenAPI 2.0 中的 collectionFormat
空格分隔 arrayobject 查询 空格分隔的数组或对象值。此选项替换 OpenAPI 2.0 中等于 ssvcollectionFormat
管道分隔 arrayobject 查询 管道分隔的数组或对象值。此选项替换 OpenAPI 2.0 中等于 pipescollectionFormat
深度对象 对象 查询 提供了一种使用表单参数呈现嵌套对象简单的方法。
4.8.12.4 样式示例

假设名为 color 的参数具有以下值之一

   string -> "blue"
   array -> ["blue","black","brown"]
   object -> { "R": 100, "G": 200, "B": 150 }

下表显示了每个值的呈现差异示例。

样式 展开 字符串 数组 对象
矩阵 false ;color ;color=blue ;color=blue,black,brown ;color=R,100,G,200,B,150
矩阵 true ;color ;color=blue ;color=blue;color=black;color=brown ;R=100;G=200;B=150
标签 false . .blue .blue.black.brown .R.100.G.200.B.150
标签 true . .blue .blue.black.brown .R=100.G=200.B=150
表单 false color= color=blue color=blue,black,brown color=R,100,G,200,B,150
表单 true color= color=blue color=blue&color=black&color=brown R=100&G=200&B=150
简单 false n/a blue blue,black,brown R,100,G,200,B,150
简单 true n/a blue blue,black,brown R=100,G=200,B=150
空格分隔 false n/a n/a blue%20black%20brown R%20100%20G%20200%20B%20150
管道分隔 false n/a n/a blue|black|brown R|100|G|200|B|150
深度对象 true n/a n/a n/a color[R]=100&color[G]=200&color[B]=150

此对象可以使用 规范扩展 进行扩展。

4.8.12.5 Parameter 对象示例

具有 64 位整数数组的标头参数

{
  "name": "token",
  "in": "header",
  "description": "token to be passed as a header",
  "required": true,
  "schema": {
    "type": "array",
    "items": {
      "type": "integer",
      "format": "int64"
    }
  },
  "style": "simple"
}
name: token
in: header
description: token to be passed as a header
required: true
schema:
  type: array
  items:
    type: integer
    format: int64
style: simple

字符串值的路径参数

{
  "name": "username",
  "in": "path",
  "description": "username to fetch",
  "required": true,
  "schema": {
    "type": "string"
  }
}
name: username
in: path
description: username to fetch
required: true
schema:
  type: string

字符串值的可选查询参数,通过重复查询参数允许多个值

{
  "name": "id",
  "in": "query",
  "description": "ID of the object to fetch",
  "required": false,
  "schema": {
    "type": "array",
    "items": {
      "type": "string"
    }
  },
  "style": "form",
  "explode": true
}
name: id
in: query
description: ID of the object to fetch
required: false
schema:
  type: array
  items:
    type: string
style: form
explode: true

自由格式查询参数,允许特定类型的未定义参数

{
  "in": "query",
  "name": "freeForm",
  "schema": {
    "type": "object",
    "additionalProperties": {
      "type": "integer"
    },
  },
  "style": "form"
}
in: query
name: freeForm
schema:
  type: object
  additionalProperties:
    type: integer
style: form

使用 content 定义序列化的复杂参数

{
  "in": "query",
  "name": "coordinates",
  "content": {
    "application/json": {
      "schema": {
        "type": "object",
        "required": [
          "lat",
          "long"
        ],
        "properties": {
          "lat": {
            "type": "number"
          },
          "long": {
            "type": "number"
          }
        }
      }
    }
  }
}
in: query
name: coordinates
content:
  application/json:
    schema:
      type: object
      required:
        - lat
        - long
      properties:
        lat:
          type: number
        long:
          type: number

4.8.13 Request Body 对象

描述单个请求体。

4.8.13.1 固定字段
字段名称 类型 描述
描述 字符串 请求体的简要描述。这可能包含使用示例。[CommonMark 规范] 语法可以用于富文本表示。
内容 Map[string, 媒体类型对象] 必需。请求体的内容。键是媒体类型或媒体类型范围,请参阅 [RFC7231] 附录 D,值描述它。对于匹配多个键的请求,仅适用最具体的键。例如,text/plain 覆盖 text/*
必需 布尔值 确定请求中是否需要请求体。默认为 false

此对象可以使用 规范扩展 进行扩展。

4.8.13.2 Request Body 示例

具有已引用模型定义的请求体。

{
  "description": "user to add to the system",
  "content": {
    "application/json": {
      "schema": {
        "$ref": "#/components/schemas/User"
      },
      "examples": {
          "user" : {
            "summary": "User Example",
            "externalValue": "https://foo.bar/examples/user-example.json"
          }
        }
    },
    "application/xml": {
      "schema": {
        "$ref": "#/components/schemas/User"
      },
      "examples": {
          "user" : {
            "summary": "User example in XML",
            "externalValue": "https://foo.bar/examples/user-example.xml"
          }
        }
    },
    "text/plain": {
      "examples": {
        "user" : {
            "summary": "User example in Plain text",
            "externalValue": "https://foo.bar/examples/user-example.txt"
        }
      }
    },
    "*/*": {
      "examples": {
        "user" : {
            "summary": "User example in other format",
            "externalValue": "https://foo.bar/examples/user-example.whatever"
        }
      }
    }
  }
}
description: user to add to the system
content:
  'application/json':
    schema:
      $ref: '#/components/schemas/User'
    examples:
      user:
        summary: User Example
        externalValue: 'https://foo.bar/examples/user-example.json'
  'application/xml':
    schema:
      $ref: '#/components/schemas/User'
    examples:
      user:
        summary: User example in XML
        externalValue: 'https://foo.bar/examples/user-example.xml'
  'text/plain':
    examples:
      user:
        summary: User example in Plain text
        externalValue: 'https://foo.bar/examples/user-example.txt'
  '*/*':
    examples:
      user:
        summary: User example in other format
        externalValue: 'https://foo.bar/examples/user-example.whatever'

作为字符串值数组的正文参数

{
  "description": "user to add to the system",
  "required": true,
  "content": {
    "text/plain": {
      "schema": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    }
  }
}
description: user to add to the system
required: true
content:
  text/plain:
    schema:
      type: array
      items:
        type: string

4.8.14 Media Type 对象

每个媒体类型对象都为其键标识的媒体类型提供模式和示例。

4.8.14.1 固定字段
字段名称 类型 描述
模式 模式对象 定义请求、响应或参数内容的模式。
示例

任何 媒体类型的示例。示例对象应该采用媒体类型指定的正确格式。example 字段与 examples 字段互斥。此外,如果引用包含示例的 schema,则 example必须覆盖 schema 提供的示例。
examples Map[ string, 示例对象 | 引用对象] 媒体类型的示例。每个示例对象应该匹配媒体类型,如果存在,则匹配指定的 schema。examples 字段与 example 字段互斥。此外,如果引用包含示例的 schema,则 examples必须覆盖 schema 提供的示例。
encoding Map[string, 编码对象] 属性名称与其编码信息之间的映射。键(即属性名称)必须在 schema 中作为属性存在。编码对象必须仅在媒体类型为 multipartapplication/x-www-form-urlencoded 时应用于 requestBody 对象。

此对象可以使用 规范扩展 进行扩展。

4.8.14.2 Media Type 示例
{
  "application/json": {
    "schema": {
         "$ref": "#/components/schemas/Pet"
    },
    "examples": {
      "cat" : {
        "summary": "An example of a cat",
        "value":
          {
            "name": "Fluffy",
            "petType": "Cat",
            "color": "White",
            "gender": "male",
            "breed": "Persian"
          }
      },
      "dog": {
        "summary": "An example of a dog with a cat's name",
        "value" :  {
          "name": "Puma",
          "petType": "Dog",
          "color": "Black",
          "gender": "Female",
          "breed": "Mixed"
        },
      "frog": {
          "$ref": "#/components/examples/frog-example"
        }
      }
    }
  }
}
application/json:
  schema:
    $ref: "#/components/schemas/Pet"
  examples:
    cat:
      summary: An example of a cat
      value:
        name: Fluffy
        petType: Cat
        color: White
        gender: male
        breed: Persian
    dog:
      summary: An example of a dog with a cat's name
      value:
        name: Puma
        petType: Dog
        color: Black
        gender: Female
        breed: Mixed
    frog:
      $ref: "#/components/examples/frog-example"
4.8.14.3 文件上传注意事项

与 2.0 规范相反,OpenAPI 中的文件输入/输出内容使用与任何其他 schema 类型相同的语义进行描述。

与 3.0 规范相反,format 关键字对 schema 的内容编码没有影响。JSON Schema 提供了一个 contentEncoding 关键字,可用于指定 schema 的 Content-EncodingcontentEncoding 关键字支持 [RFC4648] 中定义的所有编码,包括“base64”和“base64url”,以及 [RFC2045] 第 6.7 节 中的“quoted-printable”。contentEncoding 关键字指定的编码独立于请求或响应中的 Content-Type 标头或多部分正文的元数据中指定的编码 - 当两者都存在时,contentEncoding 中指定的编码将首先应用,然后应用 Content-Type 标头中指定的编码。

JSON Schema 还提供了一个 contentMediaType 关键字。但是,当媒体类型已由媒体类型对象的键或 编码对象contentType 字段指定时,如果存在,则必须忽略 contentMediaType 关键字。

示例

以二进制 (octet-stream) 传输的内容可以省略 schema

# a PNG image as a binary file:
content:
    image/png: {}
# an arbitrary binary file:
content:
    application/octet-stream: {}

使用 base64 编码传输的二进制内容

content:
    image/png:
        schema:
            type: string
            contentMediaType: image/png
            contentEncoding: base64

请注意,Content-Type 保持为 image/png,描述有效负载的语义。JSON Schema 的 typecontentEncoding 字段说明有效负载作为文本传输。JSON Schema 的 contentMediaType 在技术上是冗余的,但可由可能不知道 OpenAPI 上下文的 JSON Schema 工具使用。

这些示例适用于文件上传的输入有效负载或响应有效负载。

用于在 POST 操作中提交文件的 requestBody 可能如下例所示

requestBody:
  content:
    application/octet-stream: {}

此外,可以指定特定的媒体类型

# multiple, specific media types may be specified:
requestBody:
  content:
    # a binary file of type png or jpeg
    image/jpeg: {}
    image/png: {}

要上传多个文件,必须使用 multipart 媒体类型

requestBody:
  content:
    multipart/form-data:
      schema:
        properties:
          # The property name 'file' will be used for all files.
          file:
            type: array
            items: {}

如以下 multipart/form-data 部分所示,items 的空 schema 表示 application/octet-stream 的媒体类型。

4.8.14.4 对 x-www-form-urlencoded 请求体的支持

要使用 [RFC1866] 通过表单 URL 编码提交内容,可以使用以下定义

requestBody:
  content:
    application/x-www-form-urlencoded:
      schema:
        type: object
        properties:
          id:
            type: string
            format: uuid
          address:
            # complex types are stringified to support RFC 1866
            type: object
            properties: {}

在此示例中,requestBody 中的内容必须在传递到服务器时根据 [RFC1866] 进行字符串化。此外,address 字段的复杂对象也将被字符串化。

application/x-www-form-urlencoded 内容类型中传递复杂对象时,此类属性的默认序列化策略在 编码对象style 属性中描述为 form

4.8.14.5 multipart 内容的特殊注意事项

multipart/form-data 用作将请求正文传输到操作时的 Content-Type 非常常见。与 2.0 相比,需要使用 schema 来定义使用 multipart 内容时操作的输入参数。这支持复杂结构以及对多个文件上传的支持机制。

multipart/form-data 请求正文中,每个 schema 属性或 schema 数组属性的每个元素都在有效负载中占据一部分,并具有 [RFC7578] 定义的内部标头。可以在关联的 编码对象 中指定 multipart/form-data 请求正文的每个属性的序列化策略。

在传递 multipart 类型时,可以使用边界来分隔正在传输的内容的部分 - 因此,为 multipart 定义了以下默认 Content-Type

  • 如果属性是原始类型或原始值的数组,则默认的 Content-Type 为 text/plain
  • 如果属性是复杂类型或复杂值的数组,则默认的 Content-Type 为 application/json
  • 如果属性是带 contentEncodingtype: string,则默认的 Content-Type 为 application/octet-stream

根据 JSON Schema 规范,如果不存在 contentEncoding,则 contentMediaType 将被视为存在 contentEncoding: identity。虽然这对于将 text/html 等文本文档嵌入到 JSON 字符串中很有用,但对于 multipart/form-data 部分则没有用,因为它只会导致文档被视为 text/plain 而不是其实际媒体类型。如果不需要 contentEncoding,请使用不带 contentMediaType 的编码对象。

示例

requestBody:
  content:
    multipart/form-data:
      schema:
        type: object
        properties:
          id:
            type: string
            format: uuid
          address:
            # default Content-Type for objects is `application/json`
            type: object
            properties: {}
          profileImage:
            # Content-Type for application-level encoded resource is `text/plain`
            type: string
            contentMediaType: image/png
            contentEncoding: base64
          children:
            # default Content-Type for arrays is based on the _inner_ type (`text/plain` here)
            type: array
            items:
              type: string
          addresses:
            # default Content-Type for arrays is based on the _inner_ type (object shown, so `application/json` in this example)
            type: array
            items:
              type: object
              $ref: '#/components/schemas/Address'

引入了 encoding 属性,使您可以控制 multipart 请求正文部分的序列化。此属性适用于 multipartapplication/x-www-form-urlencoded 请求正文。

4.8.15 Encoding 对象

应用于单个 schema 属性的单个编码定义。

4.8.15.1 固定字段
字段名称 类型 描述
contentType 字符串 用于编码特定属性的 Content-Type。默认值取决于属性类型:对于 object - application/json;对于 array - 默认值基于内部类型定义;对于所有其他情况,默认值为 application/octet-stream。该值可以是特定的媒体类型(例如 application/json)、通配符媒体类型(例如 image/*)或两种类型的逗号分隔列表。
headers Map[string, 头部对象 | 引用对象] 允许提供其他信息作为标头的映射,例如 Content-DispositionContent-Type 单独描述,并且必须在本节中忽略。如果请求正文媒体类型不是 multipart,则必须忽略此属性。
style 字符串 根据其类型描述特定属性值将如何序列化。有关 参数对象style 属性的详细信息,请参阅。行为遵循与 query 参数相同的值,包括默认值。如果请求正文媒体类型不是 application/x-www-form-urlencodedmultipart/form-data,则必须忽略此属性。如果显式定义了值,则必须忽略 contentType(隐式或显式)的值。
explode 布尔值 如果此值为 true,则类型为 arrayobject 的属性值将为数组的每个值或映射的键值对生成单独的参数。对于其他类型的属性,此属性无效。当 styleform 时,默认值为 true。对于所有其他样式,默认值为 false。如果请求正文媒体类型不是 application/x-www-form-urlencodedmultipart/form-data,则必须忽略此属性。如果显式定义了值,则必须忽略 contentType(隐式或显式)的值。
allowReserved 布尔值 确定参数值应该允许 [RFC3986] 第 2.2 节 :/?#[]@!$&'()*+,;= 定义的保留字符是否包含在内,而无需进行百分比编码。默认值为 false。如果请求正文媒体类型不是 application/x-www-form-urlencodedmultipart/form-data,则必须忽略此属性。如果显式定义了值,则必须忽略 contentType(隐式或显式)的值。

此对象可以使用 规范扩展 进行扩展。

4.8.15.2 Encoding 对象示例
requestBody:
  content:
    multipart/form-data:
      schema:
        type: object
        properties:
          id:
            # default is text/plain
            type: string
            format: uuid
          address:
            # default is application/json
            type: object
            properties: {}
          historyMetadata:
            # need to declare XML format!
            description: metadata in XML format
            type: object
            properties: {}
          profileImage: {}
      encoding:
        historyMetadata:
          # require XML Content-Type in utf-8 encoding
          contentType: application/xml; charset=utf-8
        profileImage:
          # only accept png/jpeg
          contentType: image/png, image/jpeg
          headers:
            X-Rate-Limit-Limit:
              description: The number of allowed requests in the current period
              schema:
                type: integer

4.8.16 Responses 对象

操作预期响应的容器。该容器将 HTTP 响应代码映射到预期响应。

文档不一定需要涵盖所有可能的 HTTP 响应代码,因为它们可能事先未知。但是,文档需要涵盖成功操作响应和任何已知错误。

default可以用作未由 Responses Object 单独涵盖的所有 HTTP 代码的默认响应对象。

Responses Object必须包含至少一个响应代码,如果仅提供一个响应代码,则应该是成功操作调用的响应。

4.8.16.1 固定字段
字段名称 类型 描述
default 响应对象 | 引用对象 除为特定 HTTP 响应代码声明的响应之外的响应文档。使用此字段来涵盖未声明的响应。
4.8.16.2 模式化字段
字段模式 类型 描述
HTTP 状态代码 响应对象 | 引用对象 任何 HTTP 状态代码 都可以用作属性名称,但每个代码只有一个属性,以描述该 HTTP 状态代码的预期响应。为了在 JSON 和 YAML 之间兼容,此字段必须用引号括起来(例如,“200”)。要定义一系列响应代码,此字段可以包含大写通配符 X。例如,2XX 表示 [200-299] 之间的所有响应代码。仅允许以下范围定义:1XX2XX3XX4XX5XX。如果使用显式代码定义了响应,则该显式代码定义优先于该代码的范围定义。

此对象可以使用 规范扩展 进行扩展。

4.8.16.3 Responses 对象示例

成功操作的 200 响应以及其他响应的默认响应(暗示错误)

{
  "200": {
    "description": "a pet to be returned",
    "content": {
      "application/json": {
        "schema": {
          "$ref": "#/components/schemas/Pet"
        }
      }
    }
  },
  "default": {
    "description": "Unexpected error",
    "content": {
      "application/json": {
        "schema": {
          "$ref": "#/components/schemas/ErrorModel"
        }
      }
    }
  }
}
'200':
  description: a pet to be returned
  content:
    application/json:
      schema:
        $ref: '#/components/schemas/Pet'
default:
  description: Unexpected error
  content:
    application/json:
      schema:
        $ref: '#/components/schemas/ErrorModel'

4.8.17 Response 对象

描述来自 API 操作的单个响应,包括基于响应的操作的设计时静态 链接

4.8.17.1 固定字段
字段名称 类型 描述
description 字符串 必需。响应的描述。[CommonMark] 语法可以用于富文本表示。
headers Map[string, 头部对象 | 引用对象] 将标头名称映射到其定义。[RFC7230] 第 22 页 指出标头名称不区分大小写。如果使用名称 "Content-Type" 定义了响应标头,则必须忽略它。
content Map[string, 媒体类型对象] 包含潜在响应有效负载描述的地图。键是媒体类型或媒体类型范围,请参阅[RFC7231] 附录 D,其值描述了它。对于匹配多个键的响应,只有最具体的键适用。例如,text/plain 覆盖 text/*。
链接 Map[string, 链接对象 | 引用对象] 可以从响应中跟随的操作链接的映射。映射的键是链接的简称,遵循组件对象名称的命名约束。

此对象可以使用 规范扩展 进行扩展。

4.8.17.2 Response 对象示例

复杂类型数组的响应

{
  "description": "A complex object array response",
  "content": {
    "application/json": {
      "schema": {
        "type": "array",
        "items": {
          "$ref": "#/components/schemas/VeryComplexType"
        }
      }
    }
  }
}
description: A complex object array response
content:
  application/json:
    schema:
      type: array
      items:
        $ref: '#/components/schemas/VeryComplexType'

带有字符串类型的响应

{
  "description": "A simple string response",
  "content": {
    "text/plain": {
      "schema": {
        "type": "string"
      }
    }
  }

}
description: A simple string response
content:
  text/plain:
    schema:
      type: string

带有标头的纯文本响应

{
  "description": "A simple string response",
  "content": {
    "text/plain": {
      "schema": {
        "type": "string",
        "example": "whoa!"
      }
    }
  },
  "headers": {
    "X-Rate-Limit-Limit": {
      "description": "The number of allowed requests in the current period",
      "schema": {
        "type": "integer"
      }
    },
    "X-Rate-Limit-Remaining": {
      "description": "The number of remaining requests in the current period",
      "schema": {
        "type": "integer"
      }
    },
    "X-Rate-Limit-Reset": {
      "description": "The number of seconds left in the current period",
      "schema": {
        "type": "integer"
      }
    }
  }
}
description: A simple string response
content:
  text/plain:
    schema:
      type: string
    example: 'whoa!'
headers:
  X-Rate-Limit-Limit:
    description: The number of allowed requests in the current period
    schema:
      type: integer
  X-Rate-Limit-Remaining:
    description: The number of remaining requests in the current period
    schema:
      type: integer
  X-Rate-Limit-Reset:
    description: The number of seconds left in the current period
    schema:
      type: integer

没有返回值的响应

{
  "description": "object created"
}
description: object created

4.8.18 Callback 对象

与父操作相关的可能的带外回调的映射。映射中的每个值都是一个路径项对象,它描述了一组可能由 API 提供者发起的请求和预期的响应。用于标识路径项对象的键值是在运行时计算的表达式,用于标识用于回调操作的 URL。

要描述来自 API 提供者的传入请求,使其独立于其他 API 调用,请使用webhooks字段。

4.8.18.1 模式化字段
字段模式 类型 描述
{表达式} 路径项对象 | 引用对象 用于定义回调请求和预期响应的路径项对象或对它的引用。提供了完整示例

此对象可以使用 规范扩展 进行扩展。

4.8.18.2 键表达式

用于标识路径项对象的键是一个运行时表达式,可以在运行时 HTTP 请求/响应的上下文中进行计算,以标识用于回调请求的 URL。一个简单的例子可能是$request.body#/url。但是,使用运行时表达式可以访问完整的 HTTP 消息。这包括访问 JSON 指针[RFC6901]可以引用的主体任何部分。

例如,给定以下 HTTP 请求

POST /subscribe/myevent?queryUrl=https://clientdomain.com/stillrunning HTTP/1.1
Host: example.org
Content-Type: application/json
Content-Length: 187

{
  "failedUrl" : "https://clientdomain.com/failed",
  "successUrls" : [
    "https://clientdomain.com/fast",
    "https://clientdomain.com/medium",
    "https://clientdomain.com/slow"
  ]
}

201 Created
Location: https://example.org/subscription/1

以下示例显示了各种表达式的计算方式,假设回调操作具有名为eventType的路径参数和名为queryUrl的查询参数。

表达式
$url https://example.org/subscribe/myevent?queryUrl=https://clientdomain.com/stillrunning
$method POST
$request.path.eventType myevent
$request.query.queryUrl https://clientdomain.com/stillrunning
$request.header.content-Type application/json
$request.body#/failedUrl https://clientdomain.com/failed
$request.body#/successUrls/2 https://clientdomain.com/medium
$response.header.Location https://example.org/subscription/1
4.8.18.3 Callback 对象示例

以下示例使用用户提供的queryUrl查询字符串参数来定义回调 URL。这是一个如何使用回调对象来描述与订阅操作相关的 WebHook 回调以启用 WebHook 注册的示例。

myCallback:
  '{$request.query.queryUrl}':
    post:
      requestBody:
        description: Callback payload
        content:
          'application/json':
            schema:
              $ref: '#/components/schemas/SomePayload'
      responses:
        '200':
          description: callback successfully processed

以下示例显示了一个回调,其中服务器是硬编码的,但查询字符串参数是从请求主体中的idemail属性填充的。

transactionCallback:
  'http://notificationServer.com?transactionId={$request.body#/id}&email={$request.body#/email}':
    post:
      requestBody:
        description: Callback payload
        content:
          'application/json':
            schema:
              $ref: '#/components/schemas/SomePayload'
      responses:
        '200':
          description: callback successfully processed

4.8.19 Example 对象

4.8.19.1 固定字段
字段名称 类型 描述
摘要 字符串 示例的简短描述。
描述 字符串 示例的详细描述。[CommonMark] 语法可以用于富文本表示。
任何 嵌入的文字示例。value字段和externalValue字段是互斥的。要表示无法以 JSON 或 YAML 自然表示的媒体类型的示例,请使用字符串值包含示例,并在必要时进行转义。
外部值 字符串 指向文字示例的 URI。这提供了引用无法轻松包含在 JSON 或 YAML 文档中的示例的功能。value字段和externalValue字段是互斥的。请参阅解析相对引用的规则。

此对象可以使用 规范扩展 进行扩展。

在所有情况下,示例值都应与其关联值的类型模式兼容。工具实现可以选择自动验证兼容性,并在不兼容时拒绝示例值。

4.8.19.2 Example 对象示例

在请求主体中

requestBody:
  content:
    'application/json':
      schema:
        $ref: '#/components/schemas/Address'
      examples:
        foo:
          summary: A foo example
          value: {"foo": "bar"}
        bar:
          summary: A bar example
          value: {"bar": "baz"}
    'application/xml':
      examples:
        xmlExample:
          summary: This is an example in XML
          externalValue: 'https://example.org/examples/address-example.xml'
    'text/plain':
      examples:
        textExample:
          summary: This is a text example
          externalValue: 'https://foo.bar/examples/address-example.txt'

在参数中

parameters:
  - name: 'zipCode'
    in: 'query'
    schema:
      type: 'string'
      format: 'zip-code'
    examples:
      zip-example:
        $ref: '#/components/examples/zip-example'

在响应中

responses:
  '200':
    description: your car appointment has been booked
    content:
      application/json:
        schema:
          $ref: '#/components/schemas/SuccessResponse'
        examples:
          confirmation-success:
            $ref: '#/components/examples/confirmation-success'

4.8.21 Header 对象

标头对象遵循参数对象的结构,并进行了以下更改

  1. name不得指定,它在相应的headers映射中给出。
  2. in不得指定,它隐式地在header中。
  3. 受位置影响的所有特征必须适用于header的位置(例如,style)。
4.8.21.1 Header 对象示例

类型为integer的简单标头

{
  "description": "The number of allowed requests in the current period",
  "schema": {
    "type": "integer"
  }
}
description: The number of allowed requests in the current period
schema:
  type: integer

4.8.22 Tag 对象

向由操作对象使用的单个标签添加元数据。每个在操作对象实例中定义的标签不一定都需要一个标签对象。

4.8.22.1 固定字段
字段名称 类型 描述
名称 字符串 必需。标签的名称。
描述 字符串 标签的描述。[CommonMark] 语法可以用于富文本表示。
外部文档 外部文档对象 此标签的其他外部文档。

此对象可以使用 规范扩展 进行扩展。

4.8.22.2 Tag 对象示例
{
	"name": "pet",
	"description": "Pets operations"
}
name: pet
description: Pets operations

4.8.23 Reference 对象

一个简单的对象,用于在 OpenAPI 文档中(内部和外部)引用其他组件。

$ref 字符串值包含一个 URI [RFC3986],它标识被引用值的位置。

请参阅有关解析相对引用的规则。

4.8.23.1 固定字段
字段名称 类型 描述
$ref 字符串 必需。引用标识符。此标识符必须采用 URI 的形式。
summary 字符串 简短摘要,默认情况下应该覆盖被引用组件的摘要。如果被引用的对象类型不允许使用 summary 字段,则此字段无效。
description 字符串 描述,默认情况下应该覆盖被引用组件的描述。[CommonMark] 语法可以用于富文本表示。如果被引用的对象类型不允许使用 description 字段,则此字段无效。

此对象不能扩展其他属性,任何添加的属性都将被忽略。

请注意,此属性限制是引用对象与包含 $ref 关键字的Schema 对象之间的区别。

4.8.23.2 Reference 对象示例
{
	"$ref": "#/components/schemas/Pet"
}
$ref: '#/components/schemas/Pet'
4.8.23.3 相对 Schema 文档示例
{
  "$ref": "Pet.json"
}
$ref: Pet.yaml
4.8.23.4 包含嵌入式 Schema 的相对文档示例
{
  "$ref": "definitions.json#/Pet"
}
$ref: definitions.yaml#/Pet

4.8.24 Schema 对象

Schema 对象允许定义输入和输出数据类型。这些类型可以是对象,也可以是基本类型和数组。此对象是JSON Schema 规范草案 2020-12的超集。

有关属性的更多信息,请参阅JSON Schema 核心JSON Schema 验证

除非另有说明,否则属性定义遵循 JSON Schema 的定义,并且不添加任何其他语义。在 JSON Schema 指出行为由应用程序定义(例如,对于注释)的地方,OAS 也将语义定义推迟到使用 OpenAPI 文档的应用程序。

4.8.24.1 属性

OpenAPI Schema 对象方言被定义为除了 JSON Schema 草案 2020-12 中指定的词汇表之外,还需要OAS 基本词汇表通用元模式

此规范版本的 OpenAPI Schema 对象方言由 URI https://spec.openapis.org.cn/oas/3.1/dialect/base“OAS 方言模式 ID”)标识。

以下属性取自 JSON Schema 规范,但其定义已由 OAS 扩展

  • description - [CommonMark] 语法可以用于富文本表示。
  • format - 有关更多详细信息,请参阅数据类型格式。虽然依赖于 JSON Schema 定义的格式,但 OAS 提供了一些其他预定义格式。

除了构成 OAS 方言的 JSON Schema 属性外,Schema 对象还支持来自任何其他词汇表的关键字或完全任意的属性。

OpenAPI 规范的基本词汇表包含以下关键字

4.8.24.2 固定字段
字段名称 类型 描述
discriminator Discriminator 对象 添加对多态性的支持。鉴别器是一个对象名称,用于区分可能满足有效负载描述的其他模式。有关更多详细信息,请参阅组合和继承
xml XML 对象 此对象可以仅用于属性模式。它对根模式没有影响。添加其他元数据以描述此属性的 XML 表示形式。
externalDocs 外部文档对象 此模式的其他外部文档。
example 任何 一个自由格式的属性,用于包含此模式实例的示例。为了表示 JSON 或 YAML 中无法自然表示的示例,可以使用字符串值来包含示例,并在必要时进行转义。

已弃用:example 属性已弃用,取而代之的是 JSON Schema examples 关键字。不鼓励使用 example,并且此规范的更高版本可能会将其删除。

此对象可以扩展规范扩展,但如前所述,其他属性可以省略此对象中的 x- 前缀。

4.8.24.2.1 组合和继承(多态)

OpenAPI 规范允许使用 JSON Schema 的 allOf 属性组合和扩展模型定义,实际上提供了模型组合。allOf 获取一个对象定义数组,这些定义独立验证,但共同组成一个对象。

虽然组合提供了模型的可扩展性,但它并不意味着模型之间存在层次结构。为了支持多态性,OpenAPI 规范添加了 discriminator 字段。使用时,discriminator 将是用于确定哪个模式定义验证模型结构的属性的名称。因此,discriminator 字段必须是必需字段。有两种方法可以为继承的实例定义鉴别器的值。

  • 使用模式名称。
  • 通过使用新值覆盖属性来覆盖模式名称。如果存在新值,则优先于模式名称。因此,没有给定 ID 的内联模式不能用于多态性。
4.8.24.2.2 XML 建模

xml 属性允许在将 JSON 定义转换为 XML 时进行额外的定义。XML 对象包含有关可用选项的其他信息。

4.8.24.2.3 指定 Schema 方言

对于工具来说,能够确定任何给定资源希望使用哪种方言或元模式非常重要:JSON Schema 核心、JSON Schema 验证、OpenAPI Schema 方言或某些自定义元模式。

$schema 关键字可以出现在任何根 Schema 对象中,如果存在,则必须用于确定处理模式时应使用哪种方言。这允许使用符合 JSON Schema 其他草案(而不是默认的草案 2020-12 支持)的 Schema 对象。工具必须支持OAS 方言模式 ID,并且可以支持 $schema 的其他值。

为了允许对 OAS 文档中包含的所有 Schema 对象使用不同的默认 $schema 值,可以在OpenAPI 对象中设置 jsonSchemaDialect 值。如果未设置此默认值,则必须对这些 Schema 对象使用 OAS 方言模式 ID。Schema 对象中的 $schema 值始终会覆盖任何默认值。

当从不是 OAS 文档的外部资源(例如,裸 JSON Schema 资源)引用 Schema 对象时,该资源中模式的 $schema 关键字的值必须遵循JSON Schema 规则

4.8.24.3 Schema 对象示例
4.8.24.3.1 原始示例
{
  "type": "string",
  "format": "email"
}
type: string
format: email
4.8.24.3.2 简单模型
{
  "type": "object",
  "required": [
    "name"
  ],
  "properties": {
    "name": {
      "type": "string"
    },
    "address": {
      "$ref": "#/components/schemas/Address"
    },
    "age": {
      "type": "integer",
      "format": "int32",
      "minimum": 0
    }
  }
}
type: object
required:
- name
properties:
  name:
    type: string
  address:
    $ref: '#/components/schemas/Address'
  age:
    type: integer
    format: int32
    minimum: 0
4.8.24.3.3 具有 Map/Dictionary 属性的模型

对于简单的字符串到字符串映射

{
  "type": "object",
  "additionalProperties": {
    "type": "string"
  }
}
type: object
additionalProperties:
  type: string

对于字符串到模型的映射

{
  "type": "object",
  "additionalProperties": {
    "$ref": "#/components/schemas/ComplexModel"
  }
}
type: object
additionalProperties:
  $ref: '#/components/schemas/ComplexModel'
4.8.24.3.4 具有示例的模型
{
  "type": "object",
  "properties": {
    "id": {
      "type": "integer",
      "format": "int64"
    },
    "name": {
      "type": "string"
    }
  },
  "required": [
    "name"
  ],
  "example": {
    "name": "Puma",
    "id": 1
  }
}
type: object
properties:
  id:
    type: integer
    format: int64
  name:
    type: string
required:
- name
example:
  name: Puma
  id: 1
4.8.24.3.5 具有组合的模型
{
  "components": {
    "schemas": {
      "ErrorModel": {
        "type": "object",
        "required": [
          "message",
          "code"
        ],
        "properties": {
          "message": {
            "type": "string"
          },
          "code": {
            "type": "integer",
            "minimum": 100,
            "maximum": 600
          }
        }
      },
      "ExtendedErrorModel": {
        "allOf": [
          {
            "$ref": "#/components/schemas/ErrorModel"
          },
          {
            "type": "object",
            "required": [
              "rootCause"
            ],
            "properties": {
              "rootCause": {
                "type": "string"
              }
            }
          }
        ]
      }
    }
  }
}
components:
  schemas:
    ErrorModel:
      type: object
      required:
      - message
      - code
      properties:
        message:
          type: string
        code:
          type: integer
          minimum: 100
          maximum: 600
    ExtendedErrorModel:
      allOf:
      - $ref: '#/components/schemas/ErrorModel'
      - type: object
        required:
        - rootCause
        properties:
          rootCause:
            type: string
4.8.24.3.6 具有多态支持的模型
{
  "components": {
    "schemas": {
      "Pet": {
        "type": "object",
        "discriminator": {
          "propertyName": "petType"
        },
        "properties": {
          "name": {
            "type": "string"
          },
          "petType": {
            "type": "string"
          }
        },
        "required": [
          "name",
          "petType"
        ]
      },
      "Cat": {
        "description": "A representation of a cat. Note that `Cat` will be used as the discriminator value.",
        "allOf": [
          {
            "$ref": "#/components/schemas/Pet"
          },
          {
            "type": "object",
            "properties": {
              "huntingSkill": {
                "type": "string",
                "description": "The measured skill for hunting",
                "default": "lazy",
                "enum": [
                  "clueless",
                  "lazy",
                  "adventurous",
                  "aggressive"
                ]
              }
            },
            "required": [
              "huntingSkill"
            ]
          }
        ]
      },
      "Dog": {
        "description": "A representation of a dog. Note that `Dog` will be used as the discriminator value.",
        "allOf": [
          {
            "$ref": "#/components/schemas/Pet"
          },
          {
            "type": "object",
            "properties": {
              "packSize": {
                "type": "integer",
                "format": "int32",
                "description": "the size of the pack the dog is from",
                "default": 0,
                "minimum": 0
              }
            },
            "required": [
              "packSize"
            ]
          }
        ]
      }
    }
  }
}
components:
  schemas:
    Pet:
      type: object
      discriminator:
        propertyName: petType
      properties:
        name:
          type: string
        petType:
          type: string
      required:
      - name
      - petType
    Cat:  ## "Cat" will be used as the discriminator value
      description: A representation of a cat
      allOf:
      - $ref: '#/components/schemas/Pet'
      - type: object
        properties:
          huntingSkill:
            type: string
            description: The measured skill for hunting
            enum:
            - clueless
            - lazy
            - adventurous
            - aggressive
        required:
        - huntingSkill
    Dog:  ## "Dog" will be used as the discriminator value
      description: A representation of a dog
      allOf:
      - $ref: '#/components/schemas/Pet'
      - type: object
        properties:
          packSize:
            type: integer
            format: int32
            description: the size of the pack the dog is from
            default: 0
            minimum: 0
        required:
        - packSize

4.8.25 Discriminator 对象

当请求正文或响应有效负载可能是许多不同模式之一时,可以使用 discriminator 对象来帮助进行序列化、反序列化和验证。鉴别器是模式中的特定对象,用于根据与其关联的值向文档使用者告知备用模式。

使用鉴别器时,将不考虑内联模式。

4.8.25.1 固定字段
字段名称 类型 描述
propertyName 字符串 必需。有效负载中将保存鉴别器值的属性的名称。
mapping Map[string, string] 一个对象,用于保存有效负载值和模式名称或引用之间的映射。

此对象可以使用 规范扩展 进行扩展。

仅当使用组合关键字 oneOfanyOfallOf 之一时,鉴别器对象才合法。

在 OAS 3.0 中,响应有效负载可以被描述为正好是任意数量类型之一

MyResponseType:
  oneOf:
  - $ref: '#/components/schemas/Cat'
  - $ref: '#/components/schemas/Dog'
  - $ref: '#/components/schemas/Lizard'

这意味着有效负载必须通过验证与 CatDogLizard 描述的模式之一完全匹配。在这种情况下,鉴别器可以充当“提示”以缩短验证和匹配模式的选择,这可能是代价高昂的操作,具体取决于模式的复杂性。然后,我们可以准确地描述哪个字段告诉我们使用哪个模式

MyResponseType:
  oneOf:
  - $ref: '#/components/schemas/Cat'
  - $ref: '#/components/schemas/Dog'
  - $ref: '#/components/schemas/Lizard'
  discriminator:
    propertyName: petType

现在的期望是,响应有效负载中必须存在名为 petType 的属性,并且该值将对应于 OAS 文档中定义的模式的名称。因此,响应有效负载

{
  "id": 12345,
  "petType": "Cat"
}

将指示与此有效负载一起使用 Cat 模式。

在鉴别器字段的值与模式名称不匹配或无法进行隐式映射的情况下,可以使用可选的 mapping 定义

MyResponseType:
  oneOf:
  - $ref: '#/components/schemas/Cat'
  - $ref: '#/components/schemas/Dog'
  - $ref: '#/components/schemas/Lizard'
  - $ref: 'https://gigantic-server.com/schemas/Monster/schema.json'
  discriminator:
    propertyName: petType
    mapping:
      dog: '#/components/schemas/Dog'
      monster: 'https://gigantic-server.com/schemas/Monster/schema.json'

这里,鉴别器 dog 将映射到模式 #/components/schemas/Dog,而不是 Dog 的默认(隐式)值。如果鉴别器与隐式或显式映射不匹配,则无法确定任何模式,并且验证应该失败。映射键必须是字符串值,但工具可以将响应值转换为字符串以进行比较。

anyOf 结构一起使用时,鉴别器的使用可以避免多个模式可能满足单个有效负载的情况下的歧义。

oneOfanyOf 的两种使用情况下,必须明确列出所有可能的模式。为了避免冗余,可以将鉴别器添加到父模式定义中,并且 allOf 结构中构成父模式的所有模式都可以用作备用模式。

例如

components:
  schemas:
    Pet:
      type: object
      required:
      - petType
      properties:
        petType:
          type: string
      discriminator:
        propertyName: petType
        mapping:
          dog: Dog
    Cat:
      allOf:
      - $ref: '#/components/schemas/Pet'
      - type: object
        # all other properties specific to a `Cat`
        properties:
          name:
            type: string
    Dog:
      allOf:
      - $ref: '#/components/schemas/Pet'
      - type: object
        # all other properties specific to a `Dog`
        properties:
          bark:
            type: string
    Lizard:
      allOf:
      - $ref: '#/components/schemas/Pet'
      - type: object
        # all other properties specific to a `Lizard`
        properties:
          lovesRocks:
            type: boolean

这样的有效负载

{
  "petType": "Cat",
  "name": "misty"
}

将指示使用 Cat 模式。同样,此模式

{
  "petType": "dog",
  "bark": "soft"
}

由于 mapping 元素中的定义,将映射到 Dog

4.8.26 XML 对象

一个元数据对象,允许更精细的 XML 模型定义。

使用数组时,不会推断 XML 元素名称(对于单数/复数形式),并且应该使用 name 属性添加该信息。请参阅示例以了解预期行为。

4.8.26.1 固定字段
字段名称 类型 描述
name 字符串 替换用于描述的模式属性的元素/属性的名称。在 items 中定义时,它将影响列表中各个 XML 元素的名称。在 typearray(在 items 之外)时定义时,它将影响包装元素,并且仅当 wrappedtrue 时才会生效。如果 wrappedfalse,则将被忽略。
namespace 字符串 命名空间定义的 URI。此 URI必须采用绝对 URI 的形式。
prefix 字符串 要用于name的前缀。
attribute 布尔值 声明属性定义是否转换为属性而不是元素。默认值为 false
wrapped 布尔值 可以仅用于数组定义。表示数组是否已包装(例如,<books><book/><book/></books>)或未包装(<book/><book/>)。默认值为 false。仅当与 typearray(在 items 之外)一起定义时,此定义才生效。

此对象可以使用 规范扩展 进行扩展。

4.8.26.2 XML 对象示例

XML 对象定义的示例包含在Schema 对象的属性定义中,并附带其 XML 表示形式的示例。

4.8.26.2.1 无 XML 元素

基本字符串属性

{
    "animals": {
        "type": "string"
    }
}
animals:
  type: string
<animals>...</animals>

基本字符串数组属性(wrapped 默认值为 false

{
    "animals": {
        "type": "array",
        "items": {
            "type": "string"
        }
    }
}
animals:
  type: array
  items:
    type: string
<animals>...</animals>
<animals>...</animals>
<animals>...</animals>
4.8.26.2.2 XML 名称替换
{
  "animals": {
    "type": "string",
    "xml": {
      "name": "animal"
    }
  }
}
animals:
  type: string
  xml:
    name: animal
<animal>...</animal>
4.8.26.2.3 XML 属性、前缀和命名空间

在此示例中,显示了完整的模型定义。

{
  "Person": {
    "type": "object",
    "properties": {
      "id": {
        "type": "integer",
        "format": "int32",
        "xml": {
          "attribute": true
        }
      },
      "name": {
        "type": "string",
        "xml": {
          "namespace": "https://example.com/schema/sample",
          "prefix": "sample"
        }
      }
    }
  }
}
Person:
  type: object
  properties:
    id:
      type: integer
      format: int32
      xml:
        attribute: true
    name:
      type: string
      xml:
        namespace: https://example.com/schema/sample
        prefix: sample
<Person id="123">
    <sample:name xmlns:sample="https://example.com/schema/sample">example</sample:name>
</Person>
4.8.26.2.4 XML 数组

更改元素名称

{
  "animals": {
    "type": "array",
    "items": {
      "type": "string",
      "xml": {
        "name": "animal"
      }
    }
  }
}
animals:
  type: array
  items:
    type: string
    xml:
      name: animal
<animal>value</animal>
<animal>value</animal>

外部的name属性对XML没有影响

{
  "animals": {
    "type": "array",
    "items": {
      "type": "string",
      "xml": {
        "name": "animal"
      }
    },
    "xml": {
      "name": "aliens"
    }
  }
}
animals:
  type: array
  items:
    type: string
    xml:
      name: animal
  xml:
    name: aliens
<animal>value</animal>
<animal>value</animal>

即使数组被包装,如果未显式定义名称,则内部和外部将使用相同的名称

{
  "animals": {
    "type": "array",
    "items": {
      "type": "string"
    },
    "xml": {
      "wrapped": true
    }
  }
}
animals:
  type: array
  items:
    type: string
  xml:
    wrapped: true
<animals>
  <animals>value</animals>
  <animals>value</animals>
</animals>

为了克服上面示例中的命名问题,可以使用以下定义

{
  "animals": {
    "type": "array",
    "items": {
      "type": "string",
      "xml": {
        "name": "animal"
      }
    },
    "xml": {
      "wrapped": true
    }
  }
}
animals:
  type: array
  items:
    type: string
    xml:
      name: animal
  xml:
    wrapped: true
<animals>
  <animal>value</animal>
  <animal>value</animal>
</animals>

影响内部和外部名称

{
  "animals": {
    "type": "array",
    "items": {
      "type": "string",
      "xml": {
        "name": "animal"
      }
    },
    "xml": {
      "name": "aliens",
      "wrapped": true
    }
  }
}
animals:
  type: array
  items:
    type: string
    xml:
      name: animal
  xml:
    name: aliens
    wrapped: true
<aliens>
  <animal>value</animal>
  <animal>value</animal>
</aliens>

如果我们更改外部元素但未更改内部元素

{
  "animals": {
    "type": "array",
    "items": {
      "type": "string"
    },
    "xml": {
      "name": "aliens",
      "wrapped": true
    }
  }
}
animals:
  type: array
  items:
    type: string
  xml:
    name: aliens
    wrapped: true
<aliens>
  <aliens>value</aliens>
  <aliens>value</aliens>
</aliens>

4.8.27 Security Scheme 对象

定义操作可以使用的一种安全方案。

支持的方案包括HTTP身份验证、API密钥(作为标头、cookie参数或查询参数)、双向TLS(使用客户端证书)、OAuth2的常用流程(隐式、密码、客户端凭据和授权码),如[RFC6749]中所定义,以及OpenID Connect Discovery。请注意,截至2020年,隐式流程即将被OAuth 2.0 Security Best Current Practice弃用。对于大多数用例,建议使用带PKCE的授权码授予流程。

4.8.27.1 固定字段
字段名称 类型 应用于 描述
类型 字符串 任何 必需。安全方案的类型。有效值为"apiKey""http""mutualTLS""oauth2""openIdConnect"
描述 字符串 任何 安全方案的描述。[CommonMark]语法可以用于富文本表示。
名称 字符串 apiKey 必需。要使用的标头、查询或cookie参数的名称。
位置 字符串 apiKey 必需。API密钥的位置。有效值为"query""header""cookie"
方案 字符串 http 必需。如[RFC7235] 第5.1节中所定义,在Authorization标头中使用的HTTP授权方案的名称。使用的值应该IANA身份验证方案注册表中注册。
bearer格式 字符串 http ("bearer") 提示客户端识别承载令牌的格式。承载令牌通常由授权服务器生成,因此此信息主要用于文档目的。
流程 OAuth流程对象 oauth2 必需。包含支持的流程类型配置信息的 对象。
OpenId Connect URL 字符串 openIdConnect 必需。用于发现OAuth2配置值的OpenId Connect URL。这必须采用URL的形式。OpenID Connect标准要求使用TLS。

此对象可以使用 规范扩展 进行扩展。

4.8.27.2 Security Scheme 对象示例
4.8.27.2.1 基本身份验证示例
{
  "type": "http",
  "scheme": "basic"
}
type: http
scheme: basic
4.8.27.2.2 API 密钥示例
{
  "type": "apiKey",
  "name": "api_key",
  "in": "header"
}
type: apiKey
name: api_key
in: header
4.8.27.2.3 JWT Bearer 示例
{
  "type": "http",
  "scheme": "bearer",
  "bearerFormat": "JWT",
}
type: http
scheme: bearer
bearerFormat: JWT
4.8.27.2.4 隐式 OAuth2 示例
{
  "type": "oauth2",
  "flows": {
    "implicit": {
      "authorizationUrl": "https://example.com/api/oauth/dialog",
      "scopes": {
        "write:pets": "modify pets in your account",
        "read:pets": "read your pets"
      }
    }
  }
}
type: oauth2
flows:
  implicit:
    authorizationUrl: https://example.com/api/oauth/dialog
    scopes:
      write:pets: modify pets in your account
      read:pets: read your pets

4.8.28 OAuth Flows 对象

允许配置支持的OAuth流程。

4.8.28.1 固定字段
字段名称 类型 描述
隐式 OAuth流程对象 OAuth隐式流程的配置
密码 OAuth流程对象 OAuth资源所有者密码流程的配置
客户端凭据 OAuth流程对象 OAuth客户端凭据流程的配置。以前在OpenAPI 2.0中称为application
授权码 OAuth流程对象 OAuth授权码流程的配置。以前在OpenAPI 2.0中称为accessCode

此对象可以使用 规范扩展 进行扩展。

4.8.29 OAuth Flow 对象

支持的OAuth流程的配置详细信息

4.8.29.1 固定字段
字段名称 类型 应用于 描述
授权URL 字符串 oauth2 ("implicit", "authorizationCode") 必需。要用于此流程的授权URL。这必须采用URL的形式。OAuth2标准要求使用TLS。
令牌URL 字符串 oauth2 ("password", "clientCredentials", "authorizationCode") 必需。要用于此流程的令牌URL。这必须采用URL的形式。OAuth2标准要求使用TLS。
刷新URL 字符串 oauth2 用于获取刷新令牌的URL。这必须采用URL的形式。OAuth2标准要求使用TLS。
范围 Map[string, string] oauth2 必需。OAuth2安全方案的可用范围。范围名称与其简短描述之间的映射。该映射可以为空。

此对象可以使用 规范扩展 进行扩展。

4.8.29.2 OAuth Flow 对象示例
{
  "type": "oauth2",
  "flows": {
    "implicit": {
      "authorizationUrl": "https://example.com/api/oauth/dialog",
      "scopes": {
        "write:pets": "modify pets in your account",
        "read:pets": "read your pets"
      }
    },
    "authorizationCode": {
      "authorizationUrl": "https://example.com/api/oauth/dialog",
      "tokenUrl": "https://example.com/api/oauth/token",
      "scopes": {
        "write:pets": "modify pets in your account",
        "read:pets": "read your pets"
      }
    }
  }
}
type: oauth2
flows:
  implicit:
    authorizationUrl: https://example.com/api/oauth/dialog
    scopes:
      write:pets: modify pets in your account
      read:pets: read your pets
  authorizationCode:
    authorizationUrl: https://example.com/api/oauth/dialog
    tokenUrl: https://example.com/api/oauth/token
    scopes:
      write:pets: modify pets in your account
      read:pets: read your pets

4.8.30 Security Requirement 对象

列出执行此操作所需的安全性方案。每个属性使用的名称必须对应于在安全方案组件对象中声明的安全方案。

包含多个方案的安全需求对象要求所有方案必须满足才能授权请求。这支持需要多个查询参数或HTTP标头来传递安全信息的场景。

当在OpenAPI对象操作对象上定义安全需求对象的列表时,列表中只需要满足其中一个安全需求对象即可授权请求。

4.8.30.1 模式化字段
字段模式 类型 描述
{名称} [string] 每个名称必须对应于在安全方案组件对象中声明的安全方案。如果安全方案的类型为"oauth2""openIdConnect",则该值为执行所需的一系列范围名称,如果授权不需要指定的范围,则该列表可以为空。对于其他安全方案类型,该数组可以包含执行所需的一系列角色名称,但在其他方面未定义或不在带内交换。
4.8.30.2 Security Requirement 对象示例
4.8.30.2.1 非 OAuth2 安全需求
{
  "api_key": []
}
api_key: []
4.8.30.2.2 OAuth2 安全需求
{
  "petstore_auth": [
    "write:pets",
    "read:pets"
  ]
}
petstore_auth:
- write:pets
- read:pets
4.8.30.2.3 可选 OAuth2 安全

可选的OAuth2安全,将在OpenAPI对象操作对象中定义

{
  "security": [
    {},
    {
      "petstore_auth": [
        "write:pets",
        "read:pets"
      ]
    }
  ]
}
security:
  - {}
  - petstore_auth:
    - write:pets
    - read:pets

4.9 规范扩展

虽然OpenAPI规范试图适应大多数用例,但可以在某些点添加其他数据来扩展规范。

扩展属性实现为模式化字段,这些字段始终以"x-"为前缀。

字段模式 类型 描述
^x- 任何 允许扩展OpenAPI模式。字段名称必须x-开头,例如x-internal-id。以x-oai-x-oas-开头的字段名称保留用于OpenAPI Initiative定义的用途。该值可以为null、基本类型、数组或对象。

可用的工具可能支持也可能不支持扩展,但这些工具也可以扩展以添加请求的支持(如果工具是内部的或开源的)。

4.10 安全过滤

OpenAPI规范中的一些对象可以声明并保持为空,或者完全删除,即使它们本质上是API文档的核心。

这样做的原因是为了允许对文档进行额外的访问控制层。虽然本身不是规范的一部分,但某些库可以选择根据某种形式的身份验证/授权来允许访问文档的部分内容。

以下两个示例

  1. 路径对象可以存在但为空。这可能与直觉相反,但这可能会告诉查看者他们到达了正确的位置,但无法访问任何文档。他们仍然可以访问至少信息对象,其中可能包含有关身份验证的其他信息。
  2. 路径项对象可以为空。在这种情况下,查看者将知道该路径存在,但将无法看到其任何操作或参数。这与从路径对象中隐藏路径本身不同,因为用户将知道它的存在。这允许文档提供者精细地控制查看者可以看到的内容。

A. 附录 A:修订历史

版本 日期 备注
3.1.0 2021-02-15 OpenAPI规范3.1.0版本
3.1.0-rc1 2020-10-08 3.1规范的rc1版本
3.1.0-rc0 2020-06-18 3.1规范的rc0版本
3.0.3 2020-02-20 OpenAPI规范3.0.3修订版
3.0.2 2018-10-08 OpenAPI规范3.0.2修订版
3.0.1 2017-12-06 OpenAPI规范3.0.1修订版
3.0.0 2017-07-26 OpenAPI规范3.0.0版本
3.0.0-rc2 2017-06-16 3.0规范的rc2版本
3.0.0-rc1 2017-04-27 3.0规范的rc1版本
3.0.0-rc0 2017-02-28 3.0规范的实现者草稿
2.0 2015-12-31 将Swagger 2.0捐赠给OpenAPI Initiative
2.0 2014-09-08 Swagger 2.0版本
1.2 2014-03-14 正式文档的初始版本。
1.1 2012-08-22 Swagger 1.1版本
1.0 2011-08-10 Swagger规范的第一个版本

B. 参考文献

B.1 规范性引用

[ABNF]
语法规范增强BNF:ABNF。D. Crocker,编辑;P. Overell。IETF。2008年1月。互联网标准。网址:https://www.rfc-editor.org/rfc/rfc5234
[CommonMark]
CommonMark规范。网址:https://spec.commonmark.org/
[CommonMark-0.27]
CommonMark规范,版本0.27。John MacFarlane。2016年11月18日。网址:https://spec.commonmark.org/0.27/
[IANA-HTTP-AUTHSCHEMES]
超文本传输协议(HTTP)身份验证方案注册表。IANA。网址:https://www.iana.org/assignments/http-authschemes/
[IANA-HTTP-STATUS-CODES]
超文本传输协议(HTTP)状态代码注册表。IANA。网址:https://www.iana.org/assignments/http-status-codes/
[JSON-Schema-2020-12]
JSON模式:描述JSON文档的媒体类型。草稿2020-12。Austin Wright;Henry Andrews;Ben Hutton;Greg Dennis。互联网工程任务组(IETF)。2020年12月8日。互联网草稿。网址:https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-00
[JSON-Schema-Validation-2020-12]
JSON模式验证:JSON结构验证的词汇表。草稿2020-12。Austin Wright;Henry Andrews;Ben Hutton。互联网工程任务组(IETF)。2020年12月8日。互联网草稿。网址:https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00
[RFC1866]
超文本标记语言-2.0。T. Berners-Lee;D. Connolly。IETF。1995年11月。历史。网址:https://www.rfc-editor.org/rfc/rfc1866
[RFC2045]
多用途互联网邮件扩展(MIME)第一部分:互联网消息体的格式。N. Freed;N. Borenstein。IETF。1996年11月。草案标准。网址:https://www.rfc-editor.org/rfc/rfc2045
[RFC2119]
用于RFC中指示需求级别的关键词。S. Bradner。IETF。1997年3月。最佳实践。网址:https://www.rfc-editor.org/rfc/rfc2119
[RFC3986]
统一资源标识符(URI):通用语法。T. Berners-Lee;R. Fielding;L. Masinter。IETF。2005年1月。互联网标准。网址:https://www.rfc-editor.org/rfc/rfc3986
[RFC4648]
Base16、Base32和Base64数据编码。S. Josefsson。IETF。2006年10月。建议标准。网址:https://www.rfc-editor.org/rfc/rfc4648
[RFC6570]
URI模板。J. Gregorio;R. Fielding;M. Hadley;M. Nottingham;D. Orchard。IETF。2012年3月。建议标准。网址:https://www.rfc-editor.org/rfc/rfc6570
[RFC6749]
OAuth 2.0授权框架。D. Hardt,编辑。IETF。2012年10月。建议标准。网址:https://www.rfc-editor.org/rfc/rfc6749
[RFC6838]
媒体类型规范和注册程序. N. Freed; J. Klensin; T. Hansen. IETF. 2013年1月. 最佳当前实践。网址:https://www.rfc-editor.org/rfc/rfc6838
[RFC6901]
JavaScript 对象表示法 (JSON) 指针. P. Bryan,编辑;K. Zyp;M. Nottingham,编辑。IETF. 2013年4月. 提议标准。网址:https://www.rfc-editor.org/rfc/rfc6901
[RFC7159]
JavaScript 对象表示法 (JSON) 数据交换格式. T. Bray,编辑。IETF. 2014年3月. 提议标准。网址:https://www.rfc-editor.org/rfc/rfc7159
[RFC7230]
超文本传输协议 (HTTP/1.1):消息语法和路由. R. Fielding,编辑;J. Reschke,编辑。IETF. 2014年6月. 提议标准。网址:https://httpwg.org/specs/rfc7230.html
[RFC7231]
超文本传输协议 (HTTP/1.1):语义和内容. R. Fielding,编辑;J. Reschke,编辑。IETF. 2014年6月. 提议标准。网址:https://httpwg.org/specs/rfc7231.html
[RFC7235]
超文本传输协议 (HTTP/1.1):身份验证. R. Fielding,编辑;J. Reschke,编辑。IETF. 2014年6月. 提议标准。网址:https://httpwg.org/specs/rfc7235.html
[RFC7578]
从表单返回值:multipart/form-data. L. Masinter. IETF. 2015年7月. 提议标准。网址:https://www.rfc-editor.org/rfc/rfc7578
[RFC8174]
RFC 2119 关键词中大写和小写的不确定性. B. Leiba. IETF. 2017年5月. 最佳当前实践。网址:https://www.rfc-editor.org/rfc/rfc8174
[SPDX-Licenses]
SPDX 许可证列表. Linux 基金会。网址:https://spdx.org/licenses/
[YAML]
YAML 不是标记语言 (YAML™) 版本 1.2. Oren Ben-Kiki;Clark Evans;Ingy döt Net. 2009年10月1日。网址:http://yaml.org/spec/1.2/spec.html