Kotlin Academy · Lección

Reflection práctica

Lea anotaciones dinámicamente

Reflection práctica es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 4 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.

Las anotaciones se encuentran con la reflexión

Una anotación con retención RUNTIME puede descubrirse en tiempo de ejecución mediante reflexión. Esta combinación impulsa serializadores, validadores y la inyección de dependencias.

En esta lección leeremos dinámicamente nuestras propias anotaciones.

Leer una anotación de clase

Cada KClass expone una lista de annotations. Podemos recorrerla para encontrar una anotación concreta por 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)
}

Ayudante findAnnotation

La extensión findAnnotation es más clara que filtrar manualmente. Devuelve la anotación o 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)
}

Anotaciones en propiedades

Las propiedades tienen sus propias anotaciones. Recorra memberProperties e inspeccione las annotations de cada propiedad.

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)
    }
}

Crear un mini serializador

Combine la lectura de propiedades con las anotaciones para generar una salida. Aquí asignamos cada propiedad a una cadena key=value usando el nombre de columna cuando está 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(", "))
}

Omitir con un marcador

Una anotación de marcador puede indicar qué propiedades deben ignorarse. Comprobamos su presencia con 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) }
}

Leer los argumentos de una anotación

Una vez que tiene la instancia de la anotación, sus parámetros son propiedades normales. Léalos como cualquier 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)
}

Anotaciones en funciones

Las funciones también pueden anotarse e inspeccionarse. Los frameworks usan esto para encontrar controladores, como los ejecutores de pruebas localizan métodos de prueba.

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) }
    }
}

Controlar el comportamiento

Lea la anotación de ruta y distribuya realmente una llamada. Esta es la esencia del funcionamiento de los frameworks de enrutamiento.

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 en el mundo real

La reflexión basada en anotaciones sustenta muchas bibliotecas:

Serialización JSON que asigna campos a claves
Validación que impone restricciones
Enrutamiento que hace coincidir rutas con controladores
Inyección de dependencias que conecta componentes

Mantener el uso acotado

Es mejor limitar la reflexión al código de inicialización y de los frameworks que se ejecuta una vez o con poca frecuencia. Almacene en caché los resultados cuando pueda. Para rutas críticas por solicitud, prefiera el procesamiento en tiempo de compilación.

Comprobación rápida

Compruebe cuánto ha entendido sobre el uso práctico de la reflexión.

Repaso

Ha combinado anotaciones y reflexión para:

Encontrar anotaciones de clases, propiedades y funciones
Leer argumentos de anotaciones en tiempo de ejecución
Crear un mini serializador y un distribuidor de rutas
Omitir campos con anotaciones de marcador

Así se crean los frameworks reales.

Preguntas frecuentes

¿La lección «Reflection práctica» es gratis?

Sí — el texto completo de «Reflection práctica» 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 «Reflection práctica»?

Lea anotaciones dinámicamente 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 4 de 4.

¿Cuánto tiempo toma la lección «Reflection práctica»?

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

← Volver a Kotlin Academy