{* ../../docs_src/custom_response/tutorial009c.py hl[9:14,17] *}

이제 다음 대신:

```json
{"message": "Hello World"}
```

이 응답은 이렇게 반환됩니다:

```json
{
  "message": "Hello World"
}
```

물론 JSON 포맷팅보다 더 유용하게 활용할 방법을 찾을 수 있을 것입니다. 😉

## 기본 응답 클래스

**FastAPI** 클래스 객체 또는 `APIRouter`를 생성할 때 기본적으로 사용할 응답 클래스를 지정할 수 있습니다.

import okio.GzipSource
import okio.buffer
import okio.use
import org.junit.jupiter.api.Test

class RequestTest {
  @Test
  fun constructor() {
    val url = "https://example.com/".toHttpUrl()
    val body = "hello".toRequestBody()
    val headers = headersOf("User-Agent", "RequestTest")
    val method = "PUT"
    val request =
      Request(
        url = url,
        headers = headers,
        method = method,

        void shouldReadSpecifiedBytes() throws IOException {
            byte[] data = "Hello World Test".getBytes();
            InputStream is = new ByteArrayInputStream(data);
            byte[] buffer = new byte[20];

            int bytesRead = Transport.readn(is, buffer, 0, 5);
            assertEquals(5, bytesRead);
            assertArrayEquals("Hello".getBytes(), java.util.Arrays.copyOfRange(buffer, 0, 5));
        }

        @Test

    server.setServerSocketFactory(new UnixDomainServerSocketFactory(socketFile));
    server.setProtocols(Collections.singletonList(Protocol.H2_PRIOR_KNOWLEDGE));
    server.enqueue(new MockResponse().setBody("hello"));
    server.start();

    OkHttpClient client = new OkHttpClient.Builder()
        .socketFactory(new UnixDomainSocketFactory(socketFile))
        .protocols(Collections.singletonList(Protocol.H2_PRIOR_KNOWLEDGE))

{* ../../docs_src/custom_response/tutorial009c.py hl[9:14,17] *}

Now instead of returning:

```json
{"message": "Hello World"}
```

...this response will return:

```json
{
  "message": "Hello World"
}
```

Of course, you will probably find much better ways to take advantage of this than formatting JSON. 😉

        InvertibleCryptographer cryptographer = securityResourceProvider.providePrimaryInvertibleCryptographer();
        assertNotNull(cryptographer);

        String plainText = "Hello, World!";
        String encrypted = cryptographer.encrypt(plainText);
        assertNotNull(encrypted);
        assertFalse(plainText.equals(encrypted));

        String decrypted = cryptographer.decrypt(encrypted);

 * expected to be unequal. For example:
 *
 * {@snippet :
 * EquivalenceTester.of(someStringEquivalence)
 *     .addEquivalenceGroup("hello", "h" + "ello")
 *     .addEquivalenceGroup("world", "wor" + "ld")
 *     .test();
 * }
 *
 * <p>Note that testing {@link Object#equals(Object)} is more simply done using the {@link

    assertThat(headersToList(response)).containsExactly("Cookie: a=android")
  }

  @Test
  fun regularResponse() {
    server.enqueue(MockResponse().setBody("hello world"))
    val url = server.url("/").toUrl()
    val connection = url.openConnection() as HttpURLConnection
    connection.setRequestProperty("Accept-Language", "en-US")
    val inputStream = connection.inputStream

./mc replicate add sitea/bucket --remote-bucket siteb/bucket

# Run the test to make sure proxying of DEL marker doesn't happen
loop_count=0
while true; do
	if [ $loop_count -eq 1000 ]; then
		break
	fi
	echo "Hello World" | ./mc pipe sitea/bucket/obj$loop_count
	./mc rm sitea/bucket/obj$loop_count
	RESULT=$({ ./mc stat --no-list sitea/bucket/obj$loop_count; } 2>&1)
	if [[ ${RESULT} != *"Object does not exist"* ]]; then

* Создайте файл `main.py` со следующим содержимым:

```Python
from typing import Union

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}
```

<details markdown="1">