0Pricing
Kotlin Academy · Aula

Configuração do Exposed: conexão com banco de dados e DSL de transações

Conecte-se a um banco de dados, configure o Exposed e execute código dentro de transações.

Configuração do Exposed: conexão com banco de dados e DSL de transações é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 1 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 é o Exposed?

Exposed é um framework SQL leve da JetBrains para Kotlin. Ele oferece dois níveis: uma DSL de consultas (expressões SQL com segurança de tipos) e uma camada DAO (entidades no estilo Active Record). Ambos são executados dentro de transações explícitas.

Adicionando dependências do Exposed

Adicione o núcleo, a ponte do driver JDBC e o driver do seu banco de dados:

dependencies {
    implementation("org.jetbrains.exposed:exposed-core:0.52.0")
    implementation("org.jetbrains.exposed:exposed-jdbc:0.52.0")
    implementation("org.jetbrains.exposed:exposed-dao:0.52.0")
    implementation("com.h2database:h2:2.2.224") // or postgresql driver
    implementation("com.zaxxer:HikariCP:5.1.0")  // connection pooling
}

Conectando-se ao banco de dados

Chame Database.connect() uma vez na inicialização. Em produção, passe um HikariDataSource; para testes, uma URL JDBC simples é suficiente:

import org.jetbrains.exposed.sql.Database

// Simple (dev/test)
Database.connect(
    url = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1",
    driver = "org.h2.Driver"
)

// Production with HikariCP
Database.connect(HikariDataSource(HikariConfig().apply {
    jdbcUrl = "jdbc:postgresql://localhost/mydb"
    username = "user"
    password = "pass"
    maximumPoolSize = 10
}))

O bloco transaction { }

Todas as operações do Exposed devem ser executadas dentro de um bloco transaction { }. O Exposed confirma a transação em caso de sucesso e a reverte diante de qualquer exceção não tratada:

transaction {
    // all DB operations here
    SchemaUtils.create(Users)
}

Transações compatíveis com corrotinas

Use newSuspendedTransaction { } de exposed-r2dbc ou o exposed-spring-boot-starter para transações compatíveis com corrotinas. No Ktor, envolva as chamadas bloqueantes do Exposed em withContext(Dispatchers.IO) { transaction { ... } }:

suspend fun findUser(id: Long): User? = withContext(Dispatchers.IO) {
    transaction {
        UserEntity.findById(id)?.toUser()
    }
}

SchemaUtils: criando e removendo tabelas

Use SchemaUtils.create(Table1, Table2) para criar tabelas caso elas não existam e SchemaUtils.drop() para removê-las. Chame isso dentro de um bloco transaction { } na inicialização da aplicação:

transaction {
    SchemaUtils.create(Users, Posts, Comments)
}

Configurando uma conexão no Ktor

Inicialize o banco de dados em um módulo Application para que isso seja executado uma vez quando o servidor iniciar:

fun Application.configureDatabase() {
    val dbUrl = environment.config.property("ktor.database.url").getString()
    Database.connect(dbUrl, driver = "org.postgresql.Driver",
        user = "...", password = "...")
    transaction { SchemaUtils.create(Users) }
}

Níveis de isolamento de transações

Passe um nível de isolamento para transaction() quando precisar de garantias de consistência mais fortes ou mais fracas:

transaction(Connection.TRANSACTION_SERIALIZABLE) {
    // serializable isolation
}

Transações aninhadas

Por padrão, chamadas aninhadas de transaction { } entram na transação externa. Para obter uma transação independente, use transaction(db, outerTransactionIsEmpty = false) { } ou um ponto de salvamento.

Registrando SQL

Ative o registro de SQL para ver as consultas geradas durante o desenvolvimento. Defina um StdOutSqlLogger ou um registrador personalizado dentro do bloco de transação:

transaction {
    addLogger(StdOutSqlLogger)
    // ...
}

Boas práticas para pools de conexões

Sempre use HikariCP (ou equivalente) em produção. Defina maximumPoolSize para corresponder à quantidade de threads do servidor e connectionTimeout para falhar rapidamente quando o pool estiver esgotado. Monitore a utilização do pool em produção.

Verificação rápida

O que acontece quando uma exceção não tratada é lançada dentro de um bloco transaction { } no Exposed?

Recapitulação: configuração do Exposed e DSL de transações

Principais pontos:

  • Conecte-se com Database.connect() uma vez na inicialização (use HikariCP em produção)
  • Todas as operações de banco de dados são executadas dentro de transaction { } — a transação é confirmada em caso de sucesso e revertida diante de uma exceção
  • Crie ou remova tabelas com SchemaUtils.create() dentro de uma transação
  • Envolva as chamadas bloqueantes do Exposed em withContext(Dispatchers.IO) nos contextos de corrotina
  • Ative StdOutSqlLogger durante o desenvolvimento para inspecionar o SQL gerado

Perguntas Frequentes

A aula “Configuração do Exposed: conexão com banco de dados e DSL de transações” é grátis?

Sim — o texto completo de “Configuração do Exposed: conexão com banco de dados e DSL de transações” é 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 “Configuração do Exposed: conexão com banco de dados e DSL de transações”?

Conecte-se a um banco de dados, configure o Exposed e execute código dentro de transações. 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 1 de 4.

Quanto tempo leva a aula “Configuração do Exposed: conexão com banco de dados e DSL de transações”?

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

  1. Configuração do Exposed: conexão com banco de dados e DSL de transações
  2. Definindo tabelas com a DSL Table
  3. CRUD com a DSL de consultas: insert, select, update, delete
  4. DAO do Exposed: classes de entidades e relacionamentos
← Voltar para Kotlin Academy