Reflective Annotation Processing

Question

Hi there,
I am using annotations to annotate methods in classes to indicate that they are accessors for some property. Here's an example:
  An enum that defines what type of accessor a method is.
public enum AccessorType {
  GET, SET ;
}And then the annotation definition
   An annotation to indicate that the target method is an accessor for this property.
@Target(ElementType.METHOD)
@Inherited // btw, I am not sure if this inheritance works on targets of ElementType.METHOD.
@Retention(RetentionPolicy.RUNTIME)
public @interface ColorProperty {
  AccessorType value();
}And an example usage:
public class Thing {
private Color _color ;
@ColorProperty(AccessorType.GET)
public Color getColor() {
   return this.color ;
@ColorProperty(AccessorType.SET)
public void setColor(Color color) {
       this._color = color ;
}Such a way of using annotations allows me to properly encapsulate, so I prefer it to simply annotating fields and bypassing the security manager (using Field.setAccessible...). (This also makes using AspectJ for interception simple.)
The application code is supposed to process instances of objects in response to events on a GUI and create appropriate property editors by looking up a widget registry that is basically a Map<Annotation, Widget>. It does this by reflectively examining the methods of each object passed to it, pulling out the methods which have been annotated and binding the appropriate methods to the appropriate widgets. In the above example, this would mean that the engine would create a JColorChooser and bind it to the setColor method of this class.
Now my question: Currently, the only way to do this processing is to get all the methods of the target class, examine each method to see if it has the annotation. I have to do this for each property that is registered in the widget registry because all such properties need to be editable. Is there a way to do something like this:
annotation.getTarget(ElementType elementType)which would return the element which has been annotated using the specified annotation and is of the specified ElementType (and maybe null if there is no match)? Or is repeated iteration the only way to do this? Also, are there data on performance for this sort of reflection and/or annotation available somewhere?

Answer 1

Yes, that's basically what I ended up with a slight difference. I use type() to specify the type of the object that the method accepts in the set method and returns in the get method. As far as I know, there's no way to get a particular method from a class only by its name (is there?). So I can use type information from the annotation to retrieve the correct method without looping through all the methods of this class.
So the Property annotation looks like this:
public @interface Property {
  String name() default "Property" ;
  Class<?> valueType() default Object.class ;
  String getter() default "getProperty()" ;
  String setter() default "setProperty()" ;
}Its used like this:
@Properties({
   @Property(name="Color", valueType=Color.class, setter="setColor", getter="getColor"),
   @Property(name="Width", valueType=double.class, setter="setWidth", getter="getWidth")
public class Thing {
}And processed like this:
Properties propertiesAnnotation = thing.getClass().getAnnotation(Properties.class);
Property[] properties = propertiesAnnotation.value();
for (Property prop : properties) {
     Class<?> c = prop.type();
     Method getMethod = thing.getClass().getMethod(prop.getter(),new Class[0]);
     Method setMethod(thing.getClass().getMethod(prop.setter(),new Class[] { c });
}There is obviously still some convention I am relying upon, like the fact that accessors will have the form I expect them to be here, but that's no big deal.
Thanks for your solution.