0Pricing
Kotlin Academy · Lección

Leer anotaciones en tiempo de ejecución

Obtenga instancias de anotaciones de las declaraciones mediante la reflexión de Kotlin.

Leer anotaciones en tiempo de ejecución es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

Requisitos previos

Para leer anotaciones en tiempo de ejecución necesita: (1) que la anotación se haya declarado con @Retention(RUNTIME), (2) la dependencia kotlin-reflect en el classpath y (3) una referencia KClass, KFunction o KProperty al elemento anotado.

Leer anotaciones desde una KClass

Llame a annotations en una KClass para obtener todas las anotaciones de esa clase, o use findAnnotation() para un 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"

Leer anotaciones de propiedades

Acceda a las anotaciones de las propiedades mediante KProperty.annotations o 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"

Leer anotaciones de funciones

Use KFunction.findAnnotation() para leer las anotaciones de las funciones:

@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

Iterar por todas las propiedades en busca de anotaciones

Un patrón habitual consiste en examinar todas las propiedades declaradas de una clase y recopilar las que tienen una anotación 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 }
        }

Leer anotaciones de parámetros

Acceda a las anotaciones de los parámetros del constructor mediante 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 frente a findAnnotation

Use hasAnnotation() para una comprobación booleana; use findAnnotation() cuando necesite los valores de las propiedades de la anotación. Ambas son funciones de extensión de kotlin.reflect.full.

Recorrer la jerarquía de clases

Las anotaciones de las superclases o interfaces NO se heredan automáticamente en la reflexión de Kotlin. Debe recorrer KClass.superclasses o usar KClass.allSuperclasses si necesita anotaciones heredadas.

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

Rendimiento

Las llamadas de reflexión son lentas. Si examina anotaciones durante el inicio del framework, almacene los resultados en caché en un mapa indexado por KClass. Nunca lea anotaciones en rutas críticas por solicitud o por fotograma.

destinos de uso y campos de JVM

En las anotaciones de propiedades con el destino @field:, la anotación se encuentra en el campo de respaldo de JVM. Acceda a ella mediante la reflexión de Java (KProperty.javaField?.annotations) en lugar de la lista annotations de Kotlin, que solo abarca el sitio de declaración de Kotlin.

Ejemplo práctico: mapeador ORM sencillo

Un pequeño mapeador ORM lee las anotaciones @Column para crear una lista de columnas SQL:

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

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

Comprobación rápida

¿Cómo se lee desde una KClass una anotación específica del tipo MyAnn?

Resumen: leer anotaciones en tiempo de ejecución

Conclusiones clave:

  • La anotación debe tener @Retention(RUNTIME)
  • Use findAnnotation() para obtener el valor de una anotación y hasAnnotation() para una comprobación booleana
  • Funciona con KClass, KFunction, KProperty y KParameter
  • Almacene en caché los resultados del análisis durante el inicio para evitar costes por solicitud
  • Para las anotaciones @field:, use KProperty.javaField

Preguntas frecuentes

¿La lección «Leer anotaciones en tiempo de ejecución» es gratis?

Sí — el texto completo de «Leer anotaciones en tiempo de ejecución» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Leer anotaciones en tiempo de ejecución»?

Obtenga instancias de anotaciones de las declaraciones mediante la reflexión de Kotlin. Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Leer anotaciones en tiempo de ejecución»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Reflexión de Kotlin: KClass, KFunction y KProperty
  2. Crear y aplicar anotaciones personalizadas
  3. Leer anotaciones en tiempo de ejecución
  4. Validación y mapeo basados en reflexión
← Volver a Kotlin Academy