ORM pour Kotlin : comparaison et exemples (Exposed, Ktorm, Hibernate)

ORM pour Kotlin : comparaison et exemples

Lors du développement en Kotlin, le choix d'un ORM (Object-Relational Mapping) approprié est une étape clé qui influence les performances, la lisibilité du code et la facilité de maintenance. Dans cet article, nous comparons trois solutions populaires : Exposed (bibliothèque officielle de JetBrains), Ktorm (ORM légère orientée DSL) et Hibernate (classique et lourd). Nous analyserons leurs points forts, leurs particularités et fournirons des exemples concrets.

1. Exposed — le choix de JetBrains

Exposed est un ORM développé spécifiquement pour Kotlin par JetBrains. Il propose deux approches : DSL (type-safe) et DAO (Data Access Objects). Son principal avantage est une intégration complète avec le langage : les tables sont décrites comme des objets Kotlin, et les requêtes sont vérifiées à la compilation.

Exemple (approche DSL) :

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

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

fun main() {    Database.connect("jdbc:h2:mem:test", driver = "org.h2.Driver")    transaction {        SchemaUtils.create(Users)        Users.insert {            it[name] = "Иван"            it[email] = "ivan@example.com"        }        val result = Users.selectAll().map {            "${it[Users.name]} - ${it[Users.email]}"        }        println(result) // [Иван - ivan@example.com]    }}

Caractéristiques :

• Requêtes type-safe (moins d'erreurs d'exécution).
• Pas besoin de réflexion (plus rapide que Hibernate).
• Support des migrations via exposed-migration.
• Pas besoin de configuration XML ou d'annotations — tout dans le code.

2. Ktorm — légèreté et flexibilité

Ktorm est un ORM minimaliste qui utilise le DSL Kotlin pour construire des requêtes SQL. Contrairement à Exposed, il ne génère pas automatiquement le SQL, mais permet d'écrire des requêtes presque comme en SQL pur, avec une vérification de types.

Exemple :

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

interface User : Entity<User> {    companion object : Entity.Factory<User>()    val id: Int    val name: String    val email: String}

object Users : Table<User>("users") {    val id = int("id").primaryKey().bindTo { it.id }    val name = varchar("name").bindTo { it.name }    val email = varchar("email").bindTo { it.email }}

fun main() {    val database = Database.connect("jdbc:h2:mem:test", driver = "org.h2.Driver")    database.sequenceOf(Users).toList() // Obtenir tous les utilisateurs    // Insertion :    val user = User {        name = "Петр"        email = "petr@example.com"    }    database.users.add(user)}

Caractéristiques :

• Très proche du SQL — facile d'optimiser les requêtes.
• Taille JAR réduite (~200 Ko).
• Support d'extensions : ktorm-jackson, ktorm-spring-support.
• Nécessite une liaison explicite des champs (bindTo), ce qui augmente le boilerplate.

3. Hibernate — un standard éprouvé

Hibernate est un ORM puissant mais lourd issu du monde Java. En Kotlin, il s'utilise via des annotations ou du XML. Hibernate offre un contrôle complet sur la mise en cache, le chargement paresseux et la génération de schéma. Cependant, en raison de la réflexion et des classes proxy, des problèmes peuvent survenir avec les data class (nécessité de open).

Exemple :

import javax.persistence.*

@Entity@Table(name = "users")data class User(    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)    val id: Int = 0,    @Column(nullabl