Dynamic variables with given type

I have written a small class, which reads out annotation from methods.

Now I want to extend that class to make it more dynamic.

My class uses at the moment following code for reading out the annotation:

ExtendedComman开发者_运维技巧dAnnotation e = foo.getClass()
                                 .getAnnotation(ExtendedCommandAnnotation.class);
String startTag = e.annoPropStartTag();

That is the simple case with fixed annotation.

In the new version I haven't any fixed annotation. I will get the annotation 'ExtendedCommandAnnotation' in a variable.

So the code above will be edited to:

String className= "ExtendedCommandAnnotation";
??? e = foo.getClass().getAnnotation(Class.forName(className));
String startTag = e.annoPropStartTag();

I don't know what I shall put instead of the ???. I tried it with Annotation, but then I can't get the properties with the defined methods.

Is there any way to get this working?

My annotation "class":

@Retention( RetentionPolicy.RUNTIME )
public @interface ExtendedCommandAnnotation
{
    String   annoPropUseTab() default "0";
    String   annoPropStartTag() default "";
    String   annoPropEndTag() default "";
}

EDIT:

Finally I get something like that: String[] cmdMethNames = this.getAvailableCommandNames();

    Class<?> annotationClass = Class.forName(this.annotationClassName); 

    for( Method meth : cmdMeth )
    {
        HashMap<String, String> tempAnno = new HashMap<String, String>();
        if (meth.isAnnotationPresent((Class<? extends Annotation>) annotationClass))
        {
            Annotation anno = meth.getAnnotation((Class<? extends Annotation>) annotationClass);
            [...]
        }
        [...]
    }

But the cast to (Class<? extends Annotation>) make following warning: "Type safety: Unchecked cast from Class< capture#4-of ? > to Class< ? extends Annotation >"

If you don't know the annotation in advance, you can't know that it's got an annoPropStartTag() method, can you? So you can't tell the compiler how to bind to that method...

If you want to basically find a method with that name at execution time, you'll currently need to use reflection.

You might want to consider having some sort of "base" annotation type which contains all the methods you need in the general case, and then derive all the other annotation types from that.

/* Foo.java */

@ExtendedCommandAnnotation(annoPropStartTag = "hello")
public class Foo {
}

/* ExtendedCommandAnnotation.java */

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention( RetentionPolicy.RUNTIME )
public @interface ExtendedCommandAnnotation {
    String annoPropUseTab() default "0";
    String annoPropStartTag() default "";
    String annoPropEndTag() default "";
}

/* Main.java */

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

public class Main {
    public static void main(String[] args) {
        doOriginalImplementation();     // Prints "hello"
        doReflectionImplementation();   // Prints "hello"
    }

    public static void doOriginalImplementation() {
        Foo foo = new Foo();
        ExtendedCommandAnnotation e = foo.getClass().getAnnotation(ExtendedCommandAnnotation.class);
        String startTag = e.annoPropStartTag();
        System.out.println(startTag);
    }

    public static void doReflectionImplementation() {
        Foo foo = new Foo();

        Annotation[] annotations = foo.getClass().getAnnotations();
        // or the statement below, depends on what you intent to do:
        // Annotation[] annotations = foo.getClass().getDeclaredAnnotations();

        Class classOfExtendedCommandAnnotation = null;
        Annotation annotationOnClassFoo = null;
        for (Annotation a : annotations) {
            Class classA = a.annotationType();
            if ("ExtendedCommandAnnotation".equals(classA.getName())) {
                classOfExtendedCommandAnnotation = classA;
                annotationOnClassFoo = a;
                break;
            }
        }

        Method methodAnnoPropStartTag = null;
        if (classOfExtendedCommandAnnotation != null) {
            try {
                methodAnnoPropStartTag = classOfExtendedCommandAnnotation.getMethod("annoPropStartTag");
            } catch (NoSuchMethodException e) {
                throw new RuntimeException(e);
            }
        }

        if (methodAnnoPropStartTag != null) {
            try {
                String startTag = (String) methodAnnoPropStartTag.invoke(annotationOnClassFoo);
                System.out.println(startTag);
            } catch (ClassCastException e) {
                throw new RuntimeException(e);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            } catch (IllegalArgumentException e) {
                throw new RuntimeException(e);
            } catch (InvocationTargetException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

In my solution, the class ExtendedCommandAnnotation need not to be present at compile time. However, the class Foo must be present. The solution could be modified a little bit so that the class Foo need not to be present too.