Come utilizzare annotazioni di tipo personalizzato in Java

Question

Java 8 dispone di funzionalità denominate annotazioni Tipo (JSR 308). Mi piacerebbe usarlo per semplice framework di mappatura Object to Object. Vorrei definire annotazione @ExpectedType come questo

@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE}) 
@Retention(RetentionPolicy.RUNTIME) 
public @interface ExpectedType { 
    public Class<?> value(); 
} 

e poi utilizzarlo nel mio codice come questo:

public class SomeServiceImpl() { 
    public @ExpectedType(ObjectA_DTO.class) IObjectA doSomething(@ExpectedType(ObjectA_Entity.class) IObjectA obj) { 
     return (ObjectA_Entity) obj; // it's correct 
    } 
} 

IObjectA è un'interfaccia implementata da classi ObjectA_DTO e ObjectA_Entity. Il servizio Vorrei utilizzare in questo modo:

// it's correct 
assert someService.doSomething(new ObjectA_DTO()).getClass() == ObjectA_DTO.class; 

Vorrei cambiamento richiamo di metodi SomeServiceImpl usare mapper oggetto. Potrebbe essere ottenuto con il codice generato utilizzando JSR 269 o tramite AOP.

Il problema è che ho scritto un semplice processore di annotazioni e non gestisce affatto le annotazioni di tipo. La fonte di semplice elaboratore di annotazioni assomiglia a questo:

@SupportedAnnotationTypes("*") 
@SupportedSourceVersion(SourceVersion.RELEASE_8) 
public class SimpleAnnotationsProcessor extends AbstractProcessor { 

    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { 
     Messager messager = processingEnv.getMessager(); 
     try { 
      for (TypeElement e : annotations) { 
       messager.printMessage(Diagnostic.Kind.NOTE, e.toString()); 
       for (Element elem : roundEnv.getElementsAnnotatedWith(e)) { 
        messager.printMessage(Diagnostic.Kind.NOTE, elem.toString()); 
       } 
      } 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
     return true; 
    } 
} 

Delle idee come utilizzare o come accedere annotazioni di tipo da SimpleAnnotationsProcessor? L'utilizzo dell'API di elaborazione di annotazioni innestabili non è necessario per me, penso che avrebbe prestazioni migliori rispetto alla riflessione Java. Ad ogni modo non so come accedere all'annotazione del tipo tramite Java Reflection.

Answer 1

io non sono sicuro di capire che cosa si prova a raggiungere, ma qui è un esempio di come è possibile accedere alle annotazioni con il Java API Reflection:

package test; 

import java.lang.annotation.Annotation; 
import java.lang.annotation.ElementType; 
import java.lang.annotation.Retention; 
import java.lang.annotation.RetentionPolicy; 
import java.lang.annotation.Target; 
import java.lang.reflect.AnnotatedType; 
import java.lang.reflect.Method; 

public class TypeParameterTest { 

    @Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE}) 
    @Retention(RetentionPolicy.RUNTIME) 
    public @interface ExpectedType { 
     public Class<?> value(); 
    } 

    public static interface IObjectA {} 

    public static class ObjectA_DTO implements IObjectA {} 

    public static class ObjectA_Entity implements IObjectA {} 

    public static class SomeServiceImpl { 
     public @ExpectedType(ObjectA_DTO.class) IObjectA doSomething(@ExpectedType(ObjectA_Entity.class) IObjectA obj) { 
      return (ObjectA_Entity) obj; 
     } 
    } 

    public static void main(String[] args) throws NoSuchMethodException, SecurityException { 
     Method m = SomeServiceImpl.class.getMethod("doSomething", IObjectA.class); 
     AnnotatedType returnType = m.getAnnotatedReturnType(); 
     Annotation returnTypeAnnotation = returnType.getAnnotation(ExpectedType.class); 
     System.out.println(returnTypeAnnotation); 

     AnnotatedType[] parameters = m.getAnnotatedParameterTypes(); 
     for (AnnotatedType p : parameters) { 
      Annotation parameterAnnotation = p.getAnnotation(ExpectedType.class); 
      System.out.println(parameterAnnotation); 
     } 
    } 
} 

L'output è simile al seguente:

@test.TypeParameterTest$ExpectedType(value=class test.TypeParameterTest$ObjectA_DTO) 
@test.TypeParameterTest$ExpectedType(value=class test.TypeParameterTest$ObjectA_Entity) 

Nota, tuttavia, non tutte le annotazioni di tipo possibile sono accessibili tramite la reflection api, ma è sempre possibile leggerle dal codice byte se necessario (vedere la risposta here).

Answer 2

Penso che stai mescolando l'uso delle annotazioni in fase di esecuzione rispetto all'uso delle stesse in fase di "compilazione" con vari strumenti. L'interfaccia Processor può essere utilizzata negli strumenti (compilatore, generatore javadoc), non nel codice di runtime.

Answer 3

@Documented 
@Retention(RetentionPolicy.RUNTIME) 
@Target(ElementType.FIELD) 
public @interface SearchDefinition { 

    public String identifier() default ""; 

} 

@SearchDefinition - può essere utilizzato ovunque