Anotaciones múltiples del mismo tipo en un elemento?

Question

Estoy intentando copiar dos o más anotaciones del mismo tipo en un solo elemento, en este caso, un método. Aquí está el código aproximada que estoy trabajando con:

public class Dupe { 
    public @interface Foo { 
     String bar(); 
    } 

    @Foo(bar="one") 
    @Foo(bar="two") 
    public void haha() {} 
} 

Al compilar lo anterior, javac se queja de una anotación de duplicado:

 
max@upsight:~/work/daybreak$ javac Dupe.java 
Dupe.java:5: duplicate annotation 

¿Es simplemente no es posible repetir las anotaciones de este tipo? Pedadicamente hablando, ¿no son las dos instancias de @Foo superiores diferentes debido a que sus contenidos son diferentes?

Si lo anterior no es posible, ¿cuáles son algunas soluciones posibles?

ACTUALIZACIÓN: Me han pedido que describa mi caso de uso. Aquí va.

Estoy construyendo un mecanismo de sintaxis azucarada para "mapear" POJOs para documentar tiendas como MongoDB. Quiero permitir que los índices se especifiquen como anotaciones en los getters o setters. Aquí está un ejemplo artificial:

public class Employee { 
    private List<Project> projects; 

    @Index(expr = "project.client_id") 
    @Index(expr = "project.start_date") 
    public List<Project> getProjects() { return projects; } 
} 

Obviamente, quiero ser capaz de encontrar rápidamente las instancias de la plantilla por varias propiedades del proyecto. Puedo especificar @Index dos veces con diferentes valores de expr() o tomar el enfoque especificado en la respuesta aceptada. Aunque Hibernate hace esto y no se considera un hack, creo que todavía tiene sentido permitir al menos tener varias anotaciones del mismo tipo en un solo elemento.

Answer 1

No se permiten dos o más anotaciones del mismo tipo. Sin embargo, se podría hacer algo como esto:

public @interface Foos { 
    Foo[] value(); 
} 

@Foos({@Foo(bar="one"), @Foo(bar="two")}) 
public void haha() {} 

que necesitará un manejo especializado de Foos anotación en el código sin embargo.

por cierto, he acabo de utilizar este hace 2 horas para solucionar el mismo problema :)

Answer 2

Como dijo por sfussenegger, esto no es posible.

La solución habitual es crear una anotación "múltiple", que maneja una matriz de la anotación anterior. Suele llamarse igual, con un sufijo 's'.

Por cierto, esto es muy utilizado en grandes proyectos públicos (Hibernate, por ejemplo), por lo que no se debe considerar como un hack, sino como una solución correcta para esta necesidad.

---

Dependiendo de sus necesidades, podría ser mejor permita que su anotación anterior para manejar múltiples valores.

Ejemplo:

public @interface Foo { 
     String[] bars(); 
    } 

Answer 3

Si sólo tiene un "bar" 1 parámetro que puede nombrar como "valor". En este caso, usted no tiene que escribir el nombre del parámetro en absoluto cuando se utiliza de esta manera:

@Foos({@Foo("one"), @Foo("two")}) 
public void haha() {} 

un poco más corto y más ordenado, en mi humilde opinión ..

Answer 4

En Java 8 (lanzado en marzo de 2014), es posible escribir anotaciones repetidas/duplicadas. Ver http://docs.oracle.com/javase/tutorial/java/annotations/repeating.html.

Answer 5

combinando las otras respuestas en la forma más simple ... una anotación con una simple lista de los valores ...

Answer 6

http://docs.oracle.com/javase/tutorial/java/annotations/repeating.html

A partir de Java8 se puede describir anotaciones repetibles:

@Repeatable(FooValues.class) 
public @interface Foo { 
    String bar(); 
} 

public @interface FooValues { 
    Foo[] value(); 
} 

Nota, value es un campo obligatorio para la lista de valores.

Ahora usted puede utilizar las anotaciones repetición de ellas en lugar de llenar la matriz:

@Foo(bar="one") 
@Foo(bar="two") 
public void haha() {} 

Answer 7

Aparte de las otras formas mencionadas, existe una forma más menos detallado en Java8:

@Target(ElementType.TYPE) 
@Repeatable(FooContainer.class) 
@Retention(RetentionPolicy.RUNTIME) 
@interface Foo { 
    String value(); 

} 

@Target(ElementType.TYPE) 
@Retention(RetentionPolicy.RUNTIME) 
@interface FooContainer { 
     Foo[] value(); 
     } 

@Foo("1") @Foo("2") @Foo("3") 
class Example{ 

} 

ejemplo, por por defecto se pone, FooContainer como una anotación

Arrays.stream(Example.class.getDeclaredAnnotations()).forEach(System.out::println); 
    System.out.println(Example.class.getAnnotation(FooContainer.class)); 

Tanto el por encima de impresión:

@ com.FooContainer (valor = [@ com.Foo (valor = 1), @ com.Foo (valor = 2), @ com.Foo (valor = 3)])

@ com.FooContainer (valor = [@ com.Foo (valor = 1), @ com.Foo (valor = 2), @ com.Foo (valor = 3)])