CKTIS / Java
Java-annotaties: doelen, bewaarbeleid, herhaling en reflectie
In Java SE 21 bepaalt de declaratie van een annotatie welke gegevens ze bevat, waar ze mag staan en of ze tijdens uitvoering zichtbaar is. Leer metadata met reflectie lezen, overerving herkennen en compilerwaarschuwingen gericht onderdrukken.
Versie: Java SE 21
Syntax
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.FIELD, ElementType.CONSTRUCTOR})
@interface Marker {}
@Target({ElementType.FIELD, ElementType.METHOD})
@interface MemberMarker {}
@Inherited
@Repeatable(Tags.class)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Tag { String value(); }
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Tags { Tag[] value(); }
Consumer<? super Integer> subscriber = new Consumer<Number>() {
@Override public void accept(Number value) { System.out.println(value); }
};
Class<?> type = String.class;
Object payload = List.of("ok");
@SuppressWarnings("unchecked")
List<String> names = (List<String>) payload;@interface declareert een annotatie-interface. String value(); definieert een element; @Tag("core") is kort voor @Tag(value = "core"). De meta-annotatie Target uit java.lang.annotation bepaalt waar de annotatie mag staan. @Target(ElementType.TYPE/FIELD/CONSTRUCTOR) is beschrijvende notatie, geen Java-syntaxis: schrijf @Target({ElementType.TYPE, ElementType.FIELD, ElementType.CONSTRUCTOR}). ElementType.TYPE geldt voor declaraties van klassen en interfaces, niet voor het gebruik van een type (TYPE_USE). ElementType.FIELD/METHOD duidt twee constanten aan: ElementType.FIELD voor velden en ElementType.METHOD voor methoden. Constructors hebben een eigen doel.
Retention bepaalt hoe lang de annotatie wordt bewaard: SOURCE komt niet in het klassebestand, de standaard CLASS wordt wel opgeslagen maar is tijdens uitvoering niet beschikbaar via reflectie, en @Retention(RetentionPolicy.RUNTIME) maakt de annotaties in het voorbeeld via reflectie toegankelijk. Declaratieannotaties op lokale variabelen en lambdaparameters zijn uitzonderingen: ze worden niet in het klassebestand opgeslagen. Een klasseliteral zoals Base.class levert een Class<Base>-object; Class<?> accepteert het zonder het specifieke typeargument prijs te geven. ConfigKey, Init, Component en Inject zijn zelf gedefinieerde metadata: zonder code die ze interpreteert, configureren ze niets, roepen ze niets aan en injecteren ze niets.
@Repeatable(Tags.class) maakt meerdere @Tag-annotaties op dezelfde plek mogelijk. De compiler verpakt herhalingen in een container met Tag[] value(); eventuele andere elementen moeten standaardwaarden hebben. De container moet minstens even lang bewaard blijven en compatibele doelen hebben; in het voorbeeld zijn de doelen identiek. Heeft Tag @Inherited, dan moet de container die ook hebben. getAnnotationsByType(Tag.class) pakt de container uit en zoekt dankzij Inherited in superklassen als de klasse geen eigen tags heeft. De methode voegt geen tags van verschillende niveaus samen, doorzoekt geen interfaces en erft geen methode- of veldannotaties. getDeclaredAnnotationsByType pakt de container ook uit, maar doorzoekt geen superklassen; getAnnotation pakt de container niet uit.
new Consumer<Number>() { ... } declareert en instantieert een anonieme klasse. Met @Override kan de compiler controleren of accept(Number) de interfacemethode implementeert en er niet per ongeluk een overload van maakt. Java 21 staat ook signatures toe die voor overriding equivalent zijn aan die van publieke Object-methoden, en expliciete accessormethoden voor recordcomponenten.
Consumer<? super Integer> accepteert een consumer voor Integer of een supertype ervan, zoals Number of Object, en je kunt die een Integer doorgeven. Bij de onbegrensde wildcard ?, zoals in Consumer<?>, is het typeargument onbekend; je kunt dan geen Integer anders dan null doorgeven. @SuppressWarnings("unchecked") onderdrukt de compilerwaarschuwing, maar controleert de elementtypen van de lijst niet en voorkomt geen ClassCastException. Vermijd onnodige casts; is een cast gerechtvaardigd, onderdruk de waarschuwing dan op de kleinste declaratie waar dat werkt.
Voorbeelden
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.List;
import java.util.function.Consumer;
public class Demo {
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface ConfigKey { String value(); }
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Init {}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Component {}
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.CONSTRUCTOR})
@interface Inject {}
@Inherited
@Repeatable(Tags.class)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Tag { String value(); }
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Tags { Tag[] value(); }
@Component
@Tag("core")
@Tag("fast")
static class Base {
@ConfigKey("port") final int port = 8080;
boolean started;
@Inject Base() {}
@Init void start() { started = true; }
}
static class Child extends Base {}
static void publish(Consumer<? super Integer> subscriber) {
subscriber.accept(21);
}
public static void main(String[] args) throws ReflectiveOperationException {
Class<?> type = Base.class;
Base service = new Base();
var field = type.getDeclaredField("port");
System.out.println("Config: " + field.getAnnotation(ConfigKey.class).value());
boolean before = service.started;
var method = type.getDeclaredMethod("start");
if (method.isAnnotationPresent(Init.class)) {
method.invoke(service);
}
System.out.println("Started: " + before + " -> " + service.started);
System.out.println("Component/Inject: " + type.isAnnotationPresent(Component.class)
+ "/" + type.getDeclaredConstructor().isAnnotationPresent(Inject.class));
Tag[] tags = Child.class.getAnnotationsByType(Tag.class);
int declared = Child.class.getDeclaredAnnotationsByType(Tag.class).length;
System.out.println("Tags: " + tags[0].value() + ", " + tags[1].value()
+ "; declared: " + declared);
publish(new Consumer<Number>() {
@Override public void accept(Number value) {
System.out.println("Subscriber: " + value);
}
});
Object payload = List.of("ok"); // This list is known here to contain only strings.
@SuppressWarnings("unchecked")
List<String> names = (List<String>) payload;
System.out.println("Cast: " + names.get(0));
}
}Resultaat
Config: port Started: false -> true Component/Inject: true/true Tags: core, fast; declared: 0 Subscriber: 21 Cast: ok
`started` verandert pas bij de expliciete aanroep van `method.invoke(service)`. `Child` leest twee tags van `Base` en declareert er zelf geen. De cast is hier gerechtvaardigd door de bekende herkomst van de lijst uit `List.of("ok")`, niet door `@SuppressWarnings`.
Gerelateerde lessen
- Java · Les 44 · Gevorderd · Versie: 2
- Java · Les 54 · Gevorderd · Versie: 2
- Java · Les 58 · Gevorderd · Versie: 2
- Java · Les 59 · Gevorderd · Versie: 2
Bronnen
- Java SE 21 Language Specification §9.6 — Annotation Interfaces and Predefined Annotation Interfaces
- Java SE 21 Language Specification §9.7.5 — Multiple Annotations of the Same Interface
- Java SE 21 API — ElementType
- Java SE 21 API — RetentionPolicy
- Java SE 21 API — AnnotatedElement
- Java SE 21 API — SuppressWarnings
- Java SE 21 Language Specification §4.5.1 — Type Arguments of Parameterized Types
- Java SE 21 Language Specification §15.8.2 — Class Literals
- Java SE 21 Language Specification §15.9.5 — Anonymous Class Declarations