Java reflection nested methods not modifying underlying object

I am taking in an array of methods and I want to chain them together to modify an object that I am working in.

For example I start with

"getStuff().get(1).get(3).setMoreStuff().put(stuff,6)"

I split it into an array called methods, and clean up the parameters inside each method and I try to modify this.

Object res = this;
String[] methods = targetString.split("\\.(?=\\D)");
for (String m : methods){

    List<Object> params = new ArrayList<Object>();
    List<Object> params = new ArrayList<Object>();

                    for (String p : m.split("\\(|,|\\)")) {
                        try {
                            if (p.indexOf(".") != -1){
                                double tempD = Double.parseDouble(p);
                                params.add(tempD);
                            } else {
                                int tempP = Integer.parseInt(p);
                                params.add(tempP);
                            }
                        } catch (Exception ex) { //not a number
                            params.add(p);
                        }
                    }
    switch (params.size()) {
        case 1:
            res = res.getClass().getMethod(
                            params.get(0)
                                   ).invoke(res);
            break;
        case 2:
            res = res.getClass().getMethod(
                            params.get(0),
                            params.get(1).getClass()
                                   ).invoke(res, params.get(1));
            break;
        case 3:
            res = res.getClass().getMethod(
                            params.get(0), 
                            params.get(1).getClass(),           
                            params.get(2).getClass()
                                   ).invoke(res, params.get(1), params.get(2));
                                break; 
    }

in the end I notice that res has been modified the way that I expect. All the getters and setters are called correctly. But of course the underlying object "this" refers to has not been changed!

I guess I'm just calling the getters and setters of the copy I made in the first line!

now I can't just use

this.getClass().getMethod(...).invoke(...)

because I need to call the same getMethod on the object returned by this call.

To clarify:

Object res = this;

creates a "pointer" to this. So that when I call

res.getStuff().setStuff(foo)

this will also be modified.

but it seem that when I call

res = res.getStuff();
res = res.setStuff();

like I do in my loop, this does not modify the underlying object this refers to?

Edit: Included more code as per request.

Edit2: added anther example, to clarify my problem.

Edit3: tried to add more code, its a bit hard to add a working program without including every class

Jon Skeet
people
quotationmark

Your general approach should be fine (although your approach to parameter conversion is somewhat ugly) - it's the specifics that are presumably causing you problems. Here's a short but complete program demonstrating calling methods and then seeing the difference afterwards:

import java.lang.reflect.*;

class Person {
    private String name = "default";

    public String getName() {
        return name;
    }

    // Obviously this would normally take a parameter
    public void setName() {
        name = "name has been set";
    }
}

class Test {

    private Person person = new Person();

    public Person getPerson() {
        return person;
    }

    // Note that we're only declaring throws Exception for convenience
    // here - diagnostic code only, *not* production code!
    public void callMethods(String... methodNames) throws Exception {
        Object res = this;
        for (String methodName : methodNames) {
            Method method = res.getClass().getMethod(methodName);
            res = method.invoke(res);
        }
    }

    public static void main(String[] args) throws Exception {
        Test test = new Test();
        test.callMethods("getPerson", "setName");
        System.out.println(test.getPerson().getName());
    }
}

The output is "name has been set" just as I'd expect. So see if you can simplify your code bit by bit, removing extra dependencies etc until you've got something similarly short but complete, but which doesn't work. I suspect you'll actually find the problem as you go.

people

See more on this question at Stackoverflow