0Pricing
Kotlin Academy · Aula

Lendo anotações em tempo de execução

Recupere instâncias de anotações de declarações usando a reflexão do Kotlin.

Lendo anotações em tempo de execução é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 3 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.

Pré-requisitos

Para ler anotações em tempo de execução, você precisa de: (1) uma anotação declarada com @Retention(RUNTIME), (2) a dependência kotlin-reflect no caminho de classes e (3) uma referência KClass, KFunction ou KProperty ao elemento anotado.

Lendo anotações de uma KClass

Invoque annotations em uma KClass para obter todas as anotações dessa classe ou use findAnnotation() para um tipo específico:

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.CLASS)
annotation class Table(val name: String)

@Table(name = "users")
class UserEntity

val ann = UserEntity::class.findAnnotation<Table>()
println(ann?.name)  // "users"

Lendo anotações de propriedades

Acesse as anotações das propriedades por meio de KProperty.annotations ou findAnnotation():

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

data class User(@Column("user_name") val name: String)

val prop = User::name
val col = prop.findAnnotation<Column>()
println(col?.name)  // "user_name"

Lendo anotações de funções

Use KFunction.findAnnotation() para ler anotações de funções:

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.FUNCTION)
annotation class Transactional

class UserService {
    @Transactional
    fun save(user: User) { /*...*/ }
}

val fn = UserService::save
val isTx = fn.hasAnnotation<Transactional>()
println(isTx)  // true

Iterando por todas as propriedades em busca de anotações

Um padrão comum é examinar todas as propriedades declaradas de uma classe e coletar aquelas anotadas com uma anotação específica:

fun <A : Annotation> KClass<*>.annotatedProperties(
    annotationClass: KClass<A>
): List<Pair<KProperty1<*, *>, A>> =
    declaredMemberProperties
        .mapNotNull { prop ->
            prop.findAnnotation(annotationClass)?.let { ann -> prop to ann }
        }

Lendo anotações de parâmetros

Acesse as anotações dos parâmetros do construtor por meio de KFunction.parameters:

class Repo(
    @param:Validate(minLength = 3) val name: String
)

val ctor = Repo::class.primaryConstructor!!
val param = ctor.parameters.first()
val ann = param.findAnnotation<Validate>()
println(ann?.minLength)  // 3

hasAnnotation versus findAnnotation

Use hasAnnotation() para uma verificação booleana; use findAnnotation() quando precisar dos valores das propriedades da anotação. Ambas são funções de extensão de kotlin.reflect.full.

Percorrendo a hierarquia de classes

As anotações em superclasses ou interfaces NÃO são herdadas automaticamente pela reflexão do Kotlin. Você precisa percorrer KClass.superclasses ou usar KClass.allSuperclasses se precisar de anotações herdadas.

fun KClass<*>.findAnnotationRecursive(ann: KClass<out Annotation>) =
    generateSequence(this) { null } // simplified — real impl walks supers
        .flatMap { it.annotations }
        .firstOrNull { it.annotationClass == ann }

Desempenho

As chamadas de reflexão são lentas. Se você examinar anotações na inicialização da estrutura, armazene os resultados em cache em um mapa indexado por KClass. Nunca leia anotações em caminhos críticos por solicitação ou por quadro.

Alvos do local de uso e campos da JVM

Para anotações em propriedades com o alvo @field:, a anotação fica no campo de armazenamento da JVM. Acesse-a por meio da reflexão do Java (KProperty.javaField?.annotations) em vez da lista annotations do Kotlin, que abrange apenas o local da declaração no Kotlin.

Exemplo prático: mapeador ORM simples

Um pequeno mapeador ORM lê anotações @Column para criar uma lista de colunas SQL:

fun columns(klass: KClass<*>): String =
    klass.declaredMemberProperties
        .mapNotNull { it.findAnnotation<Column>()?.name }
        .joinToString(", ")

println(columns(User::class))  // "user_name, email"

Verificação rápida

Como você lê uma anotação específica do tipo MyAnn de uma KClass?

Recapitulação: lendo anotações em tempo de execução

Principais conclusões:

  • A anotação deve ter @Retention(RUNTIME)
  • Use findAnnotation() para obter o valor de uma anotação e hasAnnotation() para uma verificação booleana
  • Funciona com KClass, KFunction, KProperty e KParameter
  • Armazene os resultados da análise em cache na inicialização para evitar sobrecarga por solicitação
  • Para anotações @field:, use KProperty.javaField

Perguntas Frequentes

A aula “Lendo anotações em tempo de execução” é grátis?

Sim — o texto completo de “Lendo anotações em tempo de execução” é 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 “Lendo anotações em tempo de execução”?

Recupere instâncias de anotações de declarações usando a reflexão do Kotlin. 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 3 de 4.

Quanto tempo leva a aula “Lendo anotações em tempo de execução”?

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. Reflexão no Kotlin: KClass, KFunction, KProperty
  2. Criando e direcionando anotações personalizadas
  3. Lendo anotações em tempo de execução
  4. Validação e mapeamento baseados em reflexão
← Voltar para Kotlin Academy