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

Introduction : Pourquoi Kotlin est un excellent choix pour travailler avec les bases de données

Kotlin, en tant que langage de programmation moderne et concis, offre aux développeurs des outils puissants pour interagir avec diverses bases de données. Grâce à sa compatibilité totale avec Java et à son propre écosystème de bibliothèques, Kotlin permet d'écrire un code sûr, expressif et performant pour travailler à la fois avec des stockages relationnels (SQL) et orientés documents (NoSQL).

Dans cet article, nous allons, à l'aide d'exemples pratiques, aborder la connexion et l'exécution d'opérations CRUD (Create, Read, Update, Delete) pour deux systèmes de gestion de bases de données populaires : PostgreSQL (relationnel) et MongoDB (document). Vous apprendrez à configurer un projet, à utiliser des bibliothèques modernes (Exposed pour SQL et KMongo pour MongoDB) et à écrire un code propre en tenant compte des spécificités de Kotlin.

1. Travailler avec PostgreSQL en Kotlin : utiliser la bibliothèque Exposed

Pour travailler avec des bases de données relationnelles en Kotlin, il existe plusieurs approches. Nous allons examiner la bibliothèque Exposed — une enveloppe ORM légère écrite en Kotlin, qui fournit un DSL (Domain-Specific Language) typé pour formuler des requêtes SQL.

1.1. Ajout des dépendances

Ajoutez les dépendances suivantes dans le fichier build.gradle.kts :

dependencies {    implementation("org.jetbrains.exposed:exposed-core:0.41.1")    implementation("org.jetbrains.exposed:exposed-dao:0.41.1")    implementation("org.jetbrains.exposed:exposed-jdbc:0.41.1")    implementation("org.postgresql:postgresql:42.6.0")    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")}

1.2. Création de la table et connexion à la BDD

Définissons l'entité "Utilisateur" et la table correspondante dans le code :

import org.jetbrains.exposed.sql.*import org.jetbrains.exposed.sql.transactions.transactionimport org.jetbrains.exposed.sql.SqlExpressionBuilder.eq

// Définition de la tableobject Users : Table() {    val id = integer("id").autoIncrement()    val name = varchar("name", 255)    val email = varchar("email", 255).uniqueIndex()

    override val primaryKey = PrimaryKey(id)}

// Data class pour l'utilisateurdata class User(val id: Int, val name: String, val email: String)

fun main() {    // Connexion à la base de données    Database.connect(        url = "jdbc:postgresql://localhost:5432/mydb",        driver = "org.postgresql.Driver",        user = "postgres",        password = "password"    )

    // Création de la table (si elle n'existe pas)    transaction {        SchemaUtils.create(Users)    }}

1.3. Opérations CRUD

Implémentons maintenant les opérations de base de création, lecture, mise à jour et suppression d'enregistrements :

fun createUser(name: String, email: String): User {    return transaction {        val insertId = Users.insert {            it[Users.name] = name            it[Users.email] = email        } get Users.id

        User(            id = insertId,            name = name,            email = email        )    }}

fun readUserById(id: Int): User? {    return transaction {        Users.selectAll().where { Users.id eq id }            .singleOrNull()            ?.let { row ->                User(                    id = row[Users.id],                    name = row[Users.name],                    email = row[Users.email]                )            }    }}

fun updateUserEmail(id: Int, newEmail: String) {    transaction {        Users.update({ Users.id eq id }) {            it[email] = newEmail        }    }}

fun deleteUser(id: Int) {    transaction {        Users.deleteWhere { Users.id eq id }    }}

Grâce à Exposed, le code Kotlin devient concis et sûr au niveau des types. Les erreurs dans les noms de colonnes ou de tables sont détectées