0Pricing
Java Academy · Lección

Políticas de retención y tipos de destino

Elija la retención SOURCE, CLASS o RUNTIME y restrinja los elementos de destino con @Target.

Políticas de retención y tipos de destino es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 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.

Las tres políticas de retención

SOURCE: el compilador la descarta (solo resulta útil para APT). CLASS: se escribe en los archivos .class, pero no está disponible en tiempo de ejecución. RUNTIME: está disponible mediante reflexión. La mayoría de las anotaciones de frameworks utiliza RUNTIME.

Retención SOURCE: solo en tiempo de compilación

Las anotaciones SOURCE son procesadas por los procesadores de anotaciones y después se descartan. @Override y @SuppressWarnings son SOURCE: informan al compilador, pero no están en el archivo .class.

@Retention(RetentionPolicy.SOURCE)
public @interface GenerateBuilder {}
// APT generates a Builder class when it sees @GenerateBuilder
// The annotation itself disappears from the compiled output

Retención CLASS: análisis del bytecode

Las anotaciones CLASS se incluyen en los archivos .class para las herramientas de análisis de bytecode (PMD, FindBugs, ASM), pero NO se pueden leer en tiempo de ejecución mediante reflexión.

@Retention(RetentionPolicy.CLASS)
public @interface ThreadSafe {}
// Visible in bytecode, invisible to Class.getAnnotation() at runtime

Retención RUNTIME: procesamiento mediante reflexión

Las anotaciones RUNTIME se conservan hasta el tiempo de ejecución y se pueden leer con getAnnotation(). Spring, JUnit, Jackson y Hibernate utilizan la retención RUNTIME.

@Retention(RetentionPolicy.RUNTIME)
public @interface Route {
    String path();
    String method() default "GET";
}
// At runtime:
Route r = handler.getClass().getMethod("handle").getAnnotation(Route.class);
System.out.println(r.path()); // e.g. "/users"

@Target: restringir los puntos de aplicación

@Target utiliza constantes de ElementType para restringir dónde puede aparecer la anotación. Si se aplica a un elemento no permitido, se produce un error en tiempo de compilación.

import static java.lang.annotation.ElementType.*;
@Target({METHOD, CONSTRUCTOR})
@Retention(RetentionPolicy.RUNTIME)
public @interface Measured {}

Todos los valores de ElementType

Lista completa: TYPE (clase/interfaz/enum), FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE, PACKAGE, TYPE_PARAMETER (parámetro de tipo genérico), TYPE_USE (cualquier uso de un tipo).

// TYPE_USE: annotate any type reference
@NotNull String name;
List<@NonNull String> items;
public @Valid User createUser(@NotNull String name) { ... }

TYPE frente a TYPE_USE

TYPE se aplica a declaraciones de clases, interfaces y enums. TYPE_USE (Java 8 o posterior) se aplica a cualquier uso de un tipo, incluidos genéricos, conversiones y cláusulas extends, lo que permite usar anotaciones de seguridad frente a valores null a nivel de tipo.

@Target(ElementType.TYPE_USE)
@interface NonNull {}
// Can be applied to:
List<@NonNull String> list;
@NonNull String result = (@NonNull String) obj;

Combinar Target y Retention

Las anotaciones de frameworks más útiles combinan la retención RUNTIME con destinos específicos. Por ejemplo, una anotación de validación que solo se aplique a campos.

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Range {
    int min() default 0;
    int max() default Integer.MAX_VALUE;
}

Heredar anotaciones con @Inherited

@Inherited es una metaanotación que hace que las subclases hereden las anotaciones a nivel de clase. No tiene ningún efecto sobre las anotaciones de métodos o campos.

@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Framework {}
@Framework class Base {}
class Child extends Base {} // @Framework visible on Child too

@Documented: inclusión en Javadoc

Aplique @Documented para que la anotación aparezca en el Javadoc generado para los elementos anotados. Sin ella, las anotaciones son invisibles en la documentación de la API.

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Auditable {
    String description() default "";
}

Leer información de retención en tiempo de ejecución

Puede inspeccionar la retención del propio tipo de anotación mediante getAnnotation(Retention.class) en el objeto de clase de la anotación.

Retention r = Retry.class.getAnnotation(Retention.class);
System.out.println(r.value()); // RUNTIME, CLASS, or SOURCE

Comprobación rápida

¿Qué ElementType incluye las declaraciones de clases, interfaces y enums?

Recapitulación

Utilice SOURCE para herramientas en tiempo de compilación, CLASS para el análisis de bytecode y RUNTIME para frameworks que usan reflexión. Restrinja el uso con @Target para evitar usos incorrectos. Añada @Documented para las anotaciones de API y @Inherited para las anotaciones de jerarquías de clases.

Preguntas frecuentes

¿La lección «Políticas de retención y tipos de destino» es gratis?

Sí — el texto completo de «Políticas de retención y tipos de destino» 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 «Políticas de retención y tipos de destino»?

Elija la retención SOURCE, CLASS o RUNTIME y restrinja los elementos de destino con @Target. 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 2 de 4.

¿Cuánto tiempo toma la lección «Políticas de retención y tipos de destino»?

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

  1. Definición de anotaciones: elementos y valores predeterminados
  2. Políticas de retención y tipos de destino
  3. Procesamiento de anotaciones en tiempo de ejecución
  4. Procesadores de anotaciones en tiempo de compilación
← Volver a Java Academy