Kotlin et PostgreSQL : écrivez un backend plus vite que vous ne le pensiez

Kotlin et PostgreSQL : un duo inattendu pour votre backend

Quand il s'agit de développement backend moderne, Kotlin et PostgreSQL se retrouvent de plus en plus souvent dans la même phrase. Et ce n'est pas un hasard. Kotlin apporte concision et fonctionnalités au monde JVM, tandis que PostgreSQL reste la référence en matière de fiabilité et de flexibilité parmi les bases de données relationnelles. Dans ce guide, nous verrons comment faire collaborer ces deux technologies, écrire du code concret et examiner les meilleures pratiques.

Que vous soyez déjà familier avec Kotlin pour le backend ou que vous débutiez, cet article vous donnera un plan d'action clair. C'est parti !

Pourquoi Kotlin + PostgreSQL est génial ?

Kotlin est un langage qui fait tomber amoureux dès les premières lignes. Il est compatible avec Java, tout en éliminant des tonnes de code boilerplate. Et PostgreSQL n'est pas qu'« une base de données de plus ». C'est un outil puissant avec le support du JSON, de la recherche plein texte, des fonctions de fenêtrage et d'extensions comme PostGIS.

Ensemble, ils offrent :

\n
• Sécurité null au niveau des types — Kotlin vous protège des NPE lors du traitement des résultats de requêtes.
\n
• Asynchronisme intégré — les coroutines Kotlin sont parfaites pour travailler avec des pools de connexions.
\n
• DSL pour SQL — des bibliothèques comme Exposed permettent d'écrire des requêtes comme faisant partie du langage.
\n
• Performance — JVM + pilote JDBC optimisé offrent une excellente vitesse.
\n

Préparation de l'environnement : ce qu'il faut installer

Avant d'écrire du code, assurez-vous d'avoir :

\n
• JDK 17+ installé
\n
• IntelliJ IDEA (l'édition Community convient)
\n
• PostgreSQL 14+ (possible via Docker : docker run --name pg -e POSTGRES_PASSWORD=pass -p 5432:5432 -d postgres)
\n
• Une compréhension de base de SQL
\n

Créez un nouveau projet Gradle dans IntelliJ. Dans build.gradle.kts, ajoutez les dépendances :

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}

Connexion à PostgreSQL via HikariCP

Pour travailler avec PostgreSQL en Kotlin, nous avons besoin d'un pool de connexions. HikariCP est le standard de facto. Il est rapide, léger et se configure en quelques lignes.

Créons la classe 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}

Notez que isAutoCommit = false nous donne le contrôle sur les transactions. C'est important pour la cohérence des données.

Création de tables avec Exposed ORM

Exposed est un ORM léger pour Kotlin qui n'impose pas ses propres règles. Vous pouvez travailler aussi bien avec le DSL qu'avec les objets DAO.

Définissons un modèle d'utilisateur :

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