Question

I would like to understand what might be going on with invoking variable-arity methods using Java reflection. Let’s say we have a simple method:

void doAllTheThings(Object ... things) {
  // ...which does something with all the things...
}

And we want to invoke it dynamically, so we grab the method through reflection:

Method doItAll = Superklass.getDeclaredMethod("doAllTheThings", Object[].class);

And pass in an array:

Object[] allTheThings = new Object[] { "abc", true, 15 };
doItAll.invoke(allTheThings);

Now, this doesn’t seem to work quite like my intuition had figured; in particular, I seem to be getting various shades of IllegalArgumentException when I try invoking a method with varargs like this.

There’s clearly something I’m missing here. My guess is this is related somehow to how the variables get marshalled into the varargs. I’ve found this four year old blog post which seems to be talking about the same issue, but am unable to reproduce the ‘successful’ case there. Any thoughts on what might be going on here?

Answer 1

You need to pass in an Object[][] in this case:

Object[] allTheThings = new Object[] { "abc", true, 15 };
doItAll.invoke(o, new Object[]{allTheThings});

The reason is that the single things parameter is converted by the compiler into a single parameter of type Object[], and invoke takes an array with the values of the parameters.

Consider a method with more parameters to make it clearer:

void doMoreThings(Foo bar, Object ... things) { ... }

Object[] allTheThings = new Object[] { "abc", true, 15 };
doMore.invoke(o, new Object[]{new Foo(), allTheThings});

invoke is itself declared to take varargs, so you can let the compiler create the outer array for you. But it won’t do this if you pass an Object[], because it thinks you already did that. So just hide that fact from the compiler:

doItAll.invoke(o, (Object)allTheThings);
doMore.invoke(o, new Foo(), allTheThings);

Note the cast in the first line, now the compiler does not now anymore that there is already an array, so it creates one. In the second line this is not needed, because the compiler has no other chance anyway.

Edit:
Note that your code does not even compile because you missed to pass an instance of the class with the doAllTheThings method to invoke (I named it o in my code).