}
  }

  override fun onResponse(
    call: Call,
    response: Response,
  ) {
    processResponse(response)
  }

  fun processResponse(response: Response) {
    response.use {
      if (!response.isSuccessful) {
        listener.onFailure(this, null, response)
        return
      }

      val body = response.body

      if (!body.isEventStream()) {
        listener.onFailure(

                response.setContentType("application/vnd.ms-fontobject");
            } else if (lowerPath.endsWith(".ico")) {
                response.setContentType("image/vnd.microsoft.icon");
            } else if (lowerPath.endsWith(".js")) {
                response.setContentType("text/javascript");
            } else if (lowerPath.endsWith(".json")) {
                response.setContentType("application/json");

def test_get_no_item(client: TestClient):
    response = client.get("/items/foo")
    assert response.status_code == 404, response.text
    assert response.json() == {"detail": "Item not found, there's only a plumbus here"}


def test_get(client: TestClient):
    response = client.get("/items/plumbus")
    assert response.status_code == 200, response.text
    assert response.json() == "plumbus"

    }

    @Override
    protected void testRead() {
        final Map<String, Object> searchBody = new HashMap<>();
        final String response = checkMethodBase(searchBody).get(API_PATH + "/" + LIST_ENDPOINT_SUFFIX).asString();
        assertEquals(new Integer(0), JsonPath.from(response).get("response.status"));
    }

    @Override
    protected void tearDown() {
        // do nothing
    }

    @Test
    void crudTest() {

# Hintergrundtasks

Sie können Hintergrundtasks (Hintergrund-Aufgaben) definieren, die *nach* der Rückgabe einer Response ausgeführt werden sollen.

Das ist nützlich für Vorgänge, die nach einem Request ausgeführt werden müssen, bei denen der Client jedoch nicht unbedingt auf den Abschluss des Vorgangs warten muss, bevor er die Response erhält.

Hierzu zählen beispielsweise:

* E-Mail-Benachrichtigungen, die nach dem Ausführen einer Aktion gesendet werden:

        println("Response 2 response:          $it")
        println("Response 2 cache response:    ${it.cacheResponse}")
        println("Response 2 network response:  ${it.networkResponse}")
        return@use it.body.string()
      }

    println("Response 2 equals Response 1? " + (response1Body == response2Body))
  }
}

fun main() {

미들웨어 함수는 다음 항목들을 받습니다:

* `request`.
* `request`를 매개변수로 받는 `call_next` 함수.
    * 이 함수는 `request`를 해당하는 *경로 작업*으로 전달합니다.
    * 그런 다음, *경로 작업*에 의해 생성된 `response` 를 반환합니다.
* `response`를 반환하기 전에 추가로 `response`를 수정할 수 있습니다.

```Python hl_lines="8-9  11  14"
{!../../docs_src/middleware/tutorial001.py!}
```

/// tip | "팁"

const (
	// browserCSPPolicy setting name for Content-Security-Policy response header value
	browserCSPPolicy = "csp_policy"
	// browserHSTSSeconds setting name for Strict-Transport-Security response header, amount of seconds for 'max-age'
	browserHSTSSeconds = "hsts_seconds"
	// browserHSTSIncludeSubdomains setting name for Strict-Transport-Security response header 'includeSubDomains' flag (true or false)

        try (CloseableHttpResponse response = httpClient.execute(httpPost)) {
            if (response.getStatusLine().getStatusCode() != Constants.OK_STATUS_CODE) {
                logger.error("Failed to access {}, code: {}.", url, response.getStatusLine().getStatusCode());
                return null;
            }

            data.setContent(EntityUtils.toString(response.getEntity(), Charsets.UTF_8));

def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == {
        "openapi": "3.1.0",
        "info": {"title": "FastAPI", "version": "0.1.0"},
        "paths": {
            "/login/": {
                "post": {
                    "responses": {
                        "200": {