Kotlin Academy · Leçon

DAO Exposed : classes d’entités et relations

Utilisez l’API DAO pour mapper les tables vers des classes d’entités et parcourir les relations.

DAO Exposed : classes d’entités et relations est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que la couche DAO d'Exposed

La couche DAO (objet d'accès aux données) d'Exposed encapsule le DSL de requêtes avec une API de type Active Record. Vous définissez des sous-classes de Entity qui correspondent aux lignes des tables, puis lisez et modifiez directement les propriétés des instances d'entités.

Définir une entité

Associez un LongIdTable à une sous-classe de Entity. Chaque classe d'entité possède un EntityClass compagnon qui gère les requêtes :

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
}

Créer une entité

Utilisez Entity.new { } dans un transaction { } pour créer une nouvelle ligne et récupérer une instance d'entité :

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

Rechercher des entités

Le EntityClass compagnon fournit des méthodes de recherche : findById(id), all() et find { condition } :

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

Mettre à jour une entité

Lisez une entité, modifiez ses propriétés dans une transaction, et Exposed émettra automatiquement l'instruction UPDATE lors de la validation de la transaction :

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

Supprimer une entité

Appelez entity.delete() dans une transaction pour supprimer la ligne correspondante :

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

Relations un-à-plusieurs

Référencez une entité parente depuis une entité enfant en utilisant reference() sur la table et une propriété déléguée avec by sur l'entité. Accédez à la liste des enfants depuis le parent 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

Relations plusieurs-à-plusieurs

Utilisez une table de jointure intermédiaire. Exposez-la sous forme d'un EntityClass et accédez aux deux côtés avec 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

Chargement anticipé ou différé

Par défaut, Exposed charge les entités associées de manière différée — chaque accès déclenche une requête SQL. Utilisez load() ou with() pour charger les relations de manière anticipée et éviter les problèmes de requêtes N+1 :

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

Mise en cache dans une transaction

Exposed met en cache les instances d'entités dans une transaction. Accéder plusieurs fois à la même entité par son identifiant au cours d'une transaction renvoie le même objet en mémoire — aucun aller-retour redondant vers la base de données.

Quand utiliser le DAO ou le DSL de requêtes

Utilisez la couche DAO lorsque vous souhaitez des modes d'accès orientés objet avec des relations. Utilisez le DSL de requêtes pour les opérations en masse, les jointures complexes, les agrégations ou lorsque les performances sont importantes et que vous voulez contrôler précisément le SQL.

Vérification rapide

Comment créer une nouvelle ligne et récupérer immédiatement une instance d'entité avec le DAO d'Exposed ?

Récapitulatif : DAO d'Exposed — classes d'entités et relations

Points essentiels :

Associez un LongIdTable à une sous-classe de LongEntity ; les propriétés sont déléguées aux définitions de colonnes
Entity.new { } — créer ; findById(), find { }, all() — rechercher ; entity.delete() — supprimer
Un-à-plusieurs : referencedOn (côté enfant), referrersOn (côté parent)
Plusieurs-à-plusieurs : table de jointure + via()
Utilisez with() pour charger les relations de manière anticipée et éviter les requêtes N+1

Questions Fréquemment Posées

La leçon « DAO Exposed : classes d’entités et relations » est-elle gratuite ?

Oui — le texte complet de « DAO Exposed : classes d’entités et relations » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « DAO Exposed : classes d’entités et relations » ?

Utilisez l’API DAO pour mapper les tables vers des classes d’entités et parcourir les relations. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « DAO Exposed : classes d’entités et relations » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Configuration d’Exposed : connexion à la base de données et DSL des transactions
Définir des tables avec le DSL Table
CRUD avec le DSL de requêtes : insert, select, update, delete
DAO Exposed : classes d’entités et relations

← Retour à Kotlin Academy