Сетевое программирование на Kotlin: от сокетов до корутин

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

Сетевое программирование на Kotlin: от теории к практике

Современный мир — это мир взаимосвязанных приложений. Будь то чат-бот, онлайн-игра или микросервисная архитектура — в основе всего лежит сетевое взаимодействие. И если раньше сетевое программирование ассоциировалось исключительно с Java или C++, то сегодня на сцену уверенно выходит Kotlin.

Почему именно Kotlin? Этот язык не просто «современный Java». Он вобрал в себя лучшее из мира JVM, добавив лаконичность, безопасность и мощную поддержку асинхронности через корутины. В этой статье мы разберем, как писать сетевое программирование на Kotlin — от классических сокетов до элегантных решений на корутинах. Вы узнаете, как создать свой TCP-сервер, отправить UDP-пакет и не сойти с ума от многопоточности.

Почему Kotlin подходит для сетевых задач?

Прежде чем нырять в код, давайте разберемся, почему Kotlin — отличный выбор для сетевого программирования:

Полная совместимость с Java: вы можете использовать весь арсенал java.net, java.nio и популярных фреймворков (Netty, Ktor).
Корутины: асинхронный код выглядит как синхронный. Никакого ада коллбэков.
Null-безопасность: меньше шансов получить NullPointerException при работе с потоками данных.
Функциональные расширения: удобные функции-экстеншены для работы с байтами и строками.

Мы начнем с базовых сокетов (как в старом добром Java), а затем перейдем к более современному подходу с корутинами.

Основы: TCP-сервер и клиент на Kotlin

Начнем с классики — TCP-соединения. В Kotlin мы используем те же классы ServerSocket и Socket, но с более чистым синтаксисом.

Пишем простой TCP-эхо-сервер

Наш сервер будет принимать сообщения от клиента и отправлять их обратно (эхо).

import java.io.BufferedReader
import java.io.InputStreamReader
import java.io.PrintWriter
import java.net.ServerSocket

fun main() {
    val port = 8080
    val serverSocket = ServerSocket(port)
    println("Сервер запущен на порту $port")

    while (true) {
        // Блокируемся в ожидании клиента
        val clientSocket = serverSocket.accept()
        println("Подключился клиент: ${clientSocket.inetAddress.hostAddress}")

        // Обрабатываем клиента в отдельном потоке (в учебных целях)
        Thread {
            try {
                val input = BufferedReader(InputStreamReader(clientSocket.inputStream))
                val output = PrintWriter(clientSocket.outputStream, true)

                var message: String?
                while (input.readLine().also { message = it } != null) {
                    println("Получено: $message")
                    output.println("Эхо: $message")
                }
            } catch (e: Exception) {
                println("Ошибка: ${e.message}")
            } finally {
                clientSocket.close()
            }
        }.start()
    }
}

Обратите внимание: мы используем Thread { ... }.start(). Это работает, но для продакшена лучше использовать пул потоков или корутины (о них чуть позже).

Клиент для эхо-сервера

Теперь напишем клиент, который подключается к серверу и отправляет сообщения:

import java.io.BufferedReader
import java.io.InputStreamReader
import java.io.PrintWriter
import java.net.Socket

fun main() {
    val host = "localhost"
    val port = 8080

    try {
        val socket = Socket(host, port)
        val output = PrintWriter(socket.outputStream, true)
        val input = BufferedReader(InputStreamReader(socket.inputStream))

        // Отправляем сообщения
        val messages = listOf("Привет, сервер!", "Как дела?", "Пока!")
        for (msg in messages) {
            output.println(msg)
            val response = input.readLine()
            println("Ответ сервера: $response")
        }

        socket.close()
    } catch (e: Exception) {
        println("Ошибка подключения: ${e.message}")
    }
}

Это база. Но в реальном мире мы редко пишем такие низкоуровневые вещи вручную. Тем не менее, понимание принципов работы сокетов необходимо для любого Kotlin разработчика.

UDP-сокеты: быстрая передача данных

Если TCP гарантирует доставку, то UDP жертвует надежностью ради скорости. Это идеальный выбор для видеозвонков, онлайн-игр или стриминга.

UDP-сервер на Kotlin

import java.net.DatagramPacket
import java.net.DatagramSocket

fun main() {
    val port = 9090
    val socket = DatagramSocket(port)
    val buffer = ByteArray(1024)

    println("UDP сервер слушает порт $port")

    while (true) {
        val packet = DatagramPacket(buffer, buffer.size)
        socket.receive(packet) // Блокирующая операция

        val received = String(packet.data, 0, packet.length)
        println("Получено от ${packet.address}: $received")

        // Отправляем ответ
        val response = "Принято: $received"
        val responseData = response.toByteArray()
        val responsePacket = DatagramPacket(
            responseData,
            responseData.size,
            packet.address,
            packet.port
        )
        socket.send(responsePacket)
    }
}

UDP-клиент

import java.net.DatagramPacket
import java.net.DatagramSocket
import java.net.InetAddress

fun main() {
    val host = "localhost"
    val port = 9090
    val socket = DatagramSocket()

    val message = "Привет по UDP!"
    val sendData = message.toByteArray()
    val sendPacket = DatagramPacket(
        sendData,
        sendData.size,
        InetAddress.getByName(host),
        port
    )
    socket.send(sendPacket)

    // Получаем ответ
    val buffer = ByteArray(1024)
    val receivePacket = DatagramPacket(buffer, buffer.size)
    socket.receive(receivePacket)

    val response = String(receivePacket.data, 0, receivePacket.length)
    println("Ответ от сервера: $response")

    socket.close()
}

Как видите, код почти не отличается от Java, но благодаря Kotlin он стал чуть лаконичнее.

Асинхронное сетевое программирование с корутинами

Теперь самое интересное — корутины. Они превращают блокирующий код в неблокирующий без сложных callback'ов. Для сетевого программирования это настоящая находка.

Для работы с корутинами нам понадобится библиотека kotlinx.coroutines. Добавьте её в build.gradle.kts:

implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")

TCP-сервер на корутинах

Вместо того чтобы создавать поток на каждого клиента, мы используем легковесные корутины. Они работают в рамках одного потока, но могут приостанавливаться и возобнов