Esiste qualcosa come Annotation Inheritance in java?

Sto esplorando le annotazioni e sono arrivato a un punto in cui alcune annotazioni sembrano avere una gerarchia tra di loro.

Sto usando le annotazioni per generare codice in background per le carte. Esistono diversi tipi di carte (quindi codice e annotazioni diversi) ma ci sono alcuni elementi comuni tra loro come un nome.

@Target(value = {ElementType.TYPE})
public @interface Move extends Page{
 String method1();
 String method2();
}

E questa sarebbe l'annotazione comune:

@Target(value = {ElementType.TYPE})
public @interface Page{
 String method3();
}

Nell'esempio sopra, mi aspetto che Move to inherit method3 ma ricevo un avviso che dice che extends non è valido con le annotazioni. Stavo cercando di fare in modo che un'annotazione estendesse una base comune ma non funziona. È anche possibile o è solo un problema di design?

Sfortunatamente no. Apparentemente ha qualcosa a che fare con programmi che leggono le annotazioni su una classe senza caricarle del tutto. Vedi Perché non è possibile estendere le annotazioni in Java?

Tuttavia, i tipi ereditano le annotazioni della loro superclasse se tali annotazioni lo sono @Inherited.

Inoltre, a meno che tu non abbia bisogno di questi metodi per interagire, potresti semplicemente impilare le annotazioni sulla tua classe:

@Move
@Page
public class myAwesomeClass {}

C'è qualche motivo per cui non funzionerebbe per te?

Puoi annotare la tua annotazione con un'annotazione di base invece che con l'ereditarietà. Viene utilizzato nel framework Spring .

Per fare un esempio

@Target(value = {ElementType.ANNOTATION_TYPE})
public @interface Vehicle {
}

@Target(value = {ElementType.TYPE})
@Vehicle
public @interface Car {
}

@Car
class Foo {
}

È quindi possibile verificare se una classe è annotata Vehicleutilizzando AnnotationUtils di Spring :

Vehicle vehicleAnnotation = AnnotationUtils.findAnnotation (Foo.class, Vehicle.class);
boolean isAnnotated = vehicleAnnotation != null;

Questo metodo è implementato come:

public static <A extends Annotation> A findAnnotation(Class<?> clazz, Class<A> annotationType) {
    return findAnnotation(clazz, annotationType, new HashSet<Annotation>());
}

@SuppressWarnings("unchecked")
private static <A extends Annotation> A findAnnotation(Class<?> clazz, Class<A> annotationType, Set<Annotation> visited) {
    try {
        Annotation[] anns = clazz.getDeclaredAnnotations();
        for (Annotation ann : anns) {
            if (ann.annotationType() == annotationType) {
                return (A) ann;
            }
        }
        for (Annotation ann : anns) {
            if (!isInJavaLangAnnotationPackage(ann) && visited.add(ann)) {
                A annotation = findAnnotation(ann.annotationType(), annotationType, visited);
                if (annotation != null) {
                    return annotation;
                }
            }
        }
    }
    catch (Exception ex) {
        handleIntrospectionFailure(clazz, ex);
        return null;
    }

    for (Class<?> ifc : clazz.getInterfaces()) {
        A annotation = findAnnotation(ifc, annotationType, visited);
        if (annotation != null) {
            return annotation;
        }
    }

    Class<?> superclass = clazz.getSuperclass();
    if (superclass == null || Object.class == superclass) {
        return null;
    }
    return findAnnotation(superclass, annotationType, visited);
}

AnnotationUtilscontiene anche metodi aggiuntivi per la ricerca di annotazioni su metodi e altri elementi annotati. La classe Spring è anche abbastanza potente da cercare attraverso metodi con bridge, proxy e altri casi d'angolo, in particolare quelli incontrati in Spring.

Oltre alla risposta di Grygoriys sull'annotazione delle annotazioni.

Puoi controllare ad esempio i metodi per contenere @Qualifierun'annotazione (o un'annotazione annotata con @Qualifier) da questo ciclo:

for (Annotation a : method.getAnnotations()) {
    if (a.annotationType().isAnnotationPresent(Qualifier.class)) {
        System.out.println("found @Qualifier annotation");//found annotation having Qualifier annotation itself
    }
}

Quello che stai facendo fondamentalmente è ottenere tutte le annotazioni presenti sul metodo e di quelle annotazioni ottieni i loro tipi e controlla quei tipi se sono annotati con @Qualifier. Anche la tua annotazione deve essere Target.Annotation_type abilitata affinché funzioni.

Dai un'occhiata a https://github.com/blindpirate/annotation-magic , che è una libreria che ho sviluppato quando ho avuto la stessa domanda.

@interface Animal {
    boolean fluffy() default false;

    String name() default "";
}

@Extends(Animal.class)
@Animal(fluffy = true)
@interface Pet {
    String name();
}

@Extends(Pet.class)
@interface Cat {
    @AliasFor("name")
    String value();
}

@Extends(Pet.class)
@interface Dog {
    String name();
}

@interface Rat {
    @AliasFor(target = Animal.class, value = "name")
    String value();
}

@Cat("Tom")
class MyClass {
    @Dog(name = "Spike")
    @Rat("Jerry")
    public void foo() {
    }
}

        Pet petAnnotation = AnnotationMagic.getOneAnnotationOnClassOrNull(MyClass.class, Pet.class);
        assertEquals("Tom", petAnnotation.name());
        assertTrue(AnnotationMagic.instanceOf(petAnnotation, Animal.class));

        Animal animalAnnotation = AnnotationMagic.getOneAnnotationOnClassOrNull(MyClass.class, Animal.class);
        assertTrue(animalAnnotation.fluffy());

        Method fooMethod = MyClass.class.getMethod("foo");
        List<Animal> animalAnnotations = AnnotationMagic.getAnnotationsOnMethod(fooMethod, Animal.class);
        assertEquals(Arrays.asList("Spike", "Jerry"), animalAnnotations.stream().map(Animal::name).collect(toList()));