C'è un modo per passare un'annotazione Java come parametro?

Question

Ragazzi c'è un modo per passare un'annotazione come parametro diretto (piuttosto facendo tutto il sovraccarico di riflessione)? Per esempio nel codice seguente, ho un numero di annotazione che contiene un valore int, voglio passare come parametro al metodo addImpl, come posso farlo (oltre che per riflessione)?

Snippet di codice:

@Retention(RetentionPolicy.RUNTIME) 
@Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD}) 
public @interface Number { 
    int value(); 
} 

public void add(int x2) { 
    addImpl(@Number(value = 10) lol, x2); 
} 

public void addImpl(Number a, int b) { 
    System.out.println(a.value() + b); 
} 

public static void main(String[] args) { 
    new TestClass().add(3); 
} 

Answer 1

Sì, è possibile passare in giro per le annotazioni come questo (proprio come se fossero normali interfacce).

L'unica cosa che non si può fare è creare istanze di tale interfaccia in fase di runtime. Puoi solo prendere annotazioni esistenti e passarle in giro.

import java.lang.annotation.*; 

public class Example { 

    @Retention(RetentionPolicy.RUNTIME) 
    @Target(ElementType.METHOD) 
    public static @interface Number { 
     int value(); 
    } 

    @Number(value = 42) 
    public int adder(final int b) throws SecurityException, NoSuchMethodException { 
     Number number = getClass().getMethod("adder", int.class).getAnnotation(Number.class); 
     return addImpl(number, b); 
    } 

    public int addImpl(final Number a, final int b) { 
     return a.value() + b; 
    } 

    public static void main(final String[] args) throws SecurityException, NoSuchMethodException { 
     System.out.println(new Example().adder(0)); 
    } 
} 

Answer 2

Al meglio della mia conoscenza, non esiste una cosa come un "annotazione letterale", come si desidera utilizzare nel vostro add implementazione.

Penso che la cosa più vicina a questo sarebbe dichiarare il metodo per prendere un parametro di tipo java.lang.annotation.Annotation - ma poi avresti ancora bisogno di ottenere quelle istanze tramite riflessione dagli oggetti classe/metodo.

Answer 3

Si può fare come:

public void add(int x2) { 
    addImpl(new Number() { 

     @Override 
     public int value() { 
      return 10; 
     } 

     @Override 
     public Class<? extends Annotation> annotationType() { 
      return Number.class; 
     } 
    }, x2); 
} 

Dal numero è fondamentalmente un'interfaccia, è necessario creare un'istanza di una classe anonima che implementa tale interfaccia, e passare che per il metodo.

Anche se il motivo per cui vuoi farlo è oltre me. Se devi passare un valore a qualcosa, dovresti davvero usare una classe.

Answer 4

Il numero è anche una buona interfaccia precedente, è possibile implementare una classe concreta.

Ragazzi, questo è utile. Mentre un modulo si occupa principalmente di annotazioni che sono fissate in fase di compilazione, a volte abbiamo bisogno di alimentarle altre informazioni ottenute in fase di runtime da altre fonti (come xml, gush!) Possiamo sovra-progettare la cosa, oppure possiamo semplicemente creare un runtime oggetto del tipo di annotaion.

Answer 5

Se è necessario passare l'annotazione nel test, è possibile crearne uno. Per esempio prova della JSR 303 validatore potrebbe assomigliare a questo:

public void test() { 
    final TextLengthValidator validator = new TextLengthValidator(); 
    validator.initialize(mock(TextLength.class)); 
    final boolean valid = validator.isValid("some text", mock(ConstraintValidatorContext.class)); 
    assertThat(valid, is(true)); 
}