ORM für Kotlin: Vergleich und Beispiele (Exposed, Ktorm, Hibernate)

ORM für Kotlin: Vergleich und Beispiele

Bei der Entwicklung mit Kotlin ist die Wahl einer geeigneten ORM (Object-Relational Mapping) ein entscheidender Schritt, der die Leistung, die Lesbarkeit des Codes und die Wartbarkeit beeinflusst. In diesem Artikel vergleichen wir drei beliebte Lösungen: Exposed (offizielle Bibliothek von JetBrains), Ktorm (leichtgewichtige, DSL-orientierte ORM) und Hibernate (klassischer Schwergewichtler). Wir analysieren ihre Stärken, Besonderheiten und geben funktionierende Beispiele.

1. Exposed – die Wahl von JetBrains

Exposed ist eine ORM, die speziell für Kotlin von JetBrains entwickelt wurde. Sie bietet zwei Ansätze: DSL (typsicher) und DAO (Data Access Objects). Der Hauptvorteil ist die vollständige Integration in die Sprache: Tabellen werden als Kotlin-Objekte beschrieben, Abfragen werden zur Kompilierzeit geprüft.

Beispiel (DSL-Ansatz):

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] = "Ivan"            it[email] = "ivan@example.com"        }        val result = Users.selectAll().map {            "${it[Users.name]} - ${it[Users.email]}"        }        println(result) // [Ivan - ivan@example.com]    }}

Besonderheiten:

• Typsichere Abfragen (weniger Laufzeitfehler).
• Keine Notwendigkeit für Reflektion (schneller als Hibernate).
• Unterstützung für Migrationen über exposed-migration.
• Erfordert keine XML- oder Annotation-Konfiguration – alles im Code.

2. Ktorm – Leichtigkeit und Flexibilität

Ktorm ist eine minimalistische ORM, die Kotlin DSL zum Erstellen von SQL-Abfragen verwendet. Im Gegensatz zu Exposed generiert sie SQL nicht automatisch, sondern ermöglicht es, Abfragen fast wie in reinem SQL zu schreiben, jedoch mit Typprüfung.

Beispiel:

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() // Alle Benutzer abrufen    // Einfügen:    val user = User {        name = "Petr"        email = "petr@example.com"    }    database.users.add(user)}

Besonderheiten:

• Maximal nah an SQL – Abfragen lassen sich leicht optimieren.
• Kleine JAR-Größe (~200 KB).
• Unterstützung für Erweiterungen: ktorm-jackson, ktorm-spring-support.
• Erfordert explizite Feldbindung (bindTo), was den Boilerplate-Code erhöht.

3. Hibernate – der bewährte Standard

Hibernate ist eine leistungsstarke, aber schwere ORM aus der Java-Welt. In Kotlin wird sie über Annotationen oder XML verwendet. Hibernate bietet vollständige Kontrolle über Caching, Lazy Loading und Schema-Generierung. Aufgrund von Reflektion und Proxy-Klassen kann es jedoch Probleme mit data class geben (erfordert open).

Beispiel:

import javax.persistence.*

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