Kotlin Academy · Aula

Reflexão na Prática

Leia anotações dinamicamente

Aula 4 de 413 etapas

Reflexão na Prática é 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.

Anotações encontram a reflexão

Uma anotação com retenção RUNTIME pode ser descoberta em tempo de execução por meio da reflexão. Essa combinação dá suporte a serializadores, validadores e injeção de dependências.

Nesta lição, leremos nossas próprias anotações dinamicamente.

Lendo uma anotação de classe

Toda KClass expõe uma lista de annotations. Podemos examiná-la para encontrar uma anotação específica pelo tipo.

@Retention(AnnotationRetention.RUNTIME)
annotation class Entity(val table: String)

@Entity("users")
class User

fun main() {
    val ann = User::class.annotations
        .filterIsInstance<Entity>()
        .first()
    println(ann.table)
}

Auxiliar findAnnotation

A extensão findAnnotation é mais simples que filtrar manualmente. Ela retorna a anotação ou null.

import kotlin.reflect.full.findAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Entity(val table: String)

@Entity("orders")
class Order

fun main() {
    val ann = Order::class.findAnnotation<Entity>()
    println(ann?.table)
}

Anotações em propriedades

As propriedades têm suas próprias anotações. Itere por memberProperties e inspecione as annotations de cada propriedade.

import kotlin.reflect.full.memberProperties
import kotlin.reflect.full.findAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Column(val name: String)

class Product(@Column("product_id") val id: Int, val title: String)

fun main() {
    Product::class.memberProperties.forEach { prop ->
        val col = prop.findAnnotation<Column>()
        if (col != null) println(prop.name + " -> " + col.name)
    }
}

Criando um mini-serializador

Combine a leitura de propriedades com anotações para gerar uma saída. Aqui, mapeamos cada propriedade para uma cadeia de caracteres no formato chave=valor, usando o nome da coluna quando ele estiver presente.

import kotlin.reflect.full.memberProperties
import kotlin.reflect.full.findAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Column(val name: String)

class Item(@Column("item_id") val id: Int, val name: String)

fun main() {
    val item = Item(7, "Book")
    val parts = Item::class.memberProperties.map { p ->
        val key = p.findAnnotation<Column>()?.name ?: p.name
        key + "=" + p.getter.call(item)
    }
    println(parts.joinToString(", "))
}

Ignorando com um marcador

Uma anotação de marcador pode sinalizar propriedades que devem ser ignoradas. Verificamos sua presença com hasAnnotation.

import kotlin.reflect.full.memberProperties
import kotlin.reflect.full.hasAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Transient2

class Account(val id: Int, @Transient2 val secret: String)

fun main() {
    Account::class.memberProperties
        .filterNot { it.hasAnnotation<Transient2>() }
        .forEach { println(it.name) }
}

Lendo argumentos de anotações

Depois que você obtém a instância da anotação, seus parâmetros são propriedades comuns. Leia-os como faria com qualquer campo.

import kotlin.reflect.full.findAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Validated(val min: Int, val max: Int)

@Validated(min = 1, max = 100)
class Quantity

fun main() {
    val v = Quantity::class.findAnnotation<Validated>()!!
    println("range " + v.min + ".." + v.max)
}

Anotações em funções

As funções também podem receber anotações e ser inspecionadas. As estruturas usam isso para encontrar manipuladores, assim como os executores de testes localizam métodos de teste.

import kotlin.reflect.full.memberFunctions
import kotlin.reflect.full.findAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Route(val path: String)

class Api {
    @Route("/home")
    fun home() = "home page"
}

fun main() {
    Api::class.memberFunctions.forEach { f ->
        f.findAnnotation<Route>()?.let { println(f.name + " @ " + it.path) }
    }
}

Executando o comportamento

Leia a anotação de rota e realmente encaminhe uma chamada. Essa é a essência do funcionamento das estruturas de roteamento.

import kotlin.reflect.full.memberFunctions
import kotlin.reflect.full.findAnnotation

@Retention(AnnotationRetention.RUNTIME)
annotation class Route(val path: String)

class Api {
    @Route("/ping")
    fun ping() = "pong"
}

fun main() {
    val api = Api()
    val target = "/ping"
    Api::class.memberFunctions.forEach { f ->
        if (f.findAnnotation<Route>()?.path == target) {
            println(f.call(api))
        }
    }
}

Usos no mundo real

A reflexão orientada por anotações é a base de muitas bibliotecas:

Mapeamento de serialização JSON de campos para chaves
Validação que impõe restrições
Roteamento que associa caminhos a manipuladores
Injeção de dependências que conecta componentes

Mantenha o uso direcionado

É melhor limitar a reflexão ao código de configuração e de estruturas executado uma vez ou raramente. Armazene os resultados em cache quando possível. Para caminhos críticos executados a cada solicitação, prefira o processamento em tempo de compilação.

Verificação rápida

Teste sua compreensão sobre o uso prático da reflexão.

Responda na aula interativa

Recapitulação

Você combinou anotações e reflexão para:

Encontrar anotações de classes, propriedades e funções
Ler argumentos de anotações em tempo de execução
Criar um mini-serializador e um distribuidor de rotas
Ignorar campos com anotações de marcador

É assim que as estruturas reais são criadas.

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 “Reflexão na Prática” é grátis?

Sim — o texto completo de “Reflexão na Prática” é 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 “Reflexão na Prática”?

Leia anotações dinamicamente 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 “Reflexão na Prática”?

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

← Voltar para Kotlin Academy