0Pricing
Java Academy · Lektion

Retention-Richtlinien und Zieltypen

Wählen Sie die Aufbewahrung SOURCE, CLASS oder RUNTIME und beschränken Sie Zielelemente mit @Target.

Retention-Richtlinien und Zieltypen ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Die drei Aufbewahrungsrichtlinien

SOURCE: wird vom Compiler verworfen (nur für APT nützlich). CLASS: wird in .class-Dateien geschrieben, ist aber zur Laufzeit nicht verfügbar. RUNTIME: ist über Reflection verfügbar. Die meisten Framework-Annotationen verwenden RUNTIME.

SOURCE-Aufbewahrung: Nur zur Kompilierzeit

SOURCE-Annotationen werden von Annotation-Prozessoren verarbeitet und anschließend verworfen. @Override und @SuppressWarnings sind SOURCE: Sie informieren den Compiler, befinden sich aber nicht in der .class-Datei.

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

CLASS-Aufbewahrung: Bytecode-Analyse

CLASS-Annotationen werden für Bytecode-Analysetools (PMD, FindBugs, ASM) in .class-Dateien aufgenommen, sind aber zur Laufzeit NICHT über Reflection lesbar.

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

RUNTIME-Aufbewahrung: Verarbeitung per Reflection

RUNTIME-Annotationen bleiben bis zur Laufzeit erhalten und können mit getAnnotation() gelesen werden. Spring, JUnit, Jackson und Hibernate verwenden die RUNTIME-Aufbewahrung.

@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: Anwendungspunkte einschränken

@Target verwendet Konstanten von ElementType, um einzuschränken, wo die Annotation vorkommen darf. Wird sie auf ein nicht zulässiges Element angewendet, tritt ein Fehler zur Kompilierzeit auf.

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

Alle ElementType-Werte

Vollständige Liste: TYPE (Klasse/Interface/Enum), FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE, PACKAGE, TYPE_PARAMETER (generischer Typparameter), TYPE_USE (jede Verwendung eines Typs).

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

TYPE und TYPE_USE

TYPE gilt für Deklarationen von Klassen, Interfaces und Enums. TYPE_USE (seit Java 8) gilt für jede Verwendung eines Typs, einschließlich Generics, Casts und extends-Klauseln, und ermöglicht dadurch Null-Safety-Annotationen auf Typebene.

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

Target und Retention kombinieren

Die meisten nützlichen Framework-Annotationen kombinieren die RUNTIME-Aufbewahrung mit bestimmten Zielen. Ein Beispiel ist eine Validierungsannotation, die nur auf Felder angewendet werden darf.

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

Annotationen mit @Inherited vererben

@Inherited ist eine Metaannotation, durch die Annotationen auf Klassenebene von Unterklassen geerbt werden. Auf Methoden- oder Feldannotation hat sie keine Wirkung.

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

@Documented: Javadoc-Aufnahme

Wenden Sie @Documented an, damit die Annotation im generierten Javadoc für annotierte Elemente erscheint. Ohne diese Annotation sind Annotationen in der API-Dokumentation unsichtbar.

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

Informationen zur Aufbewahrung zur Laufzeit lesen

Sie können die Aufbewahrung eines Annotationstyps selbst mit getAnnotation(Retention.class) am Klassenobjekt der Annotation untersuchen.

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

Kurzer Test

Welches ElementType umfasst Deklarationen von Klassen, Interfaces und Enums?

Zusammenfassung

Verwenden Sie SOURCE für Tools zur Kompilierzeit, CLASS für Bytecode-Analysen und RUNTIME für Frameworks, die Reflection nutzen. Schränken Sie die Verwendung mit @Target ein, um Missbrauch zu verhindern. Ergänzen Sie @Documented für API-Annotationen und @Inherited für Annotationen in Klassenhierarchien.

Häufig gestellte Fragen

Ist die Lektion „Retention-Richtlinien und Zieltypen“ kostenlos?

Ja — der vollständige Text von „Retention-Richtlinien und Zieltypen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Retention-Richtlinien und Zieltypen“?

Wählen Sie die Aufbewahrung SOURCE, CLASS oder RUNTIME und beschränken Sie Zielelemente mit @Target. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Retention-Richtlinien und Zieltypen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Annotationen definieren: Elemente und Standardwerte
  2. Retention-Richtlinien und Zieltypen
  3. Annotationen zur Laufzeit verarbeiten
  4. Annotation-Processor zur Compile-Zeit
← Zurück zu Java Academy