Travailler avec les bases de données en Kotlin : PostgreSQL et MongoDB

Introduction : Pourquoi Kotlin et les bases de données forment un duo idéal

Kotlin est un langage moderne à typage statique qui fonctionne sur la JVM. Grâce à sa syntaxe concise, sa sécurité nulle (null safety) et sa compatibilité totale avec Java, Kotlin est devenu l'un des langages à la croissance la plus rapide pour le développement back-end. Dans cet article, nous allons voir comment se connecter et effectuer des opérations CRUD avec deux SGBD populaires : le relationnel PostgreSQL et l'orienté documents MongoDB.

Nous aborderons deux approches principales : l'utilisation de la bibliothèque Exposed pour SQL et du framework KMongo pour travailler avec MongoDB. Tous les exemples de code sont écrits en Kotlin pur et prêts à être exécutés.

1. Travailler avec PostgreSQL via la bibliothèque Exposed

1.1. Configuration des dépendances

Pour commencer, ajoutez les dépendances suivantes dans le fichier build.gradle.kts :

dependencies {    implementation("org.jetbrains.exposed:exposed-core:0.44.0")    implementation("org.jetbrains.exposed:exposed-dao:0.44.0")    implementation("org.jetbrains.exposed:exposed-jdbc:0.44.0")    implementation("org.postgresql:postgresql:42.6.0")    implementation("com.zaxxer:HikariCP:5.0.1")}

HikariCP est un pool de connexions hautes performances que nous utiliserons pour gérer les connexions à la base de données.

1.2. Connexion à la base de données

Créons un objet pour gérer la connexion :

import com.zaxxer.hikari.HikariConfigimport com.zaxxer.hikari.HikariDataSourceimport org.jetbrains.exposed.sql.Database

object DatabaseFactory {    fun init() {        val config = HikariConfig().apply {            driverClassName = "org.postgresql.Driver"            jdbcUrl = "jdbc:postgresql://localhost:5432/my_db"            username = "user"            password = "password"            maximumPoolSize = 10            isAutoCommit = false        }

        val dataSource = HikariDataSource(config)        Database.connect(dataSource)    }}

1.3. Définition des tables et opérations CRUD

Exposed utilise un style DSL pour décrire les tables. Définissons une table utilisateur simple :

import org.jetbrains.exposed.sql.Tableimport org.jetbrains.exposed.sql.*import org.jetbrains.exposed.sql.transactions.transaction

object Users : Table() {    val id = integer("id").autoIncrement()    val name = varchar("name", 100)    val email = varchar("email", 255).uniqueIndex()

    override val primaryKey = PrimaryKey(id)}

// Insertion de donnéesfun insertUser(name: String, email: String) {    transaction {        Users.insert {            it[Users.name] = name            it[Users.email] = email        }    }}

// Lecture de tous les utilisateursfun getAllUsers(): List<ResultRow> {    return transaction {        Users.selectAll().toList()    }}

// Mise à jour de l'emailfun updateUserEmail(id: Int, newEmail: String) {    transaction {        Users.update({ Users.id eq id }) {            it[email] = newEmail        }    }}

// Suppression d'un utilisateurfun deleteUser(id: Int) {    transaction {        Users.deleteWhere { Users.id eq id }    }}

1.4. Particularités d'Exposed

• Transactions : Toutes les opérations sont exécutées à l'intérieur du bloc transaction.
• Sécurité des types : Les erreurs dans les requêtes SQL sont détectées à la compilation.
• Migrations : Exposed supporte la création automatique de tables via SchemaUtils.create(Users).

2. Travailler avec MongoDB via KMongo

2.1. Configuration des dépendances

Ajoutez dans build.gradle.kts :

dependencies {    implementation("org.litote.kmongo:kmongo-coroutine:4.9.0")    implementation("org.litote.kmongo:kmongo-id:4.9.0")}<