Procesamiento de anotaciones en tiempo de ejecución
Lea anotaciones en tiempo de ejecución mediante Reflection para implementar lógica de validación, enrutamiento o inyección.
Procesamiento de anotaciones en tiempo de ejecución es una lección gratuita de Java 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 Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.
Leer anotaciones a nivel de clase
Recupere las anotaciones de una clase mediante Class.getAnnotation() (una sola) o getAnnotations() (todas). Devuelve null si la anotación no está presente.
@Service
@RequestMapping("/api")
public class UserController {}
RequestMapping rm = UserController.class.getAnnotation(RequestMapping.class);
if (rm != null) System.out.println(Arrays.toString(rm.value())); // ["/api"]Leer anotaciones de métodos
Obtenga las anotaciones de un método mediante method.getAnnotation(). Recorra getDeclaredMethods() para examinar todos los métodos de una clase.
for (Method m : UserController.class.getDeclaredMethods()) {
GetMapping gm = m.getAnnotation(GetMapping.class);
if (gm != null) System.out.println(m.getName() + " -> " + Arrays.toString(gm.value()));
}Leer anotaciones de campos
Las anotaciones de campos se utilizan en frameworks de validación y ORM. Recorra getDeclaredFields() y compruebe cada anotación relevante.
for (Field f : User.class.getDeclaredFields()) {
Column col = f.getAnnotation(Column.class);
if (col != null) System.out.println(f.getName() + " -> column: " + col.name());
}Leer anotaciones de parámetros
Las anotaciones de parámetros están disponibles mediante method.getParameterAnnotations(): un arreglo bidimensional (una fila por parámetro y una entrada por anotación).
Method m = UserController.class.getDeclaredMethod("create", UserDto.class);
Annotation[][] pa = m.getParameterAnnotations();
for (Annotation a : pa[0]) System.out.println(a.annotationType().getSimpleName()); // e.g. ValidisAnnotationPresent
Utilice isAnnotationPresent(AnnotationType.class) como comprobación rápida y segura frente a null antes de leer el valor de la anotación.
if (m.isAnnotationPresent(Transactional.class)) {
beginTransaction();
m.invoke(target, args);
commitTransaction();
}Crear un contenedor sencillo de inyección de dependencias
Examine un paquete en busca de clases anotadas con @Component, instáncielas mediante reflexión y almacénelas en un mapa: un contenedor Spring simplificado.
Map<Class<?>, Object> beans = new HashMap<>();
for (Class<?> cls : scanPackage("com.example")) {
if (cls.isAnnotationPresent(Component.class)) {
beans.put(cls, cls.getDeclaredConstructor().newInstance());
}
}Inyectar campos anotados con @Inject
Después de construir los beans, examine los campos anotados con @Inject y asígneles valores mediante reflexión, imitando la inyección de campos.
for (Object bean : beans.values()) {
for (Field f : bean.getClass().getDeclaredFields()) {
if (f.isAnnotationPresent(Inject.class)) {
f.setAccessible(true);
f.set(bean, beans.get(f.getType()));
}
}
}Validación en tiempo de ejecución con valores de anotaciones
Lea los valores de las anotaciones de restricciones (como @Range(min=1, max=100)) y valide el valor del campo comparándolo con esas restricciones en tiempo de ejecución.
for (Field f : dto.getClass().getDeclaredFields()) {
Range range = f.getAnnotation(Range.class);
if (range != null) {
f.setAccessible(true);
int val = (int) f.get(dto);
if (val < range.min() || val > range.max())
throw new ValidationException(f.getName() + " out of range");
}
}Leer anotaciones repetibles
Para las anotaciones @Repeatable, utilice getAnnotationsByType() para recuperar de forma transparente todas las instancias de la anotación contenedora.
Tag[] tags = MyClass.class.getAnnotationsByType(Tag.class);
for (Tag t : tags) System.out.println(t.value());Examinar un paquete con bibliotecas de ClassPath
La reflexión estándar de Java no puede enumerar todas las clases de un paquete. Utilice bibliotecas como Reflections, ClassGraph o ClassPathScanningCandidateComponentProvider de Spring para examinar las entradas del classpath.
Reflections reflections = new Reflections("com.example.service");
Set<Class<?>> services = reflections.getTypesAnnotatedWith(Service.class);
services.forEach(System.out::println);Procesamiento de anotaciones en tiempo de ejecución: resumen
El procesamiento de anotaciones en tiempo de ejecución permite la inyección de dependencias, la validación, el enrutamiento y el ORM. Es una tarea de inicialización: procese las anotaciones una vez al iniciar la aplicación, almacene en caché los resultados y evite la reflexión en las rutas que se ejecutan por cada solicitud.
Comprobación rápida
¿Qué método recupera todas las instancias de una anotación @Repeatable?
Recapitulación
Utilice getAnnotation/isAnnotationPresent para anotaciones individuales. Examine métodos y campos con getDeclared*. Utilice getAnnotationsByType para las anotaciones repetibles. Procese las anotaciones al iniciar la aplicación y almacene los resultados en caché.
Preguntas frecuentes
¿La lección «Procesamiento de anotaciones en tiempo de ejecución» es gratis?
Sí — el texto completo de «Procesamiento de 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 Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Procesamiento de anotaciones en tiempo de ejecución»?
Lea anotaciones en tiempo de ejecución mediante Reflection para implementar lógica de validación, enrutamiento o inyección. Practicas Java 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 Java Academy?
No se requiere experiencia previa. Java 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 «Procesamiento de 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 Java Academy?
Sí. Cada lección de Java 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
- Definición de anotaciones: elementos y valores predeterminados
- Políticas de retención y tipos de destino
- Procesamiento de anotaciones en tiempo de ejecución
- Procesadores de anotaciones en tiempo de compilación