@SearchInsideAnnotations

Esta anotação configura quando uma anotação pode ser definida dentro de outra. Quando uma anotação com essa configuração é pesquisada, a implementação da API deve procurá-la dentro de cada uma das anotações do elemento de destino;

Exemplo:

Como exemplo em primeiro lugar, criamos uma anotação contendo @SearchInsideAnnotations que diz que a anotação está dentro de outra anotação. Neste caso a anotação @AnnotationInAnnotation está anotada com a @SearchInsideAnnotations

@Retention(RetentionPolicy.RUNTIME)
@SearchInsideAnnotations
public @interface AnotationInAnotation {
}                          

Em seguida, criamos uma anotação que contem a anotação criada anteriormente, e tambem colocamos a anotação @SearchInsideAnnotations .

@Retention(RetentionPolicy.RUNTIME)
@AnotationInAnotation
@SearchInsideAnnotations
public @interface AnotationInElement {
}

Criamos uma classe que contem a anotação criada anteriormente.

@AnotationInElement
public class ElementWithMetadata {
}

Por ultimo criamos a busca pela anotação @AnnotationInAnnotation na classe ElementWithMetadata este vai verificar se o @AnnotationInAnnotation existe na classe existe no elemento anotado ou em anotações do elemento anotado.

@Test
public void metadataLocatorTestWithAnnotation() {
   List<Annotation> annotationList = AnnotationFinder.findAnnotation(ElementWithMetadata.class, AnotationInAnotation.class);
   assertTrue(annotationList.size()>0);
   assertTrue(annotationList.get(0) instanceof AnotationInAnotation);
}

@SearchOnEnclosingElements

Esta anotação configura quando uma anotação pode ser definida no escopo do seu elemento de inclusão. Quando uma anotação com essa configuração é pesquisada em um método, se não for encontrada, a implementação da API deve verificar se ela está presente em sua classe;

Exemplo:

Criemos uma anotação para anotar a classe, contendo a anotação @SearchOnEnclosingElements, que é a anotação responsavel por dizer em que nivel a anotação está na classe.

@Retention(RetentionPolicy.RUNTIME)
@SearchOnEnclosingElements
public @interface AnnotationInClass {

}

Em seguida criamos uma classe annotada com a anotação criada anteriormente, com um atributo ou metodo, neste exemplo foi criado com um atributo.

@AnnotationInClass
public class ClassWithAnnotation {
   public Object selectedElement;
}

Em seguida executamos o AnnotationFinder.findAnnotation() este caso de teste, vai retornar uma lista de anotações contendo a anotação @AnnotationInClass esta anotação vai retorar um elemento de nivel acima do elemento que está sendo buscado.

@Test
public void testWithAnnotation() throws NoSuchFieldException, SecurityException {
   List<Annotation> annotationList = 
         AnnotationFinder.findAnnotation(ClassWithAnnotation.class.getDeclaredField("selectedElement"), 
	 AnnotationInClass.class);
   assertTrue(annotationList.size()>0);
   assertTrue(annotationList.get(0) instanceof AnnotationInClass);
}

Uso de Anotações Basicas

@ContainerFor(ContainerTarget.TYPE)
public class ContainerClass {
   @ElementName
   private String elementName;

   @ContainsAnnotation(AnnotationInClass.class)
   private boolean existAnnotation;

   @ReflectionReference
   private Class<?>  reference;

   @AnnotationProperty(annotation = AnnotationInClass.class, property ="elementInAnnotation")
   private String elementInAnnotation;

   public String getElementInAnnotation() {
      return elementInAnnotation;
   }
   public void setElementInAnnotation(String elementInAnnotation) {
      this.elementInAnnotation = elementInAnnotation;
   }

   public String getElementName() {
      return elementName;
   }

   public void setElementName(String elementName) {
      this.elementName = elementName;
   }

   public boolean isExistAnnotation() {
      return existAnnotation;
   }

   public void setExistAnnotation(boolean existAnnotation) {
      this.existAnnotation = existAnnotation;
   }

   public Class<?> getReference() {
      return reference;
   }

   public void setReference(Class<?> reference) {
      this.reference = reference;
   }
}

@Retention(RetentionPolicy.RUNTIME)
public @interface AnnotationInClass{				 {
	String elementInAnnotation();
}

@AnnotationInClass(elementInAnnotation="valueOfAnnotation")
public class ClassForReader {
}

@Test
public void testAnnotationsBasic() throws Exception {
   ContainerClass container;
   AnnotationReader annotationReader = new AnnotationReader();

   container = annotationReader.readingAnnotationsTo(ClassForReader.class, ContainerClass.class);
   assertTrue(container.isExistAnnotation());
   assertEquals(ClassForReader.class.getName(), container.getElementName());
   assertEquals(ClassForReader.class, container.getReference());
   assertEquals("valueOfAnnotation", container.getElementInAnnotation());
}

Listas de anotações basicas

Anotações Avançadas

São anotações usadas para leitura e execução em elementos avançado perante o Metadata Container, que são usados para leitura e processamento de elementos como elementos e metodos.

@ContainerFor(ContainerTarget.TYPE)
public class ContainerClass {

   @ElementName
   private String elementName;

   @ReflectionReference
   private Class<?>  reference;

   @ProcessMethods
   private List<MethodContainer> methodContainer;

   @ProcessFields
   private List<FieldContainer> fieldContainer;

   @AllMethodsWith(AnnotationInElement.class)
   private List<MethodContainer> methodWithAnnotation;

   @AllFieldsWith(AnnotationInElement.class)
   private List<FieldContainer> fieldWithAnnotation;
		
   //METODOS GETS E SETS OMITIDOS

   public MethodContainer getAnnotedMethod(String name)
   {
      for(MethodContainer container : methodContainer){
         if(container.getElementName().equals(name)){
              return container;
         }
      }
      return null;
   }

   public FieldContainer getAnnotedField(String name){
      for(FieldContainer container : fieldContainer){
         if(container.getElementName().equals(name)){
            return container;
         }
      }
      return null;
   }
}

@ContainerFor(ContainerTarget.FIELDS)
public class FieldContainer {
   @ElementName
   private String elementName;

   @ContainsAnnotation(AnnotationInElement.class)
   private boolean existAnnotation;

  //METODOS GETS E SETS OMITIDOS
}

@ContainerFor(ContainerTarget.METHODS)
public class MethodContainer {

	@ElementName
	private String elementName;

	@ContainsAnnotation(AnnotationInElement.class)
	private boolean existAnnotation;
	
	//METODOS GETS E SETS OMITIDOS
}

@Retention(RUNTIME)
@Target({ FIELD, METHOD })
public @interface AnnotationInElement {
}

package net.sf.esfinge.metadata.examples.annotationReader.advanced;

@AnnotationInClass
public class ClassForReader {
  private String fieldWinouthAnnotation;

   @AnnotationInElement
   private String fieldWithAnnotation;

   @AnnotationInElement
   public void methodWithAnnotation(){
   }
   
   public void methodWinouthAnnotation(){
   }
}

public class AnnotationReaderTest {
   @Test
   public void testAnnotationsBasic() throws Exception {
	ContainerClass container;
	AnnotationReader annotationReader = new AnnotationReader();

	container = annotationReader.readingAnnotationsTo(ClassForReader.class, ContainerClass.class);

	assertEquals(ClassForReader.class, container.getReference());

	MethodContainer methodWithAnnotation = container.getAnnotedMethod("methodWithAnnotation");
	assertEquals("methodWithAnnotation", methodWithAnnotation.getElementName());
	assertTrue(methodWithAnnotation.isExistAnnotation());
			MethodContainer methodWinouthAnnotation = container.getAnnotedMethod("methodWinouthAnnotation");
	assertEquals("methodWinouthAnnotation", methodWinouthAnnotation.getElementName());
	assertFalse(methodWinouthAnnotation.isExistAnnotation());


	FieldContainer fieldWinouthAnnotation = container.getAnnotedField("fieldWinouthAnnotation");
	assertEquals("fieldWinouthAnnotation", fieldWinouthAnnotation.getElementName());
	assertFalse(fieldWinouthAnnotation.isExistAnnotation());

	FieldContainer fieldWithAnnotation = container.getAnnotedField("fieldWithAnnotation");
	assertEquals("fieldWithAnnotation", fieldWithAnnotation.getElementName());
	assertTrue(fieldWithAnnotation.isExistAnnotation());
   }
}

Listas de Anotações Avançadas

Processors

São utilizadas para a construção de esquemas personalizados de anotações para a sua aplicação utilizando a estrutura do Esfinge Metadata.

Para eles executarem nescessitam da configAnnotation, que vai uma classe, e do type que vai o ProcessorType

Os Processors são os seguintes, @CustonReader, @ProcessPerMethod, @ProcessPerField.
Os ProcessorType são os seguintes: READER_ADDS_METADATA, READER_IS_PROCESSOR, READER_RETURN_PROCESSOR.

Neste caso o Reader adiciona as informações de processors no container.

Exemplos:

Usando o @CustonReader e READER_ADDS_METADATA

Em primeiro Momento criaremos um Container, neste caso vai estar anotado nele o @CustonReader();

@ContainerFor(ContainerTarget.TYPE)
@CustomReader(configAnnotation = MyAnnotationReader.class, type = ProcessorType.READER_ADDS_METADATA,
 readerConfig = "value")
public class Container {
	private String className;
	//Get e Set omitidos
}   

Anotação criada que será executada com o processor.

@Retention(RUNTIME)
public @interface MyAnnotationReader {
	Class<? extends InterfaceWithProcessor> value();
}

Anotação que vai na classe que queremos usar com o Esfinge Metadata com o processor.

@Retention(RUNTIME)
@MyAnnotationReader(ExecuteProcessor.class)
public @interface MyAnnotation {

}

Processor que vai ser executado, neste caso vai passar o nome do AnnotatedElement que vai no processor para a execução

public class ExecuteProcessor implements InterfaceWithProcessor {

	@Override
	public void execute(AnnotatedElement element,Object container) {
		((Container)container).setClassName(((Class)element).getName());
	}
}

@MyAnnotation
public class MyClass {

}

Metodo main que vai executar o programa, e retornar o nome da classe usando o READER_ADDS_METADATA.

public static void main(String[] args) throws Exception {
	AnnotationReader reader = new AnnotationReader();
	Container ct = new Container();
	ct = reader.readingAnnotationsTo(MyClass.class, Container.class);
	System.out.println(ct.getClassName());
}

Usando o @CustonReader e READER_IS_PROCESSOR

@ContainerFor(ContainerTarget.TYPE)
public class Container {

	@ElementName
	private String elementName;

	@CustomReader(configAnnotation=PropertyAnnotation.class, type = ProcessorType.READER_IS_PROCESSOR)
	private List<PropertyProcessorInterface> interf;
	//gets e sets omitidos
}

Anotação que usa a PropertyAnnotation,

@Retention(RUNTIME)
@PropertyAnnotation(ExecuteProcessors.class)
public @interface OutraAnnotation {

}

Interface que foi criada para como um template de como deve ser o PropertyAnnotation.

public interface PropertyProcessorInterface {

	@ExecuteProcessor
	public void execute(Annotation ann, AnnotatedElement ael);

	public void print();
}

Classe que foi anotada na anotação @OutraAnnotation, está vai executar os metodos que na Interface estão anotados com @ExecuteProcessor, e ser impresso na tela o que estiver no metodo print().

@ContainerFor(ContainerTarget.ALL)
public class ExecuteProcessors implements PropertyProcessorInterface {

	private Annotation ann;
	private AnnotatedElement ael;

	@ContainsAnnotation(OutraAnnotation.class)
	private boolean existAnnotation;
	
        @Override
	public void execute(Annotation ann, AnnotatedElement ael) {
		this.ann = ann;
		this.ael = ael;
	}

	public boolean isExistAnnotation() {
		return existAnnotation;
	}

	public void setExistAnnotation(boolean existAnnotation) {
		this.existAnnotation = existAnnotation;
	}

	@Override
	public void print() {
		System.out.println("Elemento "+ael+" anotado com " + ann);
		System.out.println("A anotação "+ ann+ " "+existAnnotation);
	}
}

A classe que foi anotada com a anotação @OutraAnotação.

@OutraAnnotation
public class ClassWithMetadata {

}

Aqui vemos o metodo main() de como é executado o Container com os processors, primeiro instancia um novo Container, e logo em seguida,

public static void main(String args[]) throws Exception {
	AnnotationReader ar = new AnnotationReader();

	Container ct = new Container();

	ct = ar.readingAnnotationsTo(ClassWithMetadata.class, Container.class);								for (PropertyProcessorInterface execute :ct.getInterf()) {
		execute.print();
	}


}

Usando o @CustonReader e READER_RETURN_PROCESSOR

Foi criado um contatainer, neste caso foi criado um container que retorna um tipo de container.

public class ContainerReaderReturn {

	@CustomReader(configAnnotation = AnnotationReturn.class, type= ProcessorType.READER_RETURNS_PROCESSOR,readerConfig="value")
	private List<ReturnInterface> list;

}

Anotação que vai ser configurada no @CustonReader.

public @interface AnnotationReturn {
    Class<? extends ReturnProcessorInterface> value();
}

Interface que foi criada para retornar os dados que vão ser retornados pelo container.

public interface ReturnInterface {
	public String returnDados();
}

@Retention(RUNTIME)
@AnnotationReturn(ProcessorAnnotation.class)
public @interface MeuReader {

}

public class ProcessorAnnotation implements ReturnProcessorInterface{
	@Override
	public ReturnInterface toReturn(Annotation an) {
		ImprimirAnotacao imprimir = new ImprimirAnotacao(an);
			return (ReturnInterface) imprimir;
	}
}

@MeuReader
public class ClassToRead {

}

public class ImprimirAnotacao implements ReturnInterface {
	private Annotation an;

	public ImprimirAnotacao(Annotation an) {
		this.an = an;
	}

	@Override
	public String returnDados() {
		// TODO Auto-generated method stub
		return "Anotação "+an.annotationType();
	}
}

public static void main(String[] args) throws Exception {
		AnnotationReader ar = new AnnotationReader();
		ContainerReaderReturn ct = new ContainerReaderReturn();
		ct = ar.readingAnnotationsTo(ClassToRead.class, ct.getClass());

		System.out.println(ct.getElementName());
		for (ReturnInterface lista : ct.getList()) {
			System.out.println(lista.returnDados());
		}
	}

Exemplo de @ProcessorPerMethod e Reader_Is_Processor.

Em um primeiro momento criaremos o container com uma interface de processor, esta vai ser definida como:

@ContainerFor(ContainerTarget.TYPE)
public class Container{

	@ProcessorPerMethod(configAnnotation=ProcessorAnnotation.class,type=ProcessorType.READER_IS_PROCESSOR)
	Map<Method,ProcessorInterface> map;
	//gets e sets omitidos
 }

Criaremos a anotação que foi definida em configAnnotation, está será usada para configurar as anotações que serão usadas para dizer qual vai ser o processador da interface que vai ser utilizado no exemplo.

@Retention(RetentionPolicy.RUNTIME)
@SearchInsideAnnotations
@SearchOnEnclosingElements
@SearchOnAbstractions
public @interface ProcessorAnnotation {
	Class<? extends ProcessorInterface> value();
}

Criaremos a interface ProcessorInterface, está interface define como será executado o codigo dos processors.

public interface ProcessorInterface {

	@ExecuteProcessor
	public void processorInitializationFieldAndAnnotedElement(Annotation ann);

	public void returnDados();

}

@Retention(RetentionPolicy.RUNTIME)
@SearchOnEnclosingElements
@SearchInsideAnnotations
@SearchOnAbstractions
@ProcessorAnnotation(Processor.class)
public @interface Entidade {

}

public class Processor implements ProcessorInterface {

	private String field2;

	@Override
	public void processorInitializationFieldAndAnnotedElement(Annotation ann) {
		field2 = ann.annotationType().getName();
	}

	@Override
	public void returnDados() {
		System.out.println(field2);
	}
}

Classe que vai ser passada para a leitura de anotações, esta classe implementa a Interface DominioInterface, e possui uma implementação do metodo que queremos buscar com o Esfinge Metadata.

public class Dominio implements DominioInterface{

	@Override
	public void entidade1(){}

}

Interface criada com a anotação @Entidade, que por sua vez será buscada no metodo.

public interface DominioInterface {
   @Entidade
   public void entidade1();
}

Execução do EsfingeMetadata, neste caso ele verifica se a entidade está na classe ou na interface do mesmo.

public static void main(String args[]) throws Exception {
      Container container = new Container();
      AnnotationReader a1 = new AnnotationReader();
      container = a1.readingAnnotationsTo(Dominio.class, container.getClass());
      container.map.forEach((key, value) -> {
      value.returnDados();
   });
}

@ProcessorPerField

Exemplo:

Criaremos um container do tipo de field, este por sua vez está anotado com o @ProcessorPerField.

@ContainerFor(ContainerTarget.TYPE)
public class Container{

	@ProcessorPerField(configAnnotation=ProcessorAnnotation.class,type=ProcessorType.READER_IS_PROCESSOR)
	Map<Field,ProcessorInterface> map;
	//gets e sets omitidos
 }

Criaremos a anotação que foi definida em configAnnotation, está será usada para configurar as anotações que serão usadas para dizer qual vai ser o processador da interface que vai ser utilizado no exemplo.

@Retention(RetentionPolicy.RUNTIME)
@SearchInsideAnnotations
@SearchOnEnclosingElements
public @interface ProcessorAnnotation {
	Class<? extends ProcessorInterface> value();
}

public interface ProcessorInterface {
	@ExecuteProcessor
	public void processorInitializationAnnotation(Annotation ann);

	public void returnDados();

}

@Retention(RetentionPolicy.RUNTIME)
@SearchOnEnclosingElements
@SearchInsideAnnotations
@SearchOnAbstractions
@ProcessorAnnotation(ProcessorField.class)
public @interface Entidade {
	String nome();
}

public class ProcessorField implements ProcessorInterface {

	private String field1;


	@Override
	public void processorInitializationAnnotation(Annotation ann) {
		field1 =((Entidade)ann).nome();
	}


	@Override
	public void returnDados() {
		// TODO Auto-generated method stub
		System.out.println(field1);
	}

}

public class Dominio{
	@Entidade(nome = "nome 1")
	private String field1;
	@Entidade(nome = "nome 2")
	private int field2;
}

public static void main(String args[]) throws Exception {
   Container container = new Container();
   AnnotationReader a1 = new AnnotationReader();
   container = a1.readingAnnotationsTo(Dominio.class, container.getClass());
   container.map.forEach((key, value) -> {
	value.returnDados();
     });
}

Lista de Processors

Nesta seção falaremos sobre os processors, quais as suas funcionalidades e os atributus nescessarios para a a execução dos processors.

Extensão do Metadata Reader

O esquema de anotação da própria API pode ser estendido. Se o framework precisar recuperar um metadados da classe que não é suportada pelas anotações API nativas, novas APIs de leitura de metadados podem ser definidas.

Para criar uma extensão do Metadata Reader é preciso:

Criar uma anotação anotada com @AnnotationReadingConfig() este arquivo vai dizer qual anotação está sendo passado;

Colocar a anotação @ValidFieldType() , esta anotação diz em que tipos ou classes as anotações serão anotadas. Exemplo:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@AnnotationReadingConfig(AllFieldsWithReadingProcessor.class)
@ValidFieldType({List.class, Set.class,Map.class})
public @interface AllFieldsWith {
   Class<? extends Annotation> value();
}							

 Implemente a interface AnnotationReadingProcessor , ele tem essa estrutura:

public interface AnnotationReadingProcessor {
   void initAnnotation(Annotation an, Field field) throws AnnotationValidationException;
   
   void read(AnnotatedElement classWithMetadata, Object container, ContainerTarget enumStr) throws AnnotationReadingException;
}							

Onde a função initAnnotation() é responsável pela inicialização da classe de validação e o read() é responsavel pela leitura das anotações:

Para executar o validador de metadados deve executar os seguintes passos:

• Adicione o import org.esfinge.metadata.AnnotationValidationException, para chamar as exeções de validação do EsfingeMetadata:
• Adicione o import org.esfinge.metadata.validate.MetadataValidator, para declarar que vai utilizar o EsfingeMetadata para validar o seu codigo:
• Instancie o método: MetadataValidator.validateMetadataOn(); para procurar as anotações de validações do EsfingeMetadata, onde o Class<?> é a classe que se deseja validar:

Validação por Convenção de Nome

@MethodNamingConvention(regexNamingConvencion = "^get")
@Retention(RetentionPolicy.RUNTIME)
public @interface OneAnnotationWithMethodNamingConvention {
}

Criaremos uma classe valida usando a anotação criada anteriormente, neste caso vai executar com sucesso pois o metodo começa com o REGEX ^get.

public class NamingConvectionTrue {
   @OneAnnotationWithMethodNamingConvention
   public void getName(){
   }
}

Neste caso, não vai estar correto pois o nome do metodo não contem o REGEX ^get.

public class NamingConvectionFalse {
   @OneAnnotationWithMethodNamingConvention
   public void setName(){
   }
}

public class NamingConvectionTest {
   @Test
   public void NamingConvectionValid() throws AnnotationValidationException {
      MetadataValidator.validateMetadataOn(NamingConvectionTrue.class);
   }
   @Test(expected=AnnotationValidationException.class)
   public void NamingConvectionInvalid() throws AnnotationValidationException {
      MetadataValidator.validateMetadataOn(NamingConvectionFalse.class);
   }
}

Validação por Parâmetros

Em um primeiro momento criaremos uma anotação que tem anotada o @ValidNumbersOfParameters, neste caso o valor é 2.

@ValidNumberOfParameters(numberOfParameters = 2)
@Retention(RetentionPolicy.RUNTIME)
public @interface OneAnnotationWithValidNumberOfParameters {
}

Criaremos uma classe com os numeros parametros validos pela anotação criada anteriormente.

public class ParameterForbidenValid {
   @OneAnnotationWithValidNumberOfParameters
   public double someCalc(double a, double b){
      return Math.pow(( a * b ) * 4.2, 5);
   }
}

Aqui vai ser criada uma classe com os parametros invalidos.

public class ParameterForbidenInvalid {
   @OneAnnotationWithValidNumberOfParameters
   private strictfp double someCalc(double a){
      return Math.pow(( a ) * 4.2, 5);
   }
}

Criaremos o caso de teste para a verificação do uso com anotação valida e anotação invalida.

public class ParameterVisibility {
   @Test
   public void testVisibilityValid() throws AnnotationValidationException {
      MetadataValidator.validateMetadataOn(ParameterForbidenValid.class);
   }

   @Test(expected=AnnotationValidationException.class)
   public void testVisibilityInvalid() throws AnnotationValidationException {
      MetadataValidator.validateMetadataOn(ParameterForbidenInvalid.class);
   }
}

Listas de anotação de validação por parametros.

Validação por Retorno

@ValidMethodReturn(validTypesToReturn = {int.class, Integer.class})
@Retention(RetentionPolicy.RUNTIME)
public @interface OneAnnotationWithValidMethodReturn {
}

Criaremos uma classe com um metodo anotado com a anotação criada anteriormente, neste caso é valido pois está retornando um tipo inteiro.

public class ReturnValid {
   @OneAnnotationWithValidMethodReturn
   public int someCalc(int a, int b){
      return a+b;
   }
}

Criaremos uma classe com um metodo anotado com a anotação criada anteriormente,  neste caso é invalido pois está retornando uma string.

public class ReturnInvalid {
   @OneAnnotationWithValidMethodReturn
   private String someCalc(double a){
      return "INVALID";
   }
}

Aqui a execução do caso de teste, repare que quando se testa o caso invalido ele cai em uma exceção de AnnotationValidationException.

public class ParameterVisibility {
    @Test
   public void testVisibilityValid() throws AnnotationValidationException {
      MetadataValidator.validateMetadataOn(ReturnValid.class);
   }
@Test(expected=AnnotationValidationException.class)
   public void testVisibilityInvalid() throws AnnotationValidationException {
      MetadataValidator.validateMetadataOn(ReturnInvalid.class);
   }
}

@ToValidateProperty(validationClass = UniqueAnnotationValidator.class)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Unique {
}

public interface AnnotationPropertyValidator {
    public void initialize(Annotation self);
    public void validate(Annotation annotationOnElement, AnnotatedElement annotatedWithMainAnnotation, Method annotatedWithValidation, Object annotationPropertyValue) throws AnnotationValidationException;
}

 public class UniqueAnnotationValidator implements AnnotationPropertyValidator {

	private List<Annotation> annotationList = new ArrayList<Annotation>();

	@Override
	public void initialize(Annotation self) {

	}

	@Override
	public void validate(Annotation annotationOnElement,
			AnnotatedElement annotatedWithMainAnnotation,
			Method annotatedWithValidation, Object annotationPropertyValue)
			throws AnnotationValidationException {

		Method[] methods = annotationOnElement.annotationType().getMethods();

		for (Method m : methods) {
			for(Annotation an : m.getAnnotations()){
				if(an instanceof Unique){
					annotationList.add(an);
				}
			}
		}

		if(annotationList.size() > 1){
			throw new
			AnnotationValidationException("The @"+annotationOnElement.annotationType().getSimpleName()+" must have only one field annotated with @Unique!");
		}else if (annotationList.size() == 0 ) {
			throw new AnnotationValidationException("The annotation @"
					+ Unique.class.getSimpleName().toString()
					+ " was not found");
		}
	}
}

Apoio