- media_type
            - body
            - background
            - raw_headers
            - render
            - init_headers
            - headers
            - set_cookie
            - delete_cookie

::: fastapi.responses.ORJSONResponse
    options:
        members:
            - charset
            - status_code
            - media_type
            - body
            - background

    cacheRequest: CacheRequest?,
    response: Response,
  ): Response {
    // Some apps return a null body; for compatibility we treat that like a null cache request.
    if (cacheRequest == null) return response
    val cacheBodyUnbuffered = cacheRequest.body()

    val source = response.body.source()
    val cacheBody = cacheBodyUnbuffered.buffer()

    val cacheWritingSource =
      object : Source {

Ao usar quaisquer dos:

* `Path()`
* `Query()`
* `Header()`
* `Cookie()`
* `Body()`
* `Form()`
* `File()`

você também pode declarar um dado `example` ou um grupo de `examples` com informações adicionais que serão adicionadas ao **OpenAPI**.

### `Body` com `example`

Aqui nós passamos um `example` dos dados esperados por `Body()`:

```Python hl_lines="21-26"
{!../../../docs_src/schema_extra_example/tutorial003.py!}

Dies beinhaltet:

* `Query()`
* `Path()`
* `Body()`
* `Cookie()`
* `Header()`
* `Form()`
* `File()`

Sie können diese alle direkt von `fastapi` importieren:

```python
from fastapi import Body, Cookie, File, Form, Header, Path, Query
```

::: fastapi.Query

::: fastapi.Path

::: fastapi.Body

::: fastapi.Cookie

::: fastapi.Header

::: fastapi.Form

    this.server = server
  }

  @Test
  fun suspendCall() {
    runTest {
      server.enqueue(MockResponse(body = "abc"))

      val call = client.newCall(request)

      call.executeAsync().use {
        withContext(Dispatchers.IO) {
          assertThat(it.body.string()).isEqualTo("abc")
        }
      }
    }
  }

  @Test
  fun timeoutCall() {
    runTest {
      server.enqueue(

!!! warning "Achtung"
    Sie können mehrere `File`- und `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie können nicht gleichzeitig auch `Body`-Felder deklarieren, welche Sie als JSON erwarten, da der Request den Body mittels `multipart/form-data` statt `application/json` kodiert.

    Das ist keine Limitation von **FastAPI**, sondern Teil des HTTP-Protokolls.

## Zusammenfassung

  @Test
  @Throws(IOException::class)
  fun non101RetainsBody() {
    webServer.enqueue(
      MockResponse.Builder()
        .code(200)
        .body("Body")
        .build(),
    )
    newWebSocket()
    clientListener.assertFailure(
      200,
      "Body",
      ProtocolException::class.java,
      "Expected HTTP 101 response but was '200 OK'",
    )
  }

  @Test
  @Throws(IOException::class)

    return response
  }
  val body = response.body
  val encoding = response.header("Content-Encoding") ?: return response

  val decompressedSource =
    when {
      encoding.equals("br", ignoreCase = true) ->
        BrotliInputStream(body.source().inputStream()).source().buffer()
      encoding.equals("gzip", ignoreCase = true) ->
        GzipSource(body.source()).buffer()
      else -> return response
    }

    server.enqueue(MockResponse(body = "abc"))
    server.enqueue(MockResponse(body = "def"))

    // Call 1: set a deadline on the response body.
    val request1 = Request.Builder().url(server.url("/")).build()
    val response1 = client.newCall(request1).execute()
    val body1 = response1.body.source()
    assertThat(body1.readUtf8()).isEqualTo("abc")
    body1.timeout().deadline(5, TimeUnit.SECONDS)

### Den `RequestValidationError`-Body verwenden

Der `RequestValidationError` enthält den empfangenen `body` mit den ungültigen Daten.

Sie könnten diesen verwenden, während Sie Ihre Anwendung entwickeln, um den Body zu loggen und zu debuggen, ihn zum Benutzer zurückzugeben, usw.

```Python hl_lines="14"