Kotlin Academy · Lektion

Exposed DAO: Entity-Klassen und Beziehungen

Verwenden Sie die DAO-API, um Tabellen auf Entity-Klassen abzubilden und Beziehungen zu durchlaufen.

Exposed DAO: Entity-Klassen und Beziehungen ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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 die Exposed-DAO-Schicht?

Die Exposed-DAO-Schicht (Data Access Object) kapselt die Query DSL mit einer API im Active-Record-Stil. Sie definieren Entity-Unterklassen, die Tabellenzeilen zuordnen, und lesen oder schreiben Eigenschaften direkt über Entity-Instanzen.

Eine Entity definieren

Kombinieren Sie eine LongIdTable mit einer Entity-Unterklasse. Jede Entity-Klasse besitzt ein EntityClass-Companion-Objekt, das die Abfragen übernimmt:

object Users : LongIdTable("users") {
    val name  = varchar("name", 100)
    val email = varchar("email", 255)
}

class User(id: EntityID<Long>) : LongEntity(id) {
    companion object : LongEntityClass<User>(Users)
    var name  by Users.name
    var email by Users.email
}

Eine Entity erstellen

Verwenden Sie Entity.new { } innerhalb von transaction { }, um eine neue Zeile zu erstellen und eine Entity-Instanz zurückzuerhalten:

val alice: User = transaction {
    User.new {
        name  = "Alice"
        email = "alice@example.com"
    }
}

Entities finden

Das EntityClass-Companion-Objekt stellt Suchmethoden bereit: findById(id), all() und find { condition }:

transaction {
    val user: User? = User.findById(1L)
    val allUsers: SizedIterable<User> = User.all()
    val filtered = User.find { Users.name like "Al%" }.toList()
}

Eine Entity aktualisieren

Lesen Sie eine Entity aus, ändern Sie ihre Eigenschaften innerhalb einer Transaktion, und Exposed erzeugt das UPDATE automatisch, sobald die Transaktion festgeschrieben wird:

transaction {
    val user = User.findById(1L) ?: error("Not found")
    user.name = "Alice Smith"
    // UPDATE issued on transaction commit
}

Eine Entity löschen

Rufen Sie entity.delete() innerhalb einer Transaktion auf, um die entsprechende Zeile zu entfernen:

transaction {
    User.findById(5L)?.delete()
}

Eins-zu-viele-Beziehungen

Referenzieren Sie eine übergeordnete Entity aus einer untergeordneten Entity, indem Sie reference() in der Tabelle und eine delegierte by-Eigenschaft in der Entity verwenden. Über referrersOn greifen Sie von der übergeordneten Entity aus auf die Liste der untergeordneten Entities zu:

object Posts : LongIdTable("posts") {
    val title    = varchar("title", 300)
    val authorId = reference("author_id", Users)
}
class Post(id: EntityID<Long>) : LongEntity(id) {
    companion object : LongEntityClass<Post>(Posts)
    var title  by Posts.title
    var author by User referencedOn Posts.authorId
}
// On User entity:
val posts by Post referrersOn Posts.authorId

Viele-zu-viele-Beziehungen

Verwenden Sie eine zwischengeschaltete Verknüpfungstabelle. Stellen Sie sie als EntityClass bereit und greifen Sie über via() auf beide Seiten zu:

object UserRoles : Table("user_roles") {
    val user = reference("user_id", Users)
    val role = reference("role_id", Roles)
}
// On User entity:
var roles by Role via UserRoles

Eager Loading und Lazy Loading

Standardmäßig lädt Exposed verbundene Entities verzögert — jeder Zugriff löst eine SQL-Abfrage aus. Verwenden Sie load() oder with(), um Beziehungen eager zu laden und N+1-Abfrageprobleme zu vermeiden:

transaction {
    User.all().with(User::posts).forEach { user ->
        println("${user.name}: ${user.posts.count()} posts")
    }
}

Caching innerhalb einer Transaktion

Exposed cached Entity-Instanzen innerhalb einer Transaktion. Wenn Sie in einer Transaktion mehrmals über die ID auf dieselbe Entity zugreifen, erhalten Sie dasselbe Objekt im Arbeitsspeicher — ohne redundante Roundtrips zur Datenbank.

Wann Sie DAO und wann Sie die Query DSL verwenden sollten

Verwenden Sie die DAO-Schicht, wenn Sie objektorientierte Zugriffsmuster mit Beziehungen benötigen. Verwenden Sie die Query DSL für Massenoperationen, komplexe Joins und Aggregationen oder wenn die Performance wichtig ist und Sie eine präzise Kontrolle über das SQL wünschen.

Kurze Überprüfung

Wie erstellen Sie mit Exposed DAO eine neue Zeile und erhalten sofort eine Entity-Instanz?

Zusammenfassung: Exposed DAO — Entity-Klassen und Beziehungen

Wichtige Erkenntnisse:

Kombinieren Sie eine LongIdTable mit einer LongEntity-Unterklasse; Eigenschaften delegieren an Spaltendefinitionen
Entity.new { } — erstellen; findById(), find { }, all() — abfragen; entity.delete() — entfernen
Eins-zu-viele: referencedOn (Seite der untergeordneten Entity), referrersOn (Seite der übergeordneten Entity)
Viele-zu-viele: Verknüpfungstabelle + via()
Verwenden Sie with(), um Beziehungen eager zu laden und N+1-Abfragen zu vermeiden

Häufig gestellte Fragen

Ist die Lektion „Exposed DAO: Entity-Klassen und Beziehungen“ kostenlos?

Ja — der vollständige Text von „Exposed DAO: Entity-Klassen und Beziehungen“ 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 DAO: Entity-Klassen und Beziehungen“?

Verwenden Sie die DAO-API, um Tabellen auf Entity-Klassen abzubilden und Beziehungen zu durchlaufen. 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 4 von 4.

Wie lange dauert die Lektion „Exposed DAO: Entity-Klassen und Beziehungen“?

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