Kotlin Academy · Lekcja

Exposed DAO: klasy encji i relacje

Używaj API DAO do mapowania tabel na klasy encji i poruszania się po relacjach.

Exposed DAO: klasy encji i relacje to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Czym jest warstwa DAO Exposed

Warstwa DAO (Data Access Object) biblioteki Exposed opakowuje Query DSL za pomocą interfejsu API w stylu Active Record. Definiuje się podklasy Entity, które odwzorowują wiersze tabel, a następnie odczytuje i zapisuje właściwości bezpośrednio w instancjach encji.

Definiowanie encji

Należy połączyć LongIdTable z podklasą Entity. Każda klasa encji ma towarzyszącą klasę EntityClass, która obsługuje zapytania:

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
}

Tworzenie encji

Należy użyć Entity.new { } wewnątrz transaction { }, aby utworzyć nowy wiersz i otrzymać z powrotem instancję encji:

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

Wyszukiwanie encji

Towarzysząca klasa EntityClass udostępnia metody wyszukiwania: findById(id), all() i find { condition }:

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

Aktualizowanie encji

Należy odczytać encję i zmienić jej właściwości wewnątrz transakcji. Exposed automatycznie wygeneruje instrukcję UPDATE podczas zatwierdzania transakcji:

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

Usuwanie encji

Należy wywołać entity.delete() wewnątrz transakcji, aby usunąć odpowiadający jej wiersz:

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

Relacje jeden-do-wielu

Należy odwołać się do encji nadrzędnej z encji podrzędnej za pomocą reference() w tabeli oraz delegowanej właściwości by w encji. Lista elementów podrzędnych jest dostępna z poziomu encji nadrzędnej za pomocą 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

Relacje wiele-do-wielu

Należy użyć pośredniej tabeli złączeń. Należy udostępnić ją jako EntityClass i uzyskać dostęp do obu stron za pomocą 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

Ładowanie eager a lazy

Domyślnie Exposed ładuje powiązane encje leniwie — każde odwołanie powoduje wykonanie zapytania SQL. Należy użyć load() lub with(), aby załadować relacje zachłannie i uniknąć problemu zapytań N+1:

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

Buforowanie w ramach transakcji

Exposed buforuje instancje encji w ramach transakcji. Wielokrotny dostęp do tej samej encji po jej identyfikatorze w jednej transakcji zwraca ten sam obiekt w pamięci — bez zbędnych dodatkowych odwołań do bazy danych.

Kiedy używać DAO, a kiedy Query DSL

Warstwy DAO należy używać, gdy potrzebny jest obiektowy sposób dostępu z obsługą relacji. Query DSL sprawdzi się w przypadku operacji zbiorczych, złożonych złączeń, agregacji lub wtedy, gdy wydajność ma znaczenie i potrzebna jest precyzyjna kontrola nad SQL.

Szybkie sprawdzenie

Jak za pomocą Exposed DAO utworzyć nowy wiersz i od razu otrzymać instancję encji?

Podsumowanie: Exposed DAO — klasy encji i relacje

Najważniejsze informacje:

Należy połączyć LongIdTable z podklasą LongEntity; właściwości delegują do definicji kolumn
Entity.new { } — tworzy; findById(), find { }, all() — wyszukują; entity.delete() — usuwa
Relacja jeden-do-wielu: referencedOn (strona podrzędna), referrersOn (strona nadrzędna)
Relacja wiele-do-wielu: tabela złączeń + via()
Należy użyć with(), aby załadować relacje zachłannie i uniknąć zapytań N+1

Często zadawane pytania

Czy lekcja „Exposed DAO: klasy encji i relacje” jest bezpłatna?

Tak — pełny tekst „Exposed DAO: klasy encji i relacje” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Exposed DAO: klasy encji i relacje”?

Używaj API DAO do mapowania tabel na klasy encji i poruszania się po relacjach. Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Exposed DAO: klasy encji i relacje”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Konfiguracja Exposed: połączenie z bazą danych i DSL transakcji
Definiowanie tabel za pomocą DSL Table
CRUD z DSL zapytań: insert, select, update, delete
Exposed DAO: klasy encji i relacje

← Powrót do Kotlin Academy