ORM pour Kotlin : Exposed vs Ktor vs Ktorm — comparaison et exemples

ORM pour Kotlin : comparaison et exemples

Kotlin est un langage moderne activement utilisé pour le développement d'applications backend, d'applications Android et même de projets multiplateformes. Pour travailler avec des bases de données, les développeurs choisissent souvent un ORM (Object-Relational Mapping) afin d'éviter d'écrire des requêtes SQL brutes et d'accélérer le développement. Dans cet article, nous examinerons trois outils ORM populaires pour Kotlin : Exposed, Ktor (en combinaison avec Exposed) et Ktorm. Nous comparerons leur syntaxe, leurs performances et leur facilité d'utilisation à l'aide d'exemples pratiques.

1. Exposed — l'ORM officiel de JetBrains

Exposed est une bibliothèque ORM développée par JetBrains spécialement pour Kotlin. Elle prend en charge deux approches : DSL (Domain Specific Language) et DAO (Data Access Objects). Exposed s'intègre parfaitement avec le framework Ktor, mais peut également être utilisé indépendamment.

Caractéristiques clés :

• Syntaxe DSL légère et intuitive.
• Prise en charge des transactions, des migrations et des connexions.
• Fonctionne avec PostgreSQL, MySQL, H2, SQLite et d'autres bases de données.
• Communauté active et documentation officielle.

Exemple de code (approche DSL) :

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

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

    override val primaryKey = PrimaryKey(id)}

// Exemple de requêtefun main() {    Database.connect("jdbc:h2:mem:test", driver = "org.h2.Driver")

    transaction {        SchemaUtils.create(Users)

        // Insertion        Users.insert {            it[name] = "Alice"            it[age] = 30        }

        // Sélection        val result = Users.selectAll().where { Users.age greater 25 }        result.forEach {            println("${it[Users.name]}: ${it[Users.age]}")        }    }}

2. Ktor + Exposed — une combinaison pour les applications web

Ktor est un framework web asynchrone pour Kotlin. Bien que Ktor lui-même ne fournisse pas d'ORM intégré, il fonctionne parfaitement avec Exposed. Cette combinaison permet de créer des API REST avec un minimum de code.

Exemple d'intégration de Ktor avec Exposed :

import io.ktor.server.application.*import io.ktor.server.routing.*import io.ktor.server.response.*import org.jetbrains.exposed.sql.*import org.jetbrains.exposed.sql.transactions.transaction

fun Application.module() {    Database.connect("jdbc:h2:mem:test", driver = "org.h2.Driver")

    routing {        get("/users") {            val users = transaction {                Users.selectAll().map {                    mapOf("name" to it[Users.name], "age" to it[Users.age])                }            }            call.respond(users)        }    }}

Cette approche convient aux microservices et aux petits projets où la simplicité et la rapidité de développement sont importantes.

3. Ktorm — un ORM léger et performant

Ktorm est un autre ORM populaire pour Kotlin, axé sur les performances et le minimalisme. Il utilise la programmation fonctionnelle et prend en charge à la fois la syntaxe DSL et la syntaxe de type SQL.

Caractéristiques clés :

• Haute performance grâce à l'absence de réflexion.
• Prise en charge des extensions (par exemple, pour les champs JSON).
• Configuration simple et dépendances minimales.
• Fonctionne avec la plupart des SGBD populaires.

Exemple de code Ktorm :

import me.liuwj.ktorm.database.Databaseimport me.liuwj.ktorm.dsl.*import me.liuwj.ktorm.entity.*

// Définition de l'entitéinterface User : Entity {    compan