Sposób korzystania z adnotacji typu niestandardowego w Javie

Question

Java 8 ma funkcję o nazwie Adnotacje typu (JSR 308). Chciałbym użyć go do prostego systemu mapowania obiektów do obiektu. Chciałbym określić adnotacji @ExpectedType jak ten

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

a następnie używać go w moim kodu tak:

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

IObjectA jest realizowany przez interfejs klas ObjectA_DTO i ObjectA_Entity. Usługa Chciałbym wykorzystać ten sposób:

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

chciałbym zmiana połączenia metod SomeServiceImpl użyć mapowania obiektów. Można to osiągnąć za pomocą wygenerowanego kodu przy użyciu JSR 269 lub AOP.

Problem polega na tym, że napisałem prosty procesor adnotacji i w ogóle nie obsługuję adnotacji typu. Źródłem prosty procesor adnotacji wygląda następująco:

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

pomysłów jak wykorzystać lub uzyskiwania dostępu typu adnotacji przez SimpleAnnotationsProcessor? Używanie Pluggable Adnotation Processing API nie jest dla mnie konieczne, myślę, że miałoby lepszą wydajność niż odbicie Java. W każdym razie nie wiem jak uzyskać dostęp do adnotacji typu za pomocą Java Reflection.

Answer 1

Nie jestem pewien, czy rozumiem co próbujesz osiągnąć, ale tutaj jest przykładem, w jaki sposób można uzyskać dostęp do notatek z refleksji Java API:

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

Wyjście wygląda następująco:

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

Pamiętaj, że nie wszystkie możliwe adnotacje typu są dostępne za pośrednictwem api odbicia, ale zawsze możesz je odczytać z kodu bajtowego, jeśli to konieczne (zobacz moją odpowiedź: here).

Answer 2

Myślę, że mieszasz użycie adnotacji w czasie wykonywania w porównaniu do użycia tego samego w czasie "kompilacji" przez różne narzędzia. Processor Interfejs jest przeznaczony do użycia w narzędziach (kompilator, generator javadoc), a nie w kodzie środowiska wykonawczego.

Answer 3

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

    public String identifier() default ""; 

} 

@SearchDefinition - może być stosowany wszędzie