Java Reflection

I have a java method which is supposed to compute some thing and return it back as a string using all of the information available from its arguments. The number of arguments may vary. Basically, the method should act like a variable-arg method like the way it can be done in C/C++. As we do not have variable-arg. facility in Java, one possible solution could be using an array of strings or something that would simulate variable-arguments. This would be work out fine in a normal scenario. But, I am calling this method using Reflection. You can think that I have a generic method calling mechanism as part of an XML file. The XML file contains the method name, arguments etc. and using reflection, I am loading the appropriate method and calling it. The problem is, I cannot build an array of strings to be passed as variable arguments to the method.
Let me put it through an example:
Method in a called called company.MyClass
public static String myMethod(variable args ...) {
// compute from the arguments and return a string
}
XML file:<method>company.MyClass::myMethod::hello::String::10::Integer</method>
Here, my application would call myMethod with "hello" and 10 as arguments. I want these arguments to be variable. ie., I want both these XML snippets to work:
<method>company.MyClass::myMethod::hello::String::first::String</method>
<method>company.MyClass::myMethod::hello::String::firstr:String::secong::String</method>
Remember that I am calling the method using reflection and so, I cannot build a string array in runtime because there are other methods which do not take String[] as arguments.
Hope I got the problem clear.
Any suggestions how to do this??
Thanks
Zooey

Hello, Zooey, and welcome to JavaRanch.
I can think of a couple of ways of doing this; a slight modification of your XML data might be in order.
public void methodCall(String methodInfo){ String[] methodInfoArray = methodInfo.split("::"); if(methodInfoArray.length < 2 || methodInfoArray.length % 2 != 0){ //Error; not enough info throw new IllegalArgumentException("Invalid method format: It must contain at least the class name and method name, and may have parameter value/type pairs"); } String className = methodInfoArray[0]; String methodName = methodInfoArray[1]; java.util.List valueList = new java.util.ArrayList(); java.util.List typeList = new java.util.ArrayList(); for(int index = 2; index < methodInfoArray.length; index += 2){ String parameterValue = methodInfoArray[index]; String parameterTypeString = methodInfoArray[index+1]; Class parameterType = null; //Note that this will not work for primitive types //Other, more annoying, solutions are needed. if(parameterTypeString.endsWith("[]"){ String arrayTypeString = parameterTypeString.substring(0, parameterTypeString.length()-2); Class arrayType = Class.forName(arrayTypeString); Object tempArrayInstance = java.lang.reflect.Array.newInstance(arrayType, 0); parameterType = tempArrayInstance.getClass(); valueList.add(parameterValue.split(",")); } else{ parameterType = Class.forName(parameterTypeString); //Translate the parameter value to the appropriate type, then //add to the array. We will jsut use the strings for now valueList.add(parameterValue); } //Now, convert the typeList and the valueList to arrays typeArray = (Class[])typeList.toArray(new Class[]{}); paramArray = parameterList.toArray(); //And use Reflection to invoke it Class destClass = Class.forName(className); Object anObject = destClass.newInstance(); Method aMethod = destClass.getMethod(methodName, typeArray); Object result = aMethod.invoke(anObject, paramArray); }
Note that this would change your XML code to something like the following:
<method>company.MyClass::myMethod::hello::String::10::Integer</method>
(calls myMethod("hello", 10))
<method>company.MyClass::myMethod::hello::String::first::String</method>
(calls myMethod("hello", "first"))
<method>company.MyClass::myMethod::hello,first::String[]</method>
(calls myMethod(new String[]{"hello", "first"}))
<method>company.MyClass::myMethod::hello, first, second::String[]</method>
(calls myMethod(new String[]{"hello", "first", "second"}))
=============
Also, as an aside, you may want to consider breaking your XML method element down into several sub-elements; it may look convenient to insert your own formatting mechanism, but in the long run, it would probably be more hassle than it is worth. Try:
<method>
<className>company.MyClass</className>
<methodName>myMethod</methodName>
<parameter>
<type>java.lang.String[]</type>
<value>hello</value>
<value>first</value>
</parameter>
</method>
and the like. Of course, this is just my suggestion