reflection - Listener on Method.invoke java

Question

Hi, everyone.
I want to add a listener on an invoked method by calling like this :

myClass.myMethod(...);

In runtime, it will be something like :

listenerClass.beforeMethod(...);
myClass.myMethod(...); 
listenerClass.beforeMethod(...);

I wanted to override Method.invoke(...) :

public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    doBefore(...);
    super.invoke(...);
    doAfter(...);
}

Class.java and Method.java are final and I tried with my own ClassLoader. Perhaps a factory or annotation can do the work. Thanks for your answer.

Answer 1

One option is to use Aspect Oriented programming patterns.

In this case you can use a proxy (JDK or CGLIB).

Here's an example with JDK proxies. You'll need an interface

interface MyInterface {
    public void myMethod();
}

class MyClass implements MyInterface {
    public void myMethod() {
        System.out.println("myMethod");
    }
}

...

public static void main(String[] args) throws Exception {
    MyClass myClass = new MyClass();
    MyInterface instance = (MyInterface) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
            new Class<?>[] { MyInterface.class }, new InvocationHandler() {
                MyClass target = myClass;

                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    if (method.getName().equals("myMethod")) { // or some other logic 
                        System.out.println("before");
                        Object returnValue = method.invoke(target, args);
                        System.out.println("after");
                        return returnValue;
                    }
                    return method.invoke(target);
                }
            });
    instance.myMethod();
}

prints

before
myMethod
after

Obviously, there are libraries that do this much better than the above. Take a look at Spring AOP and AspectJ.