Apakah ada sesuatu seperti Annotation Inheritance di java?

Saya menjelajahi anotasi dan sampai pada titik di mana beberapa anotasi tampaknya memiliki hierarki di antara anotasi tersebut.

Saya menggunakan anotasi untuk menghasilkan kode di latar belakang untuk Kartu. Ada berbagai jenis Kartu (dengan demikian kode dan anotasi berbeda) tetapi ada elemen tertentu yang umum di antara mereka seperti nama.

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

Dan ini akan menjadi Anotasi yang umum:

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

Dalam contoh di atas saya berharap Pindah ke mewarisi method3 tetapi saya mendapat peringatan yang mengatakan bahwa meluas tidak valid dengan anotasi. Saya mencoba agar Anotasi memperluas basis yang sama tetapi tidak berhasil. Apakah itu mungkin atau hanya masalah desain?

Sayangnya tidak ada. Rupanya ini ada hubungannya dengan program yang membaca anotasi di kelas tanpa memuatnya sepenuhnya. Lihat Mengapa tidak mungkin memperluas anotasi di Java?

Namun, tipe mewarisi anotasi superkelasnya jika anotasi tersebut adalah @Inherited.

Selain itu, kecuali Anda memerlukan metode tersebut untuk berinteraksi, Anda bisa menumpuk anotasi di kelas Anda:

@Move
@Page
public class myAwesomeClass {}

Apakah ada alasan yang tidak berhasil untuk Anda?

Anda dapat membuat anotasi anotasi Anda dengan anotasi dasar, bukan dengan pewarisan. Ini digunakan dalam kerangka Spring .

Memberi contoh

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

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

@Car
class Foo {
}

Anda kemudian dapat memeriksa apakah sebuah kelas dianotasi Vehiclemenggunakan Spring's AnnotationUtils :

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

Metode ini diimplementasikan sebagai:

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

AnnotationUtilsjuga berisi metode tambahan untuk mencari penjelasan tentang metode dan elemen beranotasi lainnya. Kelas Spring juga cukup kuat untuk mencari melalui metode bridged, proxy, dan kasus sudut lainnya, terutama yang ditemui di Spring.

Selain jawaban Grygoriys tentang anotasi anotasi.

Anda dapat memeriksa misalnya metode untuk memuat @Qualifieranotasi (atau anotasi dengan anotasi @Qualifier) oleh loop ini:

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

Apa yang pada dasarnya Anda lakukan, adalah menampilkan semua anotasi pada metode dan dari anotasi tersebut Anda mendapatkan jenisnya dan memeriksa jenis tersebut jika dianotasi dengan @Qualifier. Anotasi Anda harus Target.Annotation_type diaktifkan juga agar ini berfungsi.

Lihat https://github.com/blindpirate/annotation-magic , yang merupakan perpustakaan yang saya kembangkan ketika saya memiliki pertanyaan yang sama.

@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()));