Kotlin Academy · Leçon

Configuration d’Exposed : connexion à la base de données et DSL des transactions

Connectez-vous à une base de données, configurez Exposed et exécutez du code dans des transactions.

Configuration d’Exposed : connexion à la base de données et DSL des transactions est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Qu’est-ce qu’Exposed ?

Exposed est un framework SQL léger de JetBrains pour Kotlin. Il propose deux niveaux : un DSL de requêtes (avec des expressions SQL dont les types sont vérifiés) et une couche DAO (des entités de style Active Record). Les deux s’exécutent dans des transactions explicites.

Ajout des dépendances Exposed

Ajoutez le cœur, le pont vers le pilote JDBC et le pilote de votre base de données :

dependencies {
    implementation("org.jetbrains.exposed:exposed-core:0.52.0")
    implementation("org.jetbrains.exposed:exposed-jdbc:0.52.0")
    implementation("org.jetbrains.exposed:exposed-dao:0.52.0")
    implementation("com.h2database:h2:2.2.224") // or postgresql driver
    implementation("com.zaxxer:HikariCP:5.1.0")  // connection pooling
}

Connexion à la base de données

Appelez Database.connect() une seule fois au démarrage. En production, transmettez un HikariDataSource ; pour les tests, une simple URL JDBC convient :

import org.jetbrains.exposed.sql.Database

// Simple (dev/test)
Database.connect(
    url = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1",
    driver = "org.h2.Driver"
)

// Production with HikariCP
Database.connect(HikariDataSource(HikariConfig().apply {
    jdbcUrl = "jdbc:postgresql://localhost/mydb"
    username = "user"
    password = "pass"
    maximumPoolSize = 10
}))

Le bloc transaction { }

Toutes les opérations Exposed doivent s’exécuter dans un bloc transaction { }. Exposed valide la transaction en cas de succès et l’annule en cas d’exception non interceptée :

transaction {
    // all DB operations here
    SchemaUtils.create(Users)
}

Transactions compatibles avec les coroutines

Utilisez newSuspendedTransaction { } depuis exposed-r2dbc ou exposed-spring-boot-starter pour effectuer des transactions compatibles avec les coroutines. Dans Ktor, encapsulez les appels Exposed bloquants dans withContext(Dispatchers.IO) { transaction { ... } } :

suspend fun findUser(id: Long): User? = withContext(Dispatchers.IO) {
    transaction {
        UserEntity.findById(id)?.toUser()
    }
}

SchemaUtils : création et suppression de tables

Utilisez SchemaUtils.create(Table1, Table2) pour créer les tables qui n’existent pas et SchemaUtils.drop() pour les supprimer. Appelez cette fonction dans un bloc transaction { } au démarrage de l’application :

transaction {
    SchemaUtils.create(Users, Posts, Comments)
}

Configuration d’une connexion dans Ktor

Initialisez la base de données dans un module d’application afin que cette opération ne s’exécute qu’une seule fois au démarrage du serveur :

fun Application.configureDatabase() {
    val dbUrl = environment.config.property("ktor.database.url").getString()
    Database.connect(dbUrl, driver = "org.postgresql.Driver",
        user = "...", password = "...")
    transaction { SchemaUtils.create(Users) }
}

Niveaux d’isolation des transactions

Transmettez un niveau d’isolation à transaction() lorsque vous avez besoin de garanties de cohérence plus fortes ou plus faibles :

transaction(Connection.TRANSACTION_SERIALIZABLE) {
    // serializable isolation
}

Transactions imbriquées

Par défaut, les appels imbriqués à transaction { } rejoignent la transaction externe. Pour obtenir une transaction indépendante, utilisez transaction(db, outerTransactionIsEmpty = false) { } ou un point de sauvegarde.

Journalisation SQL

Activez la journalisation SQL pour voir les requêtes générées pendant le développement. Définissez un StdOutSqlLogger ou un enregistreur personnalisé dans le bloc de transaction :

transaction {
    addLogger(StdOutSqlLogger)
    // ...
}

Bonnes pratiques pour le regroupement des connexions

Utilisez toujours HikariCP (ou un équivalent) en production. Définissez maximumPoolSize en fonction du nombre de fils d’exécution de votre serveur et configurez connectionTimeout pour échouer rapidement lorsque le pool est épuisé. Surveillez l’utilisation du pool en production.

Vérification rapide

Que se passe-t-il si une exception non interceptée est levée dans un bloc transaction { } d’Exposed ?

Récapitulatif : configuration d’Exposed et DSL des transactions

Points essentiels :

Connectez la base avec Database.connect() une seule fois au démarrage (utilisez HikariCP en production)
Exécutez toutes les opérations de base de données dans transaction { } : la transaction est validée en cas de succès et annulée en cas d’exception
Créez et supprimez les tables avec SchemaUtils.create() dans une transaction
Dans les contextes utilisant des coroutines, encapsulez les appels Exposed bloquants dans withContext(Dispatchers.IO)
Activez StdOutSqlLogger pendant le développement pour inspecter le SQL généré

Questions Fréquemment Posées

La leçon « Configuration d’Exposed : connexion à la base de données et DSL des transactions » est-elle gratuite ?

Oui — le texte complet de « Configuration d’Exposed : connexion à la base de données et DSL des transactions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Configuration d’Exposed : connexion à la base de données et DSL des transactions » ?

Connectez-vous à une base de données, configurez Exposed et exécutez du code dans des transactions. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Configuration d’Exposed : connexion à la base de données et DSL des transactions » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Configuration d’Exposed : connexion à la base de données et DSL des transactions
Définir des tables avec le DSL Table
CRUD avec le DSL de requêtes : insert, select, update, delete
DAO Exposed : classes d’entités et relations

← Retour à Kotlin Academy