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

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction : Pourquoi Kotlin pour travailler avec des bases de données ?

Kotlin est un langage moderne à typage statique, totalement compatible avec Java, et activement utilisé pour créer des applications back-end. Grâce à sa syntaxe concise, sa sécurité contre les valeurs nulles et ses outils puissants, Kotlin est idéal pour travailler avec des bases de données relationnelles (PostgreSQL) et orientées documents (MongoDB). Dans cet article, nous analyserons des exemples pratiques de connexion, d'opérations CRUD et d'optimisation de requêtes.

Nous examinerons deux bibliothèques populaires : Exposed (pour PostgreSQL) et KMongo (pour MongoDB). Vous apprendrez à configurer l'environnement, à écrire des requêtes efficaces et à éviter les erreurs courantes.

1. Travailler avec PostgreSQL via Exposed

Exposed est une bibliothèque ORM pour Kotlin qui fournit deux API : DSL (Domain-Specific Language) pour écrire des requêtes dans le style SQL et DAO (Data Access Object) pour une approche orientée objet. Examinons les deux options.

1.1. Connexion et configuration

Ajoutez les dépendances dans 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.5.0")}

Connexion à la base de données :

import org.jetbrains.exposed.sql.Databaseimport org.jetbrains.exposed.sql.transactions.transaction

fun main() {    Database.connect(        url = "jdbc:postgresql://localhost:5432/mydb",        driver = "org.postgresql.Driver",        user = "user",        password = "password"    )    println("Connexion à PostgreSQL établie")}

1.2. Création d'une table et opérations CRUD (DSL)

Définissons la table Users :

import org.jetbrains.exposed.sql.Tableimport org.jetbrains.exposed.sql.insertimport org.jetbrains.exposed.sql.selectAllimport org.jetbrains.exposed.sql.update

object Users : Table() {    val id = integer("id").autoIncrement()    val name = varchar("name", 50)    val email = varchar("email", 100).uniqueIndex()    override val primaryKey = PrimaryKey(id)}

Effectuons des opérations CRUD :

transaction {    // Création d'une table    SchemaUtils.create(Users)

    // INSERT    Users.insert {        it[name] = "Alexey"        it[email] = "alex@example.com"    }

    // SELECT    val users = Users.selectAll().map {        "${it[Users.id]}: ${it[Users.name]} (${it[Users.email]})"    }    println(users)

    // UPDATE    Users.update({ Users.id eq 1 }) {        it[name] = "Alexey Ivanov"    }

    // DELETE (en utilisant deleteWhere)    Users.deleteWhere { Users.id eq 2 }}

1.3. Approche DAO

Créons une entité et une classe DAO :

import org.jetbrains.exposed.dao.IntEntityimport org.jetbrains.exposed.dao.IntEntityClassimport org.jetbrains.exposed.dao.id.EntityIDimport org.jetbrains.exposed.dao.id.IntIdTable

object UsersDAO : IntIdTable() {    val name = varchar("name", 50)    val email = varchar("email", 100)}

class User(id: EntityID<Int>) : IntEntity(id) {    companion object : IntEntityClass<User>(UsersDAO)    var name by UsersDAO.name    var email by UsersDAO.email}

// Utilisationtransaction {    val newUser = User.new {        name = "Maria"        email = "maria@example.com"    }    println("Utilisateur créé avec l'ID : ${newUser.id.value}")}

2. Travailler avec MongoDB via KMongo

KMongo est un pilote orienté coroutines pour MongoDB, construit au-dessus du pilote Java officiel. Il prend en charge la sérialisation via kotlinx.serialization et Jackson.