Kotlin y PostgreSQL: escribiendo un backend más rápido de lo que pensabas

Kotlin y PostgreSQL: un dúo inesperado para tu backend

Cuando se habla de desarrollo backend moderno, Kotlin y PostgreSQL aparecen cada vez más en la misma frase. Y no es casualidad. Kotlin aporta concisión y características funcionales al mundo JVM, mientras que PostgreSQL sigue siendo el estándar de fiabilidad y flexibilidad entre las bases de datos relacionales. En esta guía, veremos cómo hacer que estas dos tecnologías trabajen juntas, escribiremos código real y repasaremos las mejores prácticas.

Si ya conoces Kotlin para backend o estás empezando, este artículo te dará un plan de acción claro. ¡Vamos allá!

¿Por qué Kotlin + PostgreSQL es genial?

Kotlin es un lenguaje que te enamora desde las primeras líneas. Es compatible con Java, pero elimina toneladas de código repetitivo. Y PostgreSQL no es solo "otra base de datos". Es una herramienta potente con soporte para JSON, búsqueda de texto completo, funciones de ventana y extensiones como PostGIS.

Juntos ofrecen:

\n
• Seguridad contra nulos a nivel de tipos — Kotlin te protege de NPE al trabajar con resultados de consultas.
\n
• Asincronía integrada — las corrutinas de Kotlin son ideales para trabajar con pools de conexiones.
\n
• DSL para SQL — bibliotecas como Exposed permiten escribir consultas como parte del lenguaje.
\n
• Rendimiento — la JVM junto con un controlador JDBC optimizado ofrecen una velocidad excelente.
\n

Preparación del entorno: qué necesitas instalar

Antes de escribir código, asegúrate de tener:

\n
• JDK 17+ instalado
\n
• IntelliJ IDEA (la Community Edition es suficiente)
\n
• PostgreSQL 14+ (puedes usar Docker: docker run --name pg -e POSTGRES_PASSWORD=pass -p 5432:5432 -d postgres)
\n
• Conocimientos básicos de SQL
\n

Crea un nuevo proyecto Gradle en IntelliJ. En build.gradle.kts agrega las dependencias:

dependencies {\n    implementation("org.jetbrains.exposed:exposed-core:0.44.1")\n    implementation("org.jetbrains.exposed:exposed-dao:0.44.1")\n    implementation("org.jetbrains.exposed:exposed-jdbc:0.44.1")\n    implementation("org.postgresql:postgresql:42.7.1")\n    implementation("com.zaxxer:HikariCP:5.1.0")\n    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")\n}

Conexión a PostgreSQL mediante HikariCP

Para trabajar con PostgreSQL en Kotlin necesitamos un pool de conexiones. HikariCP es el estándar de facto. Es rápido, ligero y se configura en pocas líneas.

Creemos la clase DatabaseFactory:

import com.zaxxer.hikari.HikariConfig\nimport com.zaxxer.hikari.HikariDataSource\nimport org.jetbrains.exposed.sql.Database\n\nobject DatabaseFactory {\n    fun init() {\n        val config = HikariConfig().apply {\n            jdbcUrl = "jdbc:postgresql://localhost:5432/yourdb"\n            driverClassName = "org.postgresql.Driver"\n            username = "postgres"\n            password = "pass"\n            maximumPoolSize = 10\n            isAutoCommit = false\n            transactionIsolation = "TRANSACTION_REPEATABLE_READ"\n        }\n\n        val dataSource = HikariDataSource(config)\n        Database.connect(dataSource)\n    }\n}

Observa: isAutoCommit = false nos da control sobre las transacciones. Esto es importante para la consistencia de los datos.

Creación de tablas con Exposed ORM

Exposed es un ORM ligero para Kotlin que no impone sus reglas. Puedes trabajar tanto con DSL como con objetos DAO.

Definamos el modelo de usuario:

import org.jetbrains.exposed.sql.Table\n\nobject Users : Table("users") {\n    val id = integer("id").autoIncrement()\n    val name = varchar("name", 100)\n    val email = varchar("email", 255).uniqueIndex()\n    val