CODEWITHSUNDEEP
javaannotations
Kuba
Kuba

Reputation: 839

Can I use annotation to call method after the annotated one?

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.

Upvotes: 0

Views: 2398

Answers (3)

VeryNiceArgumentException
VeryNiceArgumentException

Reputation: 2056

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.

Upvotes: 0

Mordechai
Mordechai

Reputation: 16234

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.

Upvotes: 1

piotrek
piotrek

Reputation: 14530

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

Upvotes: 1

Related Questions