0Pricing
Java Academy · Lezione

Politiche di conservazione e tipi di target

Scelga la conservazione SOURCE, CLASS o RUNTIME e limiti gli elementi target con @Target.

Politiche di conservazione e tipi di target è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Le tre politiche di conservazione

SOURCE: viene scartata dal compilatore (utile solo per APT). CLASS: viene scritta nei file .class, ma non è disponibile in fase di esecuzione. RUNTIME: è disponibile tramite reflection. La maggior parte delle annotazioni dei framework utilizza RUNTIME.

Conservazione SOURCE: solo in fase di compilazione

Le annotazioni SOURCE vengono elaborate dai processori di annotazioni e poi scartate. @Override e @SuppressWarnings sono SOURCE: informano il compilatore, ma non si trovano nel file .class.

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

Conservazione CLASS: analisi del bytecode

Le annotazioni CLASS sono incluse nei file .class per gli strumenti di analisi del bytecode (PMD, FindBugs, ASM), ma NON sono leggibili in fase di esecuzione tramite reflection.

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

Conservazione RUNTIME: elaborazione tramite reflection

Le annotazioni RUNTIME rimangono disponibili in fase di esecuzione e possono essere lette con getAnnotation(). Spring, JUnit, Jackson e Hibernate utilizzano la conservazione 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: limitare i punti di applicazione

@Target utilizza le costanti di ElementType per limitare i punti in cui può comparire l'annotazione. Se viene applicata a un elemento non consentito, si verifica un errore in fase di compilazione.

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

Tutti i valori di ElementType

Elenco completo: TYPE (dichiarazione di classe/interfaccia/enum), FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE, PACKAGE, TYPE_PARAMETER (parametro di tipo generico), TYPE_USE (qualsiasi utilizzo di un tipo).

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

TYPE e TYPE_USE a confronto

TYPE si applica alle dichiarazioni di classi/interfacce/enum. TYPE_USE (da Java 8 in poi) si applica a qualsiasi utilizzo di un tipo, inclusi generics, cast e clausole extends, consentendo annotazioni di null-safety a livello di tipo.

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

Combinare Target e Retention

Le annotazioni dei framework più utili combinano la conservazione RUNTIME con destinazioni specifiche. Ad esempio, un'annotazione di convalida applicabile solo ai campi.

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

Ereditare le annotazioni con @Inherited

@Inherited è una meta-annotazione che fa ereditare alle sottoclassi le annotazioni a livello di classe. Non ha effetto sulle annotazioni di metodi o campi.

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

@Documented: inclusione nella documentazione Javadoc

Applichi @Documented affinché l'annotazione compaia nella documentazione Javadoc generata per gli elementi annotati. Senza di essa, le annotazioni non sono visibili nella documentazione dell'API.

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

Leggere le informazioni sulla conservazione in fase di esecuzione

È possibile esaminare la conservazione del tipo di annotazione stesso utilizzando getAnnotation(Retention.class) sull'oggetto della classe dell'annotazione.

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

Verifica rapida

Quale ElementType comprende le dichiarazioni di classi, interfacce ed enum?

Riepilogo

Utilizzi SOURCE per gli strumenti in fase di compilazione, CLASS per l'analisi del bytecode e RUNTIME per i framework che usano la reflection. Limiti l'utilizzo con @Target per prevenire usi impropri. Aggiunga @Documented alle annotazioni dell'API e @Inherited alle annotazioni della gerarchia delle classi.

Domande Frequenti

La lezione «Politiche di conservazione e tipi di target» è gratuita?

Sì — il testo completo di «Politiche di conservazione e tipi di target» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Politiche di conservazione e tipi di target»?

Scelga la conservazione SOURCE, CLASS o RUNTIME e limiti gli elementi target con @Target. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Politiche di conservazione e tipi di target»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Definire annotazioni: elementi e valori predefiniti
  2. Politiche di conservazione e tipi di target
  3. Elaborazione delle annotazioni a runtime
  4. Annotation processor a compile time
← Torna a Java Academy