ejemplo - ¿Hay algo así como la herencia de anotación en java?

crear annotations en java

Question

Estoy explorando anotaciones y llegué a un punto en el que algunas anotaciones parecen tener una jerarquía entre ellas.

Estoy usando anotaciones para generar código en el fondo para Tarjetas. Existen diferentes tipos de Tarjeta (por lo tanto, diferentes códigos y anotaciones), pero hay ciertos elementos que son comunes entre ellos como un nombre.

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

Y esta sería la Anotación común:

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

En el ejemplo anterior, esperaría que Move heredara el método3, pero recibo una advertencia que dice que extends no es válido con las anotaciones. Estaba tratando de tener una Anotación que amplía una base común pero eso no funciona. ¿Es eso posible o solo es un problema de diseño?

Answer 1

Además de la respuesta de Grygoriys de anotaciones anotadas.

Puede verificar, por ejemplo, los métodos para contener una anotación @Qualifier (o una anotación anotada con @Qualifier) ​​mediante este ciclo:

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

Lo que básicamente estás haciendo es obtener todas las anotaciones presentes en el método y esas anotaciones obtienes sus tipos y verifica esos tipos si están anotadas con @Qualifier. Su anotación debe ser Target.Anotation_type habilitado también para que funcione.

Answer 2

Lamentablemente no. Aparentemente tiene algo que ver con los programas que leen las anotaciones en una clase sin cargarlas por completo. Consulte ¿Por qué no es posible ampliar las anotaciones en Java?

Sin embargo, los tipos heredan las anotaciones de su superclase si esas anotaciones son @Inherited .

Además, a menos que necesite esos métodos para interactuar, puede simplemente apilar las anotaciones en su clase:

@Move
@Page
public class myAwesomeClass {}

¿Hay alguna razón por la que no funcionaría para ti?

Answer 3

Puede anotar su anotación con una anotación base en lugar de la herencia. Esto se usa en el marco de primavera .

Para dar un ejemplo

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

Luego puede verificar si una clase está anotada con Vehicle usando la Anotación de SpringUtils :

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

Este método se implementa como:

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

AnnotationUtils también contiene métodos adicionales para buscar anotaciones en métodos y otros elementos anotados. La clase Spring también es lo suficientemente potente como para buscar a través de métodos en puente, proxies y otros casos de esquina, particularmente los encontrados en Spring.