Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / Java

Anotacije v Javi: cilji, hramba, ponavljanje in refleksija

Deklaracija anotacije v Java SE 21 določa podatke, dovoljena mesta uporabe in vidnost med izvajanjem. Nauči se prebrati metapodatke z refleksijo, ločiti deklarirane anotacije od podedovanih in omejiti obseg utišanja opozoril.

Različica: Java SE 21

Sintaksa

@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 deklarira anotacijski vmesnik. String value(); določa element, @Tag("core") pa je krajši zapis za @Tag(value = "core"). Metaanotacija Target iz java.lang.annotation določa dovoljena mesta uporabe. @Target(ElementType.TYPE/FIELD/CONSTRUCTOR) je opisna okrajšava, ne sintaksa Jave: uporabi @Target({ElementType.TYPE, ElementType.FIELD, ElementType.CONSTRUCTOR}). ElementType.TYPE velja za deklaracije razredov in vmesnikov, ne za uporabo tipa (TYPE_USE). ElementType.FIELD/METHOD označuje dve konstanti: ElementType.FIELD za polja in ElementType.METHOD za metode. Konstruktorji imajo poseben cilj.

Retention določa trajanje hrambe: SOURCE se ne zapiše v datoteko razreda, privzeti CLASS se zapiše, a ni na voljo prek refleksije med izvajanjem, @Retention(RetentionPolicy.RUNTIME) pa omogoči refleksijski dostop do anotacij iz primera. Izjema so deklaracije lokalnih spremenljivk in parametrov lambda izrazov: njihove deklaracijske anotacije se ne shranijo v datoteko razreda. Razredni literal Base.class da objekt Class<Base>; Class<?> ga sprejme, ne da bi razkril konkretni tipski argument. ConfigKey, Init, Component in Inject so lastni metapodatki. Brez kode, ki jih interpretira, ničesar ne nastavijo, pokličejo ali vbrizgajo.

@Repeatable(Tags.class) omogoča več zapisov @Tag na istem mestu. Prevajalnik ponovitve združi v vsebnik z Tag[] value(); morebitni drugi elementi vsebnika morajo imeti privzete vrednosti. Vsebnik mora imeti vsaj enako dolgo hrambo in združljive cilje; v primeru so cilji enaki. Če ima Tag anotacijo @Inherited, jo mora imeti tudi vsebnik. getAnnotationsByType(Tag.class) razpakira vsebnik in zaradi Inherited išče po nadrazredih, če razred nima lastnih oznak. Ne združuje oznak z različnih ravni, ne išče po vmesnikih in ne deduje anotacij metod ali polj. getDeclaredAnnotationsByType prav tako razpakira vsebnik, a ne preišče nadrazredov; getAnnotation vsebnika ne razpakira.

new Consumer<Number>() { ... } deklarira anonimni razred in ustvari njegovo instanco. Z @Override prevajalnik preveri, da accept(Number) implementira metodo vmesnika, namesto da bi jo pomotoma preobremenila. Java 21 dovoljuje tudi podpise, ki so za prepisovanje enakovredni podpisom javnih metod Object, in eksplicitne dostopne metode za komponente recorda.

Consumer<? super Integer> sprejme porabnika tipa Integer ali njegovega nadtipa, na primer Number ali Object, ter mu omogoča posredovati Integer. Neomejeni nadomestni znak ?, na primer v Consumer<?>, pusti tipski argument neznan, zato mu ni mogoče posredovati vrednosti Integer, različne od null. @SuppressWarnings("unchecked") utiša opozorilo prevajalnika, vendar ne preverja tipov elementov seznama in ne prepreči ClassCastException. Izogibaj se nepotrebnim pretvorbam tipov; če je pretvorba utemeljena, utišaj opozorilo na najmanjši deklaraciji, kjer deluje.

Primeri

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));
    }
}

Rezultat

Config: port
Started: false -> true
Component/Inject: true/true
Tags: core, fast; declared: 0
Subscriber: 21
Cast: ok

`started` se spremeni šele ob eksplicitnem klicu `method.invoke(service)`. `Child` prebere dve oznaki iz `Base`, čeprav ne deklarira nobene. Pretvorba tipa je utemeljena z znanim izvorom seznama iz `List.of("ok")`, ne z `@SuppressWarnings`.

Povezane lekcije

  • Java · Lekcija 44 · Napredna · Različica: 2
  • Java · Lekcija 54 · Napredna · Različica: 2
  • Java · Lekcija 58 · Napredna · Različica: 2
  • Java · Lekcija 59 · Napredna · Različica: 2

Viri