Programación en red con Kotlin: de sockets a corutinas

Programación en red con Kotlin: de la teoría a la práctica

El mundo moderno es un mundo de aplicaciones interconectadas. Ya sea un chatbot, un juego en línea o una arquitectura de microservicios, todo se basa en la comunicación en red. Y si antes la programación en red se asociaba exclusivamente con Java o C++, hoy Kotlin emerge con fuerza en el escenario.

¿Por qué Kotlin? Este lenguaje no es solo un "Java moderno". Ha absorbido lo mejor del mundo JVM, añadiendo concisión, seguridad y un potente soporte para asincronía mediante corutinas. En este artículo, analizaremos cómo escribir programación en red con Kotlin, desde los sockets clásicos hasta soluciones elegantes con corutinas. Aprenderás a crear tu propio servidor TCP, enviar un paquete UDP y no volverte loco con la concurrencia.

¿Por qué Kotlin es adecuado para tareas de red?

Antes de sumergirnos en el código, veamos por qué Kotlin es una excelente opción para la programación en red:

• Compatibilidad total con Java: puedes usar todo el arsenal de java.net, java.nio y frameworks populares (Netty, Ktor).
• Corutinas: el código asíncrono se ve como síncrono. Sin infierno de callbacks.
• Seguridad contra nulos: menos posibilidades de obtener un NullPointerException al trabajar con flujos de datos.
• Extensiones funcionales: funciones de extensión convenientes para trabajar con bytes y cadenas.

Comenzaremos con los sockets básicos (como en el viejo Java) y luego pasaremos a un enfoque más moderno con corutinas.

Fundamentos: Servidor y cliente TCP en Kotlin

Empecemos con lo clásico: la conexión TCP. En Kotlin usamos las mismas clases ServerSocket y Socket, pero con una sintaxis más limpia.

Escribimos un servidor eco TCP simple

Nuestro servidor recibirá mensajes del cliente y los devolverá (eco).

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 en el puerto $port")

    while (true) {        // Bloqueamos esperando un cliente        val clientSocket = serverSocket.accept()        println("Cliente conectado: ${clientSocket.inetAddress.hostAddress}")

        // Procesamos al cliente en un hilo separado (con fines educativos)        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("Recibido: $message")                    output.println("Eco: $message")                }            } catch (e: Exception) {                println("Error: ${e.message}")            } finally {                clientSocket.close()            }        }.start()    }}

Observa: usamos Thread { ... }.start(). Esto funciona, pero para producción es mejor usar un pool de hilos o corutinas (hablaremos de ellas más adelante).

Cliente para el servidor eco

Ahora escribamos un cliente que se conecte al servidor y envíe mensajes:

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))

        // Enviamos mensajes        val messages = listOf("¡Hola, servidor!", "¿Cómo estás?", "¡Adiós!")