How to change method behaviour through reflection?

Question

I have a a static method in some legacy code, which is called by multiple clients. I obviously have no options to override it, or change behaviour through dependency injection. I am not allowed to modify the existing class.

What I want to do now is change the behaviour (that method - with the same signature and return type) using reflection.

Is it possible ? If not, can any design pattern rescue me ?

Thanks !

EDIT : There is some confusion on what can I change/modify. I cannot change any existing class/method - but I can add more classes to the project. The best I can do with the existing classes is annotate them. This is all done to avoid breaking anything in the existing code - which means a complete round of testing for a big project.

EDIT 2 : java.lang.Instrumentation is not available for Android - or else it sounds like a good fit !

Answer 1

Sounds like a weird requirement...

Anyway, reflection does not allow you to change code behaviour, it can only explore current code, invoke methods and constuctors, change fields values, that kind of things.

If you want to actually change the behaviour of a method you would have to use a bytecode manipulation library such as ASM. But this will not be very easy, probably not a good idea...

Patterns that might help you :

• If the class is not final and you can modify the clients, extend the existing class and overload the method, with your desired behaviour. Edit : that would work only if the method were not static !
• Aspect programming : add interceptors to the method using AspectJ

Anyway, the most logical thing to do would be to find a way to modify the existing class, work-arounds will just make your code more complicated and harder to maintain.

Good luck.

Answer 2

I guess you could have a look at Instrumentation class which have a method redefineClasses(ClassDefintion classDefinition).

The redefinition may change method bodies, the constant pool and attributes. The redefinition must not add, remove or rename fields or methods, change the signatures of methods, or change inheritance.

Hope this helps.

References: Javadoc

Answer 3

You can change method behaviour via Java's dynamic proxies mechanism. See this guide. It will proxied all object methods. You can redefine only some methods by method name, like:

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    if (method.getName().equals("put")) { // example for map
        methods.get(method.getName()).invoke(target, args);
        args[0] = "second"; // put again with "second" key
        Object result = methods.get(method.getName()).invoke(target, args);

        return result;
    }

    if (method.getName().equals("get")) { // example for map
        System.out.println("Method get");  // you implementation
        return methods.get(method.getName()).invoke(target, args);
    }

    return methods.get(method.getName()).invoke(target, args); // just do what initial method do
}