CKTIS / Java
Anotácie v Jave: ciele, uchovávanie, opakovanie a reflexia
Deklarácia anotácie v Java SE 21 určuje jej údaje, povolené miesta použitia a dostupnosť za behu. Nauč sa čítať metadáta pomocou reflexie, odlíšiť deklarované anotácie od zdedených a potláčať upozornenia len tam, kde treba.
Verzia: 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 deklaruje anotačné rozhranie. String value(); definuje prvok a @Tag("core") je skratka zápisu @Tag(value = "core"). Metaanotácia Target z java.lang.annotation určuje povolené miesta použitia. @Target(ElementType.TYPE/FIELD/CONSTRUCTOR) je opisná skratka, nie syntax Javy: použi @Target({ElementType.TYPE, ElementType.FIELD, ElementType.CONSTRUCTOR}). ElementType.TYPE označuje deklarácie tried a rozhraní, nie použitia typu (TYPE_USE). ElementType.FIELD/METHOD označuje dve konštanty: ElementType.FIELD pre polia a ElementType.METHOD pre metódy. Konštruktory majú samostatný cieľ.
Retention určuje dobu uchovávania: SOURCE sa do súboru triedy nezapisuje, predvolené CLASS sa zapíše, ale nie je dostupné reflexiou za behu, a @Retention(RetentionPolicy.RUNTIME) sprístupní anotácie z príkladu reflexiou. Výnimkou sú deklarácie lokálnych premenných a parametrov lambda výrazov: ich deklaračné anotácie sa neukladajú do súboru triedy. Literál triedy Base.class poskytne objekt Class<Base>; Class<?> ho prijme bez sprístupnenia konkrétneho typového argumentu. ConfigKey, Init, Component a Inject sú vlastné metadáta. Bez kódu, ktorý ich spracuje, nič nenastavujú, nevolajú ani nevkladajú.
@Repeatable(Tags.class) umožňuje zapísať viacero @Tag na rovnaké miesto. Kompilátor zabalí opakovania do kontajnera s Tag[] value(); prípadné ďalšie prvky kontajnera musia mať predvolené hodnoty. Kontajner musí mať aspoň rovnako dlhú dobu uchovávania a kompatibilné ciele; v príklade sú ciele rovnaké. Ak má Tag anotáciu @Inherited, musí ju mať aj kontajner. getAnnotationsByType(Tag.class) rozbalí kontajner a vďaka Inherited vyhľadáva v nadtriedach, ak trieda nemá vlastné tagy. Nespája tagy z rôznych úrovní, neprehľadáva rozhrania a nededí anotácie metód ani polí. getDeclaredAnnotationsByType tiež rozbalí kontajner, ale nehľadá v nadtriedach; getAnnotation kontajner nerozbaľuje.
new Consumer<Number>() { ... } deklaruje a vytvorí inštanciu anonymnej triedy. @Override umožní kompilátoru overiť, že accept(Number) implementuje metódu rozhrania a omylom ju nepreťažuje. Java 21 pripúšťa aj signatúry ekvivalentné z hľadiska prepisovania verejným metódam Object a explicitné prístupové metódy komponentov recordu.
Consumer<? super Integer> prijíma konzumenta typu Integer alebo niektorého jeho nadtypu, napríklad Number či Object, a možno mu odovzdať Integer. Neohraničený zástupný symbol ?, napríklad v Consumer<?>, ponecháva typový argument neznámy, preto nemožno odovzdať Integer odlišný od null. @SuppressWarnings("unchecked") potlačí upozornenie kompilátora, ale nekontroluje typy prvkov zoznamu a nezabráni ClassCastException. Vyhýbaj sa zbytočným pretypovaniam; ak je pretypovanie odôvodnené, potlač upozornenie na najmenšej deklarácii, kde to funguje.
Príklady
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));
}
}Výsledok
Config: port Started: false -> true Component/Inject: true/true Tags: core, fast; declared: 0 Subscriber: 21 Cast: ok
`started` sa zmení až po explicitnom volaní `method.invoke(service)`. `Child` načíta dva tagy z `Base`, hoci vlastné nedeklaruje. Pretypovanie je tu odôvodnené známym pôvodom zoznamu z `List.of("ok")`, nie anotáciou `@SuppressWarnings`.
Súvisiace lekcie
- Java · Lekcia 44 · Pokročilá · Verzia: 2
- Java · Lekcia 54 · Pokročilá · Verzia: 2
- Java · Lekcia 58 · Pokročilá · Verzia: 2
- Java · Lekcia 59 · Pokročilá · Verzia: 2
Zdroje
- 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