Y a-t-il quelque chose comme l’inheritance d’annotation dans Java?

J’explore les annotations et en arrive à un point où certaines annotations semblent avoir une hiérarchie entre elles.

J’utilise des annotations pour générer du code en arrière-plan pour les cartes. Il existe différents types de cartes (donc des codes et des annotations différents), mais certains éléments sont communs comme un nom.

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

Et ce serait l’annotation commune:

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

Dans l’exemple ci-dessus, je m’attendrais à ce que Move hérite de method3, mais je reçois un avertissement disant que extend n’est pas valide pour les annotations. J’essayais d’avoir une annotation qui étend une base commune mais cela ne fonctionne pas. Est-ce que c’est même possible ou est-ce juste un problème de conception?

Malheureusement non. Apparemment, cela a quelque chose à voir avec les programmes qui lisent les annotations sur une classe sans les charger complètement. Voir Pourquoi est-il impossible d’étendre les annotations en Java?

Cependant, les types héritent des annotations de leur superclasse si ces annotations sont @Inherited .

De plus, sauf si vous avez besoin de ces méthodes pour interagir, vous pouvez simplement emstackr les annotations sur votre classe:

 @Move @Page public class myAwesomeClass {} 

Y a-t-il une raison qui ne fonctionnerait pas pour vous?

Vous pouvez annoter votre annotation avec une annotation de base au lieu de l’inheritance. Ceci est utilisé dans le framework Spring .

Donner un exemple

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

Vous pouvez ensuite vérifier si une classe est annotée avec Vehicle aide de l’option AnnotationUtils de Spring :

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

Cette méthode est implémentée comme suit:

 public static  A findAnnotation(Class< ?> clazz, Class annotationType) { return findAnnotation(clazz, annotationType, new HashSet()); } @SuppressWarnings("unchecked") private static  A findAnnotation(Class< ?> clazz, Class annotationType, Set 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); } 

AnnotationUtils contient également des méthodes supplémentaires pour rechercher des annotations sur les méthodes et autres éléments annotés. La classe Spring est également assez puissante pour rechercher des méthodes pontées, des proxys et d’autres casiers, en particulier ceux rencontrés au spring.

En plus de Grygoriys, répondez aux annotations.

Vous pouvez vérifier par exemple les méthodes pour contenir une annotation @Qualifier (ou une annotation annotée avec @Qualifier) ​​par cette boucle:

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

Qu’est-ce que vous faites essentiellement, est d’obtenir toutes les annotations présentes sur la méthode et de ces annotations, vous obtenez leurs types et vérifiez ces types si elles sont annotées avec @Qualifier. Votre annotation doit également être Target.Annotation_type pour que cela fonctionne.