Programação de Rede em Kotlin: de Sockets a Corrotinas

Programação de Rede em Kotlin: da Teoria à Prática

O mundo moderno é um mundo de aplicações interconectadas. Seja um chatbot, um jogo online ou uma arquitetura de microsserviços — a base de tudo é a comunicação em rede. E se antes a programação de rede era associada exclusivamente a Java ou C++, hoje o Kotlin entra com confiança em cena.

Por que Kotlin? Esta linguagem não é apenas um "Java moderno". Ela absorveu o melhor do mundo JVM, adicionando concisão, segurança e suporte poderoso para assincronia através de corrotinas. Neste artigo, vamos explorar como escrever programação de rede em Kotlin — desde sockets clássicos até soluções elegantes com corrotinas. Você aprenderá como criar seu próprio servidor TCP, enviar um pacote UDP e não enlouquecer com multithreading.

Por que Kotlin é adequado para tarefas de rede?

Antes de mergulhar no código, vamos entender por que Kotlin é uma excelente escolha para programação de rede:

• Compatibilidade total com Java: você pode usar todo o arsenal de java.net, java.nio e frameworks populares (Netty, Ktor).
• Corrotinas: código assíncrono parece síncrono. Nada de inferno de callbacks.
• Segurança contra nulos: menos chances de obter NullPointerException ao trabalhar com fluxos de dados.
• Extensões funcionais: funções de extensão convenientes para trabalhar com bytes e strings.

Começaremos com sockets básicos (como no bom e velho Java) e depois passaremos para uma abordagem mais moderna com corrotinas.

Fundamentos: Servidor e Cliente TCP em Kotlin

Vamos começar com o clássico — conexão TCP. Em Kotlin, usamos as mesmas classes ServerSocket e Socket, mas com uma sintaxe mais limpa.

Escrevendo um servidor TCP echo simples

Nosso servidor receberá mensagens do cliente e as enviará de volta (echo).

import java.io.BufferedReaderimport java.io.InputStreamReaderimport java.io.PrintWriterimport java.net.ServerSocket

fun main() {    val port = 8080    val serverSocket = ServerSocket(port)    println("Servidor iniciado na porta $port")

    while (true) {        // Bloqueia aguardando um cliente        val clientSocket = serverSocket.accept()        println("Cliente conectado: ${clientSocket.inetAddress.hostAddress}")

        // Processa o cliente em uma thread separada (para fins educacionais)        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("Recebido: $message")                    output.println("Echo: $message")                }            } catch (e: Exception) {                println("Erro: ${e.message}")            } finally {                clientSocket.close()            }        }.start()    }}

Observe: usamos Thread { ... }.start(). Isso funciona, mas para produção é melhor usar um pool de threads ou corrotinas (falaremos sobre isso em breve).

Cliente para o servidor echo

Agora vamos escrever um cliente que se conecta ao servidor e envia mensagens:

import java.io.BufferedReaderimport java.io.InputStreamReaderimport java.io.PrintWriterimport 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))

        // Envia mensagens        val messages = listOf("Olá, servidor!", "Como vai?", "Tchau!")