Kotlin Academy · Aula

DAO do Exposed: classes de entidades e relacionamentos

Use a API DAO para mapear tabelas para classes de entidades e navegar pelos relacionamentos.

Aula 4 de 413 etapas

DAO do Exposed: classes de entidades e relacionamentos é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

O que é a camada DAO do Exposed?

A camada DAO (Objeto de Acesso a Dados) do Exposed encapsula a DSL de consultas com uma API no estilo de Registro Ativo. Você define subclasses de Entity que mapeiam para linhas da tabela e lê e grava propriedades diretamente nas instâncias de entidade.

Definindo uma entidade

Associe uma LongIdTable a uma subclasse de Entity. Cada classe de entidade tem uma EntityClass complementar que gerencia as consultas:

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
}

Criando uma entidade

Use Entity.new { } dentro de uma transaction { } para criar uma nova linha e obter de volta uma instância de entidade:

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

Encontrando entidades

A EntityClass complementar fornece métodos de busca: 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()
}

Atualizando uma entidade

Leia uma entidade, altere suas propriedades dentro de uma transação, e o Exposed emitirá automaticamente a UPDATE quando a transação for confirmada:

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

Excluindo uma entidade

Chame entity.delete() dentro de uma transação para remover a linha correspondente:

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

Relacionamentos um para muitos

Faça referência a uma entidade pai a partir de uma filha usando reference() na tabela e uma propriedade delegada com by na entidade. Acesse a lista de filhas a partir da entidade pai por meio de 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

Relacionamentos muitos para muitos

Use uma tabela de junção intermediária. Exponha-a como uma EntityClass e acesse ambos os lados usando 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

Carregamento antecipado vs. sob demanda

Por padrão, o Exposed carrega entidades relacionadas sob demanda — cada acesso dispara uma consulta SQL. Use load() ou with() para carregar os relacionamentos antecipadamente e evitar problemas de consultas N+1:

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

Armazenamento em cache dentro de uma transação

O Exposed armazena instâncias de entidades em cache dentro de uma transação. Acessar a mesma entidade pelo ID várias vezes em uma única transação retorna o mesmo objeto em memória — sem idas e vindas redundantes ao banco de dados.

Quando usar DAO ou a DSL de consultas

Use a camada DAO quando quiser padrões de acesso orientados a objetos com relacionamentos. Use a DSL de consultas para operações em massa, junções complexas, agregações ou quando o desempenho for importante e você quiser controle preciso sobre SQL.

Verificação rápida

Como criar uma nova linha e obter imediatamente uma instância de entidade usando o DAO do Exposed?

Responda na aula interativa

Recapitulação: DAO do Exposed — classes de entidades e relacionamentos

Principais conclusões:

Associe uma LongIdTable a uma subclasse de LongEntity; as propriedades delegam para definições de colunas
Entity.new { } — criar; findById(), find { }, all() — consultar; entity.delete() — remover
Um para muitos: referencedOn (lado da filha), referrersOn (lado do pai)
Muitos para muitos: tabela de junção + via()
Use with() para carregar os relacionamentos antecipadamente e evitar consultas N+1

Grátis para começar

Aprenda Kotlin com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 51
Aulas: 203

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “DAO do Exposed: classes de entidades e relacionamentos” é grátis?

Sim — o texto completo de “DAO do Exposed: classes de entidades e relacionamentos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “DAO do Exposed: classes de entidades e relacionamentos”?

Use a API DAO para mapear tabelas para classes de entidades e navegar pelos relacionamentos. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “DAO do Exposed: classes de entidades e relacionamentos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Configuração do Exposed: conexão com banco de dados e DSL de transações
Definindo tabelas com a DSL Table
CRUD com a DSL de consultas: insert, select, update, delete
DAO do Exposed: classes de entidades e relacionamentos

← Voltar para Kotlin Academy