Skip to content

Ktor로 Kotlin에서 WebSocket 애플리케이션 만들기

코드 예제: tutorial-server-websockets

사용된 플러그인: Static Content스타일시트, 스크립트, 이미지 등과 같은 정적 콘텐츠를 서빙하는 방법을 알아봅니다., Content NegotiationContentNegotiation 플러그인은 두 가지 주요 목적을 수행합니다. 클라이언트와 서버 간의 미디어 유형 협상, 그리고 특정 형식으로 콘텐츠를 직렬화/역직렬화하는 것입니다., WebSockets in Ktor ServerWebSockets 플러그인을 사용하면 서버와 클라이언트 간의 양방향 통신 세션을 생성할 수 있습니다., kotlinx.serialization

이 문서에서는 Ktor를 사용하여 Kotlin에서 WebSocket 애플리케이션을 생성하는 과정을 단계별로 안내합니다. 이 내용은 RESTful API 만들기Kotlin과 Ktor를 사용하여 백엔드 서비스를 구축하는 방법을 배우며, JSON을 생성하는 RESTful API 예제를 다룹니다. 튜토리얼에서 다룬 내용을 기반으로 합니다.

이 문서를 통해 다음 내용을 배울 수 있습니다:

  • JSON 직렬화를 사용하는 서비스 생성하기
  • WebSocket 연결을 통해 콘텐츠 주고받기
  • 여러 클라이언트에 동시에 콘텐츠 브로드캐스트하기

사전 준비 사항

이 튜토리얼은 독립적으로 진행할 수 있지만, Content NegotiationContentNegotiation 플러그인은 두 가지 주요 목적을 수행합니다. 클라이언트와 서버 간의 미디어 유형 협상, 그리고 특정 형식으로 콘텐츠를 직렬화/역직렬화하는 것입니다.과 REST에 익숙해지도록 RESTful API 만들기Kotlin과 Ktor를 사용하여 백엔드 서비스를 구축하는 방법을 배우며, JSON을 생성하는 RESTful API 예제를 다룹니다. 튜토리얼을 먼저 완료하는 것을 권장합니다.

IntelliJ IDEA를 설치하는 것을 권장하지만, 원하는 다른 IDE를 사용해도 좋습니다.

Hello WebSockets

이 튜토리얼에서는 RESTful API 만들기Kotlin과 Ktor를 사용하여 백엔드 서비스를 구축하는 방법을 배우며, JSON을 생성하는 RESTful API 예제를 다룹니다. 튜토리얼에서 개발한 작업 관리자(Task Manager) 서비스를 기반으로, WebSocket 연결을 통해 클라이언트와 Task 객체를 주고받는 기능을 추가합니다. 이를 구현하려면 WebSockets 플러그인WebSockets 플러그인을 사용하면 서버와 클라이언트 간의 양방향 통신 세션을 생성할 수 있습니다.을 추가해야 합니다. 기존 프로젝트에 수동으로 추가할 수도 있지만, 이 튜토리얼에서는 새 프로젝트를 처음부터 생성하여 진행합니다.

플러그인을 포함한 초기 프로젝트 생성

  1. Ktor Project Generator로 이동합니다.

  2. Project artifact 필드에 프로젝트 아티팩트 이름으로 com.example.ktor-websockets-task-app을 입력합니다. Ktor Project Generator에서 프로젝트 아티팩트 이름 지정

  3. 플러그인 섹션에서 Add 버튼을 클릭하여 다음 플러그인을 검색하고 추가합니다:

    1. Content Negotiation
    2. kotlinx.serialization
    3. WebSockets
    4. Static Content

    Ktor Project Generator에서 플러그인 추가

  4. 플러그인을 추가하면 플러그인 섹션의 오른쪽 상단에 표시됩니다.

    그런 다음 프로젝트에 추가될 모든 플러그인 목록을 확인할 수 있습니다: Ktor Project Generator의 플러그인 목록

  5. Download 버튼을 클릭하여 Ktor 프로젝트를 생성하고 다운로드합니다.

시작 코드 추가

다운로드가 완료되면 IntelliJ IDEA에서 프로젝트를 열고 다음 단계를 따릅니다:

  1. src/main/kotlin으로 이동하여 model이라는 새 하위 패키지를 생성합니다.
  2. model 패키지 안에 새 Task.kt 파일을 생성합니다.

  3. Task.kt 파일을 열고 우선순위를 나타내는 enum과 작업을 나타내는 data class를 추가합니다:

    kotlin
    package com.example.model
    
    import kotlinx.serialization.Serializable
    
    enum class Priority {
        Low, Medium, High, Vital
    }
    
    @Serializable
    data class Task(
        val name: String,
        val description: String,
        val priority: Priority
    )

    Task 클래스에 kotlinx.serialization 라이브러리의 Serializable 타입이 어노테이션으로 지정되어 있다는 점에 유의하세요. 이는 인스턴스를 JSON으로 상호 변환할 수 있음을 의미하며, 이를 통해 해당 콘텐츠를 네트워크로 전송할 수 있습니다.

    WebSockets 플러그인을 포함했기 때문에, 생성기가 src/main/kotlin 내에 Websockets.kt 파일과 Routing.kt 파일의 webSocket 라우트를 추가했습니다.

  4. Websockets.kt 파일을 열고 기존 .configureWebsockets() 함수를 다음과 같이 교체합니다:
    kotlin
    fun Application.configureWebsockets() {
        install(WebSockets) {
            contentConverter = KotlinxWebsocketSerializationConverter(Json)
            pingPeriod = 15.seconds
            timeout = 15.seconds
            maxFrameSize = Long.MAX_VALUE
            masking = false
        }
    }
    • WebSockets 플러그인이 설치되고 표준 설정으로 구성됩니다.
    • contentConverter 속성이 설정되어, 플러그인이 kotlinx.serialization 라이브러리를 통해 송수신되는 객체를 직렬화할 수 있게 됩니다.
  5. Routing.kt 파일을 열고 기존 Application.configureRouting() 함수를 아래 구현으로 교체합니다:

    kotlin
    fun Application.configureRouting() {
        routing {
            webSocket("/tasks") {
                val tasks = listOf(
                    Task("cleaning", "Clean the house", Priority.Low),
                    Task("gardening", "Mow the lawn", Priority.Medium),
                    Task("shopping", "Buy the groceries", Priority.High),
                    Task("painting", "Paint the fence", Priority.Medium)
                )
    
                for (task in tasks) {
                    sendSerialized(task)
                    delay(1000.milliseconds)
                }
    
                close(CloseReason(CloseReason.Codes.NORMAL, "All done"))
            }
            staticResources("/static", "static")
        }
    }
    • 상대 URL이 /tasks인 단일 엔드포인트로 라우팅이 구성됩니다.
    • 요청을 받으면 작업 목록이 WebSocket 연결을 통해 직렬화되어 전송됩니다.
    • 모든 항목이 전송되면 서버가 연결을 닫습니다.

    데모 목적으로 작업 전송 사이에 1초의 지연(delay)이 추가되었습니다. 이를 통해 클라이언트에서 작업이 하나씩 점진적으로 나타나는 것을 확인할 수 있습니다. 이 지연이 없다면 이전 문서에서 개발한 RESTful 서비스Kotlin과 Ktor를 사용하여 백엔드 서비스를 구축하는 방법을 배우며, JSON을 생성하는 RESTful API 예제를 다룹니다. 및 웹 애플리케이션Kotlin, Ktor 및 Thymeleaf 템플릿을 사용하여 웹사이트를 구축하는 방법을 알아봅니다.과 동일하게 보일 것입니다.

    이번 단계의 마지막 작업은 이 엔드포인트를 위한 클라이언트를 만드는 것입니다. Static Content스타일시트, 스크립트, 이미지 등과 같은 정적 콘텐츠를 서빙하는 방법을 알아봅니다. 플러그인을 포함했기 때문에, Ktor 프로젝트 생성기가 src/main/resources/static 내에 index.html 파일을 추가해 두었습니다.

  6. index.html 파일을 열고 기존 콘텐츠를 다음 내용으로 교체합니다:

    html
    <html>
    <head>
        <title>Using Ktor WebSockets</title>
        <script>
            function readAndDisplayAllTasks() {
                clearTable();
    
                const serverURL = 'ws://0.0.0.0:8080/tasks';
                const socket = new WebSocket(serverURL);
    
                socket.onopen = logOpenToConsole;
                socket.onclose = logCloseToConsole;
                socket.onmessage = readAndDisplayTask;
            }
    
            function readAndDisplayTask(event) {
                let task = JSON.parse(event.data);
                logTaskToConsole(task);
                addTaskToTable(task);
            }
    
            function logTaskToConsole(task) {
                console.log(`Received ${task.name}`);
            }
    
            function logCloseToConsole() {
                console.log("Web socket connection closed");
            }
    
            function logOpenToConsole() {
                console.log("Web socket connection opened");
            }
    
            function tableBody() {
                return document.getElementById("tasksTableBody");
            }
    
            function clearTable() {
                tableBody().innerHTML = "";
            }
    
            function addTaskToTable(task) {
                tableBody().appendChild(taskRow(task));
            }
    
    
            function taskRow(task) {
                return tr([
                    td(task.name),
                    td(task.description),
                    td(task.priority)
                ]);
            }
    
    
            function tr(children) {
                const node = document.createElement("tr");
                children.forEach(child => node.appendChild(child));
                return node;
            }
    
    
            function td(text) {
                const node = document.createElement("td");
                node.appendChild(document.createTextNode(text));
                return node;
            }
        </script>
    </head>
    <body>
    <h1>Viewing Tasks Via WebSockets</h1>
    <form action="javascript:readAndDisplayAllTasks()">
        <input type="submit" value="View The Tasks">
    </form>
    <table rules="all">
        <thead>
        <tr>
            <th>Name</th><th>Description</th><th>Priority</th>
        </tr>
        </thead>
        <tbody id="tasksTableBody">
        </tbody>
    </table>
    </body>
    </html>

    이 페이지는 모든 최신 브라우저에서 지원하는 WebSocket 타입을 사용합니다. JavaScript에서 이 객체를 생성할 때 생성자에 엔드포인트 URL을 전달합니다. 그 후 onopen, onclose, onmessage 이벤트에 이벤트 핸들러를 연결합니다. onmessage 이벤트가 트리거되면 문서 객체의 메서드를 사용하여 테이블에 행을 추가합니다.

  7. IntelliJ IDEA에서 실행 버튼(intelliJ IDEA 실행 아이콘)을 클릭하여 애플리케이션을 시작합니다.

  8. http://0.0.0.0:8080/static/index.html로 이동합니다. 버튼과 빈 테이블이 있는 폼이 표시됩니다:

    버튼 하나가 있는 HTML 폼을 표시하는 웹 브라우저 페이지

    폼의 버튼을 클릭하면 서버에서 작업이 로드되어 1초에 하나씩 나타납니다. 그 결과 테이블이 점진적으로 채워집니다. 브라우저의 개발자 도구에서 JavaScript 콘솔을 열어 기록된 로그 메시지를 확인할 수도 있습니다.

    버튼 클릭 시 목록 항목을 표시하는 웹 브라우저 페이지

    이로써 서비스가 예상대로 작동합니다. WebSocket 연결이 열리고, 항목들이 클라이언트로 전송된 다음, 연결이 닫힙니다. 기반 네트워크 처리에는 많은 복잡성이 수반되지만, Ktor는 이 모든 것을 기본적으로 처리해 줍니다.

WebSocket 이해하기

다음 단계로 넘어가기 전에 WebSocket의 몇 가지 기본 개념을 살펴보는 것이 도움이 될 수 있습니다. WebSocket에 이미 익숙하다면 건너뛰고 서비스 설계 개선하기로 바로 진행해도 좋습니다.

이전 튜토리얼에서는 클라이언트가 HTTP 요청을 보내고 HTTP 응답을 받았습니다. 이는 잘 작동하며 인터넷이 확장 가능하고 안정적으로 유지될 수 있도록 해줍니다.

그러나 다음과 같은 시나리오에는 적합하지 않습니다:

  • 콘텐츠가 시간에 따라 점진적으로 생성되는 경우
  • 이벤트에 반응하여 콘텐츠가 자주 변경되는 경우
  • 콘텐츠가 생성되는 동안 클라이언트가 서버와 상호작용해야 하는 경우
  • 한 클라이언트가 보낸 데이터가 다른 클라이언트들에게 신속하게 전파되어야 하는 경우

이러한 시나리오의 예로는 주식 거래, 영화 및 콘서트 티켓 예매, 온라인 경매 입찰, 소셜 미디어의 채팅 기능 등이 있습니다. WebSocket은 이러한 상황을 처리하기 위해 개발되었습니다.

WebSocket 연결은 TCP를 통해 설정되며 오랫동안 유지될 수 있습니다. 이 연결은 전이중 통신(full duplex communication)을 제공하므로, 클라이언트가 서버로 메시지를 보내는 동시에 서버로부터 메시지를 받을 수 있습니다.

WebSocket API는 4개의 이벤트(open, message, close, error)와 2개의 액션(send, close)을 정의합니다. 이 기능에 접근하는 방식은 언어와 라이브러리에 따라 다를 수 있습니다. 예를 들어 Kotlin에서는 들어오는 메시지 시퀀스를 Flow로 사용할 수 있습니다.

설계 개선하기

이제 더 발전된 예제를 다룰 수 있도록 기존 코드를 리팩터링합니다.

  1. model 패키지에 새 TaskRepository.kt 파일을 생성합니다.

  2. TaskRepository.kt를 열고 TaskRepository 타입을 추가합니다:

    kotlin
    package com.example.model
    
    object TaskRepository {
        private val tasks = mutableListOf(
            Task("cleaning", "Clean the house", Priority.Low),
            Task("gardening", "Mow the lawn", Priority.Medium),
            Task("shopping", "Buy the groceries", Priority.High),
            Task("painting", "Paint the fence", Priority.Medium)
        )
    
        fun allTasks(): List<Task> = tasks
    
        fun tasksByPriority(priority: Priority) = tasks.filter {
            it.priority == priority
        }
    
        fun taskByName(name: String) = tasks.find {
            it.name.equals(name, ignoreCase = true)
        }
    
        fun addTask(task: Task) {
            if (taskByName(task.name) != null) {
                throw IllegalStateException("Cannot duplicate task names!")
            }
            tasks.add(task)
        }
    
        fun removeTask(name: String): Boolean {
            return tasks.removeIf { it.name == name }
        }
    }

    이 코드는 이전 튜토리얼에서 보았던 코드일 것입니다.

  3. src/main/kotlin으로 이동하여 Routing.kt 파일을 엽니다.
  4. 이제 TaskRepository를 활용하여 Application.configureRouting()의 라우팅을 간소화할 수 있습니다:

    kotlin
    routing {
        webSocket("/tasks") {
            for (task in TaskRepository.allTasks()) {
                sendSerialized(task)
                delay(1000.milliseconds)
            }
            close(CloseReason(CloseReason.Codes.NORMAL, "All done"))
        }
        // ...
    }

WebSocket을 통해 메시지 전송하기

WebSocket의 진가를 확인하기 위해 다음과 같이 동작하는 새로운 엔드포인트를 만듭니다:

  • 클라이언트가 시작될 때 기존의 모든 작업을 수신합니다.
  • 클라이언트가 작업을 생성하여 전송할 수 있습니다.
  • 한 클라이언트가 작업을 전송하면 다른 클라이언트들에게 알림이 전달됩니다.
  1. Routing.kt 파일에서 현재 .configureRouting() 메서드를 아래 구현으로 교체합니다:

    kotlin
    fun Application.configureRouting() {
        routing {
            val sessions =
                Collections.synchronizedList<WebSocketServerSession>(ArrayList())
    
            webSocket("/tasks") {
                sendAllTasks()
                close(CloseReason(CloseReason.Codes.NORMAL, "All done"))
            }
    
            webSocket("/tasks2") {
                sessions.add(this)
                sendAllTasks()
    
                while(true) {
                    ensureActive()
                    val newTask = receiveDeserialized<Task>()
                    TaskRepository.addTask(newTask)
                    for(session in sessions) {
                        session.sendSerialized(newTask)
                    }
                }
            }
            staticResources("/static", "static")
        }
    }
    
    private suspend fun DefaultWebSocketServerSession.sendAllTasks() {
        for (task in TaskRepository.allTasks()) {
            sendSerialized(task)
            delay(1000.milliseconds)
        }
    }

    이 코드를 통해 다음 작업을 수행했습니다:

    • 기존의 모든 작업을 전송하는 기능을 헬퍼 메서드로 리팩터링했습니다.
    • routing {} 블록에서 모든 클라이언트를 추적하기 위해 스레드 안전(thread-safe)한 session 객체 목록을 생성했습니다.
    • 상대 URL이 /tasks2인 새 엔드포인트를 추가했습니다. 클라이언트가 이 엔드포인트에 연결하면 해당 session 객체가 목록에 추가됩니다. 그런 다음 서버는 무한 루프로 들어가 새 작업을 기다립니다. 새 작업을 수신하면 서버는 이를 리포지토리에 저장하고, 현재 클라이언트를 포함한 모든 클라이언트에게 복사본을 전송합니다.

    이 기능을 테스트하기 위해 index.html의 기능을 확장하는 새 페이지를 생성합니다.

  2. src/main/resources/static 안에 wsClient.html이라는 새 HTML 파일을 생성합니다.

  3. wsClient.html을 열고 다음 내용을 추가합니다:

    html
    <html>
    <head>
        <title>WebSocket Client</title>
        <script>
            let serverURL;
            let socket;
    
            function setupSocket() {
                serverURL = 'ws://0.0.0.0:8080/tasks2';
                socket = new WebSocket(serverURL);
    
                socket.onopen = logOpenToConsole;
                socket.onclose = logCloseToConsole;
                socket.onmessage = readAndDisplayTask;
            }
    
            function readAndDisplayTask(event) {
                let task = JSON.parse(event.data);
                logTaskToConsole(task);
                addTaskToTable(task);
            }
    
            function logTaskToConsole(task) {
                console.log(`Received ${task.name}`);
            }
    
            function logCloseToConsole() {
                console.log("Web socket connection closed");
            }
    
            function logOpenToConsole() {
                console.log("Web socket connection opened");
            }
    
            function tableBody() {
                return document.getElementById("tasksTableBody");
            }
    
            function addTaskToTable(task) {
                tableBody().appendChild(taskRow(task));
            }
    
            function taskRow(task) {
                return tr([
                    td(task.name),
                    td(task.description),
                    td(task.priority)
                ]);
            }
    
            function tr(children) {
                const node = document.createElement("tr");
                children.forEach(child => node.appendChild(child));
                return node;
            }
    
            function td(text) {
                const node = document.createElement("td");
                node.appendChild(document.createTextNode(text));
                return node;
            }
    
            function getFormValue(name) {
                return document.forms[0][name].value
            }
    
            function buildTaskFromForm() {
                return {
                    name: getFormValue("newTaskName"),
                    description: getFormValue("newTaskDescription"),
                    priority: getFormValue("newTaskPriority")
                }
            }
    
            function logSendingToConsole(data) {
                console.log("About to send",data);
            }
    
            function sendTaskViaSocket(data) {
                socket.send(JSON.stringify(data));
            }
    
            function sendTaskToServer() {
                let data = buildTaskFromForm();
                logSendingToConsole(data);
                sendTaskViaSocket(data);
                //prevent form submission
                return false;
            }
        </script>
    </head>
    <body onload="setupSocket()">
    <h1>Viewing Tasks Via WebSockets</h1>
    <table rules="all">
        <thead>
        <tr>
            <th>Name</th><th>Description</th><th>Priority</th>
        </tr>
        </thead>
        <tbody id="tasksTableBody">
        </tbody>
    </table>
    <div>
        <h3>Create a new task</h3>
        <form onsubmit="return sendTaskToServer()">
            <div>
                <label for="newTaskName">Name: </label>
                <input type="text" id="newTaskName"
                       name="newTaskName" size="10">
            </div>
            <div>
                <label for="newTaskDescription">Description: </label>
                <input type="text" id="newTaskDescription"
                       name="newTaskDescription" size="20">
            </div>
            <div>
                <label for="newTaskPriority">Priority: </label>
                <select id="newTaskPriority" name="newTaskPriority">
                    <option name="Low">Low</option>
                    <option name="Medium">Medium</option>
                    <option name="High">High</option>
                    <option name="Vital">Vital</option>
                </select>
            </div>
            <input type="submit">
        </form>
    </div>
    </body>
    </html>

    이 새 페이지에는 사용자가 새 작업 정보를 입력할 수 있는 HTML 폼이 도입되었습니다. 폼을 제출하면 sendTaskToServer() 이벤트 핸들러가 호출됩니다. 이는 폼 데이터로 JavaScript 객체를 구성하고, WebSocket 객체의 .send() 메서드를 사용하여 서버로 전송합니다.

  4. IntelliJ IDEA에서 재실행 버튼(intelliJ IDEA 재실행 아이콘)을 클릭하여 애플리케이션을 다시 시작합니다.

  5. 이 기능을 테스트하려면 두 개의 브라우저 창을 나란히 열고 다음 단계를 따릅니다.

    1. 브라우저 A에서 http://0.0.0.0:8080/static/wsClient.html로 이동합니다. 기본 작업들이 표시되는 것을 볼 수 있습니다.
    2. 브라우저 A에서 새 작업을 추가합니다. 해당 페이지의 테이블에 새 작업이 나타나야 합니다.
    3. 브라우저 B에서 http://0.0.0.0:8080/static/wsClient.html로 이동합니다. 기본 작업과 함께 브라우저 A에서 추가한 새 작업이 표시되는 것을 볼 수 있습니다.
    4. 어느 한 브라우저에서 작업을 추가합니다. 두 페이지 모두에 새 항목이 나타나는 것을 확인할 수 있습니다.
    HTML 폼을 통해 새 작업을 생성하는 것을 보여주는 두 개의 나란히 놓인 웹 브라우저 페이지

자동화 테스트 추가하기

QA 프로세스를 간소화하고 빠르며 재현 가능하고 자동화된 방식으로 만들려면 Ktor의 내장 자동화 테스트 지원특별한 테스트 엔진을 사용하여 서버 애플리케이션을 테스트하는 방법을 알아봅니다.을 사용할 수 있습니다. 다음 단계를 따르세요:

  1. Ktor Client 내에서 Content NegotiationContentNegotiation 플러그인은 두 가지 주요 목적을 수행합니다. 클라이언트와 서버 간의 미디어 유형 협상, 그리고 특정 형식으로 콘텐츠를 직렬화/역직렬화하는 것입니다. 지원을 구성할 수 있도록 build.gradle.kts에 다음 의존성을 추가합니다:

    kotlin
    testImplementation(ktorLibs.client.contentNegotiation)
  2. IntelliJ IDEA에서 에디터 오른쪽에 있는 Gradle 알림 아이콘(intelliJ IDEA gradle 아이콘)을 클릭하여 Gradle 변경 사항을 로드합니다.

  3. src/test/kotlin으로 이동하여 ServerTest.kt 파일을 엽니다.

  4. 생성된 테스트 클래스를 아래 구현으로 교체합니다:

    kotlin
    import com.example.model.Priority
    import com.example.model.Task
    import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
    import io.ktor.client.plugins.websocket.DefaultClientWebSocketSession
    import io.ktor.client.plugins.websocket.WebSockets
    import io.ktor.client.plugins.websocket.converter
    import io.ktor.client.plugins.websocket.webSocket
    import io.ktor.serialization.deserialize
    import io.ktor.serialization.kotlinx.KotlinxWebsocketSerializationConverter
    import io.ktor.serialization.kotlinx.json.json
    import io.ktor.server.testing.testApplication
    import kotlinx.coroutines.flow.consumeAsFlow
    import kotlinx.coroutines.flow.map
    import kotlinx.coroutines.flow.scan
    import kotlinx.serialization.json.Json
    import kotlin.test.Test
    import kotlin.test.assertEquals
    
    class ServerTest {
        @Test
        fun testRoot() = testApplication {
            configure()
    
            val client = createClient {
                install(ContentNegotiation) {
                    json()
                }
                install(WebSockets) {
                    contentConverter =
                        KotlinxWebsocketSerializationConverter(Json)
                }
            }
    
            val expectedTasks = listOf(
                Task("cleaning", "Clean the house", Priority.Low),
                Task("gardening", "Mow the lawn", Priority.Medium),
                Task("shopping", "Buy the groceries", Priority.High),
                Task("painting", "Paint the fence", Priority.Medium)
            )
            var actualTasks = emptyList<Task>()
    
            client.webSocket("/tasks") {
                consumeTasksAsFlow().collect { allTasks ->
                    actualTasks = allTasks
                }
            }
    
            assertEquals(expectedTasks.size, actualTasks.size)
            expectedTasks.forEachIndexed { index, task ->
                assertEquals(task, actualTasks[index])
            }
        }
    
        private fun DefaultClientWebSocketSession.consumeTasksAsFlow() = incoming
            .consumeAsFlow()
            .map {
                converter!!.deserialize<Task>(it)
            }
            .scan(emptyList<Task>()) { list, task ->
                list + task
            }
    }

    이 설정을 통해 다음 작업을 수행합니다:

    • 서비스가 테스트 환경 내에서 실행되도록 구성하고, JSON 직렬화 및 WebSockets를 포함하여 프로덕션 환경과 동일한 기능을 활성화합니다.
    • Ktor ClientKtor 클라이언트를 생성하고 구성하는 방법을 알아봅니다. 내에서 콘텐츠 협상(Content Negotiation) 및 WebSocket 지원을 구성합니다. 이렇게 하지 않으면 클라이언트가 WebSocket 연결을 사용할 때 객체를 JSON으로 직렬화/역직렬화하는 방법을 알 수 없습니다.
    • 서비스가 반환할 것으로 기대하는 Task 목록을 선언합니다.
    • client 객체의 .webSocket 함수를 사용하여 /tasks로 요청을 보냅니다.
    • 수신되는 작업을 Flow로 소비하여 리스트에 점진적으로 추가합니다.
    • 모든 작업을 수신한 후 일반적인 방식으로 expectedTasks와 actualTasks를 비교합니다.

다음 단계

수고하셨습니다! WebSocket 통신과 Ktor Client를 활용한 자동화 테스트를 결합하여 작업 관리자 서비스를 대폭 개선했습니다.

다음 튜토리얼Exposed SQL 라이브러리를 사용하여 Ktor 서비스를 데이터베이스 리포지토리에 연결하는 프로세스를 알아봅니다.로 이동하여 Exposed 라이브러리를 사용하여 서비스가 관계형 데이터베이스와 원활하게 상호작용하는 방법을 살펴보세요.