Adding Code to an Annotation

Sometimes you have a framework you would like to be able to add custom annotations to. The problem is; how do you define what this custom annotation does. A possible solution is to use a nested enum.

Nested types

You can nest an interface, a class, an annotation or an enum inside any of these types. e.g.

public class A {
    public interface B {
        public enum C {;
            public @interface D {
                public class E {
                    // etc etc
                }
            }
        }
    }
}

But is this useful or just a novelty?

Adding functionality to an annotation

You can define an interface the framework can call to determine how your custom annotation should behave.

import java.lang.reflect.Member;

/**
* @author peter.lawrey
*/
public interface AnnotationHandler<A> {
    void process(Model model, Member member, A annotation);
}

One way of associating the implementation with the annotation itself is to provide a Singleton enum which implements this interface.

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

/**
* @author peter.lawrey
*/
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomAnnotation {
    public int value() default 0;
    
    enum HandlesAnnotation implements AnnotationHandler<CustomAnnotation> {
        INSTANCE;

        @Override
        public void process(Model model, Member member, CustomAnnotation ca) {
            // do something with a model based on the members details and the annotation state.
        }
    }
}

If an annotation could be handled a number of different ways (depending on what process you are performing), you could provide more than one implementation. Using this approach, a framework which uses annotations can allow developers to add custom annotations is a simple manner. The framework can also make it clear how an annotation behaves, making it easier to create annotations which are similar but need to be different in some way.