Kotlin Academy · Lezione

DAO di Exposed: classi Entity e relazioni

Utilizzi l'API DAO per mappare le tabelle nelle classi entity e navigare le relazioni.

Lezione 4 di 413 passaggi

DAO di Exposed: classi Entity e relazioni è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Che cos'è il livello DAO di Exposed

Il livello DAO (Data Access Object) di Exposed racchiude il Query DSL in un'API in stile Active Record. Definisca sottoclassi di Entity che eseguono il mapping delle righe delle tabelle, quindi legga e scriva direttamente le proprietà sulle istanze delle entity.

Definizione di un'entity

Associ una LongIdTable a una sottoclasse di Entity. Ogni classe entity dispone di un companion EntityClass che gestisce le query:

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
}

Creazione di un'entity

Utilizzi Entity.new { } all'interno di transaction { } per creare una nuova riga e ottenere in risposta un'istanza dell'entity:

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

Ricerca delle entity

Il companion EntityClass fornisce metodi di ricerca: findById(id), all() e find { condition }:

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

Aggiornamento di un'entity

Legga un'entity, ne modifichi le proprietà all'interno di una transazione e Exposed genererà automaticamente l'UPDATE al commit della transazione:

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

Eliminazione di un'entity

Chiami entity.delete() all'interno di una transazione per rimuovere la riga corrispondente:

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

Relazioni uno-a-molti

Faccia riferimento a un'entity padre da un'entity figlia utilizzando reference() sulla tabella e una proprietà delegata con by sull'entity. Acceda all'elenco delle entity figlie dal padre tramite 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

Relazioni molti-a-molti

Utilizzi una tabella di join intermedia. La esponga come EntityClass e acceda a entrambi i lati tramite 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

Caricamento eager e lazy

Per impostazione predefinita, Exposed carica le entity correlate in modo lazy: ogni accesso esegue una query SQL. Utilizzi load() o with() per caricare eager le relazioni ed evitare problemi di query N+1:

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

Caching all'interno di una transazione

Exposed memorizza nella cache le istanze delle entity all'interno di una transazione. Accedere più volte alla stessa entity tramite ID nella stessa transazione restituisce lo stesso oggetto in memoria, senza round trip ridondanti verso il DB.

Quando usare il DAO invece del Query DSL

Utilizzi il livello DAO quando desidera modelli di accesso orientati agli oggetti con relazioni. Utilizzi il Query DSL per operazioni bulk, join complessi, aggregazioni oppure quando le prestazioni sono importanti e desidera un controllo preciso sull'SQL.

Verifica rapida

Come si crea una nuova riga ottenendo immediatamente un'istanza dell'entity usando il DAO di Exposed?

Rispondi nella lezione interattiva

Riepilogo: DAO di Exposed — classi Entity e relazioni

Punti chiave:

Associ una LongIdTable a una sottoclasse di LongEntity; le proprietà delegano alle definizioni delle colonne
Entity.new { } — crea; findById(), find { }, all() — eseguono query; entity.delete() — rimuove
Uno-a-molti: referencedOn (lato figlio), referrersOn (lato padre)
Molti-a-molti: tabella di join + via()
Utilizzi with() per caricare eager le relazioni ed evitare query N+1

Gratis per iniziare

Impara Kotlin con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 51
Lezioni: 203

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «DAO di Exposed: classi Entity e relazioni» è gratuita?

Sì — il testo completo di «DAO di Exposed: classi Entity e relazioni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «DAO di Exposed: classi Entity e relazioni»?

Utilizzi l'API DAO per mappare le tabelle nelle classi entity e navigare le relazioni. Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «DAO di Exposed: classi Entity e relazioni»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Configurazione di Exposed: connessione al database e DSL delle transazioni
Definire le tabelle con la DSL Table
CRUD con la DSL Query: insert, select, update, delete
DAO di Exposed: classi Entity e relazioni

← Torna a Kotlin Academy