Kotlin Academy · Lektion

Exposed DAO: Entity-klasser og relationer

Brug DAO-API'et til at mappe tabeller til entity-klasser og navigere i relationer.

Lektion 4 af 413 trin

Exposed DAO: Entity-klasser og relationer er en gratis Kotlin Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Kotlin Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Kotlin Academy-kurset indeholder 4 lektioner i alt.

Hvad er Exposed-DAO-laget?

DAO-laget i Exposed omslutter Query DSL med en API i Active Record-stil. Du definerer Entity-underklasser, der knytter sig til tabelrækker, og læser eller skriver egenskaber direkte på Entity-instanser.

Definition af en Entity

Kombinér en LongIdTable med en Entity-underklasse. Hver Entity-klasse har en tilhørende EntityClass, der håndterer forespørgsler:

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
}

Oprettelse af en Entity

Brug Entity.new { } inden i en transaction { } for at oprette en ny række og få en Entity-instans tilbage:

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

Sådan finder du Entities

Den tilhørende EntityClass leverer findermetoderne findById(id), all() og find { condition }:

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

Opdatering af en Entity

Læs en Entity, ændr dens egenskaber inden i en transaction, så genererer Exposed automatisk UPDATE-sætningen, når transactionen gennemføres:

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

Sletning af en Entity

Kald entity.delete() inden i en transaction for at fjerne den tilsvarende række:

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

En-til-mange-relationer

Referér til en overordnet Entity fra en underordnet ved hjælp af reference() på tabellen og en delegeret by-egenskab på Entity'en. Få adgang til listen over underordnede fra den overordnede via referrersOn:

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

Mange-til-mange-relationer

Brug en mellemliggende join-tabel. Eksponér den som en EntityClass, og få adgang til begge sider ved hjælp af via():

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

Ivrig kontra doven indlæsning

Som standard indlæser Exposed relaterede Entities dovent — hver adgang udløser en SQL-forespørgsel. Brug load() eller with() til at indlæse relationer ivrigt og undgå problemer med N+1-forespørgsler:

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

Cachelagring inden for en transaction

Exposed cachelagrer Entity-instanser inden for en transaction. Hvis du tilgår den samme Entity via dens ID flere gange i én transaction, får du det samme objekt i hukommelsen tilbage — uden overflødige ture til databasen.

Hvornår skal du bruge DAO frem for Query DSL

Brug DAO-laget, når du ønsker objektorienterede adgangsmønstre med relationer. Brug Query DSL til masseoperationer, komplekse joins, aggregationer eller når ydeevnen er vigtig, og du ønsker præcis kontrol over SQL.

Hurtigt tjek

Hvordan opretter du en ny række og får en Entity-instans med det samme ved hjælp af Exposed DAO?

Besvar den i den interaktive lektion

Opsummering: Exposed DAO — Entity-klasser og relationer

Vigtigste pointer:

Kombinér en LongIdTable med en LongEntity-underklasse; egenskaber delegerer til kolonnedefinitioner
Entity.new { } — opretter; findById(), find { }, all() — forespørger; entity.delete() — fjerner
En-til-mange: referencedOn (underordnet side), referrersOn (overordnet side)
Mange-til-mange: join-tabel + via()
Brug with() til at indlæse relationer ivrigt og undgå N+1-forespørgsler

Gratis at komme i gang

Lær Kotlin med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 51
Lektioner: 203

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Exposed DAO: Entity-klasser og relationer” gratis?

Ja — alle 3 lektioner i læringssporet Kotlin Academy, inklusive “Exposed DAO: Entity-klasser og relationer”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Kotlin Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Exposed DAO: Entity-klasser og relationer”?

Brug DAO-API'et til at mappe tabeller til entity-klasser og navigere i relationer. Du øver dig i Kotlin Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Kotlin Academy?

Der kræves ingen tidligere erfaring. Kotlin Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Exposed DAO: Entity-klasser og relationer”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Kotlin Academy-lektion?

Ja. Alle Kotlin Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Exposed-opsætning: Databaseforbindelse og transaction-DSL
Definition af tabeller med Table-DSL'en
CRUD med Query-DSL'en: insert, select, update, delete
Exposed DAO: Entity-klasser og relationer

← Tilbage til Kotlin Academy