How to check if a parameter of the current method has an annotation and retrieve that parameter value in Java?

Question

Consider this code:

public example(String s, int i, @Foo Bar bar) {
  /* ... */
}

I want to check if the method has an annotation @Foo and get the argument or throw an exception if no @Foo annotation is found.

My current approach is to first get the current method and then iterate through the parameter annotations:

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

class Util {

    private Method getCurrentMethod() {
        try {
            final StackTraceElement[] stes = Thread.currentThread().getStackTrace();
            final StackTraceElement ste = stes[stes.length - 1];
            final String methodName = ste.getMethodName();
            final String className = ste.getClassName();   
            final Class<?> currentClass = Class.forName(className);
            return currentClass.getDeclaredMethod(methodName);
        } catch (Exception cause) {
            throw new UnsupportedOperationException(cause);
        }  
    }

    private Object getArgumentFromMethodWithAnnotation(Method method, Class<?> annotation) {
        final Annotation[][] paramAnnotations = method.getParameterAnnotations();    
            for (Annotation[] annotations : paramAnnotations) {
                for (Annotation an : annotations) {
                    /* ... */
                }
            }
    }

}

Is this the right approach or is there a better one? How would the code inside the forach loop look like? I'm not sure if I have understood the what getParameterAnnotations actually returns...

I don't see anything wrong with you have already – skaffman Aug 29 '11 at 10:09 — skaffman, Aug 29 '11 at 10:09
+1 for not doing `new Exception().getStackTrace()` – Cephalopod Aug 29 '11 at 11:11 — Cephalopod, Aug 29 '11 at 11:11

score 8 · Accepted Answer · answered Aug 29 '11 at 11:08

The outer for loop

for (Annotation[] annotations : paramAnnotations) {
   ...
}

should use an explicit counter, otherwise you don't know what parameter you are processing right now

final Annotation[][] paramAnnotations = method.getParameterAnnotations();
final Class[] paramTypes = method.getParameterTypes();
for (int i = 0; i < paramAnnotations.length; i++) {
    for (Annotation a: paramAnnotations[i]) {
        if (a instanceof Foo) {
            System.out.println(String.format("parameter %d with type %s is annotated with @Foo", i, paramTypes[i]);
        }
    }
}

Also make sure your annotation type is annotated with @Retention(RetentionPolicy.RUNTIME)

From your question it is not entirely clear what you are trying to do. We agree on the difference of formal parameters vs. actual arguments:

void foo(int x) { }

{ foo(3); }

where x is a parameter and 3 is an argument?

It is not possible to get the arguments of methods via reflection. If it is possible at all, you would have to use the sun.unsafe package. I can't tell you much about that though.

Yes, I want to get the actual argument which is annotated with `@Foo`. — soc, Aug 29 '11 at 12:06
You should create an explicit question for that, as it gets lost between the (unrelated) annotation stuff. — Cephalopod, Aug 29 '11 at 12:11

Don Roby · Answer 2 · 2011-08-29T10:22:37.283

If you're looking for annotations on the method, you probably want method.getAnnotations() or method.getDeclaredAnnotations().

The method.getParameterAnnotations() call gives you annotations on the method's formal parameters, not on the method itself.

Looking back at the question title, I suspect you are looking for annotations on the parameters, which I didn't read in the content of the question. If that's the case, your code looks fine.

See Method Javadoc and AnnotatedElement Javadoc.

kapex · Answer 3 · 2013-09-12T00:20:36.360

getParameterAnnotations returns an array with the length equals to the amount of method parameters. Each element in that array contains an array of annotations on that parameter.
So getParameterAnnotations()[2][0] contains the first ([0]) annotation of the third ([2]) parameter.

If you only need to check if at least one parameter contains an annotation of a specific type, the method could look like this:

private boolean isAnyParameterAnnotated(Method method, Class<?> annotationType) {
    final Annotation[][] paramAnnotations = method.getParameterAnnotations();    
    for (Annotation[] annotations : paramAnnotations) {
        for (Annotation an : annotations) {
            if(an.annotationType().equals(annotationType)) {
                return true;
            }
        }
    }
    return false;
}

How to check if a parameter of the current method has an annotation and retrieve that parameter value in Java?

3 Answers3

Linked