带注释的方法之后，可以使用注释来调用方法吗？

Question

I am wondering if I can use custom annotation to call some method right after annotated one. For example I have a class that holds some settings that can also notify objects that something has changed (for example user changed something in settings panel). Not all listeners are interested in all types of events, so MyEvent is enum. Now I have structure like this:

class Settings
{
    private ArrayList<Listeners> listeners;

    private void notifyListeners(MyEvent e)
    {
        // notify all listeners that something was changed
    }

    public void setSomeOption(int value)
    {
        // validate parameter, store it etc.
       notifyListeners(MyEvent.SOME_INTEGER_SETTING_CHANGED);
    }
}

Of course listening object has to check type of event and ignore it or perform some action, but it is not the case here.

I am interested if I can achieve this with annotations, like this

@NotifyAnnotation(MyEvent.SOME_INTEGER_SETTING_CHANGED)
public void setSomeOption(int value)
{
    // validate parameter, store it etc.
    // NO NEED TO CALL NOTIFY HERE - WILL BE HANDLED BY ANNOTATION
}

In JUnit for example, we have @Before or @After annotations, and I am wondering if JUnit has own annotations parser that handles method annotated this way, or this kind of behavior can be done simpler, since annotations can be @Retention(value=RUNTIME) .

I know that in this example it might look over-complicated and calling notifyListeners() is much simper, but I wan't to know if annotation can be used the way I described, and if yes, can i get some tips? I don't expect ready solution, just a hint if this is possible and what should I take in consideration.

Answer 1

In annotations you need a class that checks for it. they don't work on themselves. The way systems check for them are with reflection.

Annotation<NotifyAnnotation> a = method.getAnnotation();

And explicitly call their methods

a.notifyListeners(a.evt);

I can't see any advantage with your case. but I see full of disadvantages. They should not be used in actual coding, just for test systems or similar scenarios, where an external system has control on your class.

Answer 2

yes, you can do it but you have to use a framework or write one by yourself. you can use for example spring aspects and @After advice (or any other proxy mechanism). you can also use full aspectj for this. another option is to write it by yourself using reflection api. in last case you will need some kind of inversion of control - some mechanism that will launch your method and then the other method

Answer 3

It could be do that using bytecode manipulation (JAssist, Asm, Java Rocks ...). All the classes would be instantiated thru a Factory that would identify annotated methods and would inject in the first line of this method a call to the method specified in its annotation.