Java Academy · Leçon

Politiques de rétention et types de cibles

Choisissez la rétention SOURCE, CLASS ou RUNTIME et limitez les éléments cibles avec @Target.

Politiques de rétention et types de cibles est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Les trois politiques de conservation

SOURCE : supprimée par le compilateur (utile uniquement pour APT). CLASS : écrite dans les fichiers .class, mais indisponible à l'exécution. RUNTIME : disponible par réflexion. La plupart des annotations de framework utilisent RUNTIME.

Conservation SOURCE : uniquement lors de la compilation

Les annotations SOURCE sont traitées par les processeurs d'annotations, puis supprimées. @Override et @SuppressWarnings sont SOURCE : elles informent le compilateur, mais ne figurent pas dans le fichier .class.

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

Conservation CLASS : analyse du bytecode

Les annotations CLASS sont incluses dans les fichiers .class pour les outils d'analyse du bytecode (PMD, FindBugs, ASM), mais ne sont PAS lisibles à l'exécution par réflexion.

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

Conservation RUNTIME : traitement par réflexion

Les annotations RUNTIME sont conservées jusqu'à l'exécution et peuvent être lues avec getAnnotation(). Spring, JUnit, Jackson et Hibernate utilisent la conservation 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 : limiter les points d'application

@Target utilise les constantes de ElementType pour limiter les endroits où l'annotation peut apparaître. Une erreur est générée lors de la compilation si elle est appliquée à un élément non autorisé.

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

Toutes les valeurs de ElementType

Liste complète : TYPE (classe/interface/enum), FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE, PACKAGE, TYPE_PARAMETER (paramètre de type générique), TYPE_USE (toute utilisation d'un type).

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

TYPE ou TYPE_USE

TYPE cible les déclarations de classe/interface/enum. TYPE_USE (Java 8 ou version ultérieure) cible toute utilisation d'un type, notamment les types génériques, les conversions et les clauses extends, ce qui permet d'annoter la sécurité contre les valeurs null au niveau des types.

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

Combiner Target et Retention

Les annotations de framework les plus utiles combinent la conservation RUNTIME avec des cibles précises. Exemple : une annotation de validation appliquée uniquement aux champs.

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

Hériter des annotations avec @Inherited

@Inherited est une méta-annotation qui entraîne l'héritage des annotations appliquées au niveau d'une classe par les sous-classes. Elle n'a aucun effet sur les annotations de méthodes ou de champs.

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

@Documented : inclure l'annotation dans Javadoc

Appliquez @Documented pour que l'annotation apparaisse dans le Javadoc généré pour les éléments annotés. Sans cette annotation, les annotations sont invisibles dans la documentation de l'API.

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

Lire les informations de conservation à l'exécution

Vous pouvez examiner la conservation du type d'annotation lui-même en utilisant getAnnotation(Retention.class) sur l'objet représentant la classe de l'annotation.

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

Vérification rapide

Quelle valeur de ElementType couvre les déclarations de classe, d'interface et d'enum ?

Récapitulatif

Utilisez SOURCE pour les outils de compilation, CLASS pour l'analyse du bytecode et RUNTIME pour les frameworks utilisant la réflexion. Limitez l'utilisation avec @Target afin d'éviter les usages incorrects. Ajoutez @Documented aux annotations d'API et @Inherited aux annotations liées à une hiérarchie de classes.

Questions Fréquemment Posées

La leçon « Politiques de rétention et types de cibles » est-elle gratuite ?

Oui — le texte complet de « Politiques de rétention et types de cibles » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Politiques de rétention et types de cibles » ?

Choisissez la rétention SOURCE, CLASS ou RUNTIME et limitez les éléments cibles avec @Target. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Politiques de rétention et types de cibles » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Définir des annotations : éléments et valeurs par défaut
Politiques de rétention et types de cibles
Traitement des annotations à l’exécution
Processeurs d’annotations à la compilation

← Retour à Java Academy