Kotlin Academy · Lektion

Exposed einrichten: Datenbankverbindung und Transaction-DSL

Verbinden Sie eine Datenbank, konfigurieren Sie Exposed und führen Sie Code innerhalb von Transaktionen aus.

Exposed einrichten: Datenbankverbindung und Transaction-DSL ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Exposed?

Exposed ist ein leichtgewichtiges SQL-Framework von JetBrains für Kotlin. Es bietet zwei Ebenen: eine Query DSL (typsichere SQL-Ausdrücke) und eine DAO-Schicht (Entitäten im Stil von Active Record). Beide werden innerhalb expliziter Transaktionen ausgeführt.

Exposed-Abhängigkeiten hinzufügen

Fügen Sie den Kern, die JDBC-Treiberanbindung und Ihren Datenbanktreiber hinzu:

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
}

Mit der Datenbank verbinden

Rufen Sie Database.connect() einmal beim Start auf. Übergeben Sie in der Produktion eine HikariDataSource; für Tests reicht eine einfache JDBC-URL aus:

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
}))

Der Block transaction { }

Alle Exposed-Operationen müssen innerhalb eines transaction { }-Blocks ausgeführt werden. Exposed führt bei Erfolg einen Commit durch und bei jeder nicht abgefangenen Ausnahme ein Rollback:

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

Coroutine-freundliche Transaktionen

Verwenden Sie newSuspendedTransaction { } aus exposed-r2dbc oder den exposed-spring-boot-starter für coroutine-kompatible Transaktionen. Umschließen Sie in Ktor blockierende Exposed-Aufrufe mit withContext(Dispatchers.IO) { transaction { ... } }:

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

SchemaUtils: Tabellen erstellen und löschen

Verwenden Sie SchemaUtils.create(Table1, Table2), um nicht vorhandene Tabellen zu erstellen, und SchemaUtils.drop(), um sie zu löschen. Rufen Sie dies beim Anwendungsstart innerhalb eines transaction { }-Blocks auf:

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

Eine Verbindung in Ktor konfigurieren

Initialisieren Sie die Datenbank in einem Application-Modul, damit dies einmal beim Start des Servers ausgeführt wird:

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) }
}

Transaktionsisolationsstufen

Übergeben Sie transaction() eine Isolationsstufe, wenn Sie stärkere oder schwächere Konsistenzgarantien benötigen:

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

Verschachtelte Transaktionen

Standardmäßig werden verschachtelte Aufrufe von transaction { } in die äußere Transaktion aufgenommen. Verwenden Sie transaction(db, outerTransactionIsEmpty = false) { } oder einen Savepoint, um eine unabhängige Transaktion zu erhalten.

SQL protokollieren

Aktivieren Sie die SQL-Protokollierung, um während der Entwicklung die generierten Abfragen zu sehen. Setzen Sie innerhalb des Transaktionsblocks einen StdOutSqlLogger oder einen benutzerdefinierten Logger:

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

Bewährte Methoden für Connection-Pooling

Verwenden Sie in der Produktion immer HikariCP oder eine vergleichbare Lösung. Setzen Sie maximumPoolSize passend zur Thread-Anzahl Ihres Servers und connectionTimeout, damit bei erschöpftem Pool schnell ein Fehler auftritt. Überwachen Sie die Pool-Auslastung in der Produktion.

Kurzer Check

Was geschieht, wenn innerhalb eines transaction { }-Blocks in Exposed eine nicht abgefangene Ausnahme ausgelöst wird?

Zusammenfassung: Exposed-Setup und Transaction DSL

Wichtigste Erkenntnisse:

Stellen Sie mit Database.connect() einmal beim Start eine Verbindung her (verwenden Sie in der Produktion HikariCP)
Alle Datenbankoperationen werden innerhalb von transaction { } ausgeführt – bei Erfolg wird ein Commit durchgeführt, bei einer Ausnahme ein Rollback
Erstellen und löschen Sie Tabellen mit SchemaUtils.create() innerhalb einer Transaktion
Umschließen Sie blockierende Exposed-Aufrufe in Coroutine-Kontexten mit withContext(Dispatchers.IO)
Aktivieren Sie während der Entwicklung StdOutSqlLogger, um das generierte SQL zu untersuchen

Häufig gestellte Fragen

Ist die Lektion „Exposed einrichten: Datenbankverbindung und Transaction-DSL“ kostenlos?

Ja — der vollständige Text von „Exposed einrichten: Datenbankverbindung und Transaction-DSL“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Exposed einrichten: Datenbankverbindung und Transaction-DSL“?

Verbinden Sie eine Datenbank, konfigurieren Sie Exposed und führen Sie Code innerhalb von Transaktionen aus. Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Exposed einrichten: Datenbankverbindung und Transaction-DSL“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Exposed einrichten: Datenbankverbindung und Transaction-DSL
Tabellen mit der Table-DSL definieren
CRUD mit der Query-DSL: insert, select, update, delete
Exposed DAO: Entity-Klassen und Beziehungen

← Zurück zu Kotlin Academy