Question

I want to use

Class.getMethod(String name, Class... parameterTypes)

to find the method I need to invoke with the given parameters, but apparently as described in Bug 6176992 Java doesn’t include autoboxing there. So if my reflected class has a method with a (String, int) signature you still get a NoSuchMethodException with a {String.class, Integer.class} array as a paremeter.

Is there any sollution for this? The only way I could think of to call getMethod() with every permutation of primitive and non primitive types which I don’t really want to do.

Edit: To make it more clear: I am well aware of the primitive type classes, but I don’t see how they could help to solve my problem. My parameterTypes array comes from somewhere and I know that it will only return non primitive types. I can not assume that the interface will only be declared with primitive types and that’s exactly my problem:

public interface TestInterface()
{
    public void doTest(Integer i1, int i2, double d3, Double d);
}

Class<?>[] classes = { Integer.class, Integer.class, Double.class, Double.class }
// Due to autoboxing I should become the doTest method here, but it doesn't work
TestInterface.class.getMethod("doTest", classes);

Answer 1

As @Stephen C mentions, your only hope is to do the search yourself. All of his caveats hold but I’d argue a little flexibility would go a long way to covering most of the gotchas as long as the callers were aware of the caveats… versus making your callers always be painfully specific.

For code that actually does something like this you can look here:
http://meta-jb.svn.sourceforge.net/viewvc/meta-jb/trunk/dev/src/main/java/org/progeeks/util/MethodIndex.java?revision=3811&view=markup

The findMethod() call is the entry point but it delegates (after some caching, etc.) to this method:

private Method searchForMethod( String name, Class[] parms ) {
    Method[] methods = type.getMethods();
    for( int i = 0; i < methods.length; i++ ) {
        // Has to be named the same of course.
        if( !methods[i].getName().equals( name ) )
            continue;

        Class[] types = methods[i].getParameterTypes();

        // Does it have the same number of arguments that we're looking for.
        if( types.length != parms.length )
            continue;

        // Check for type compatibility
        if( InspectionUtils.areTypesCompatible( types, parms ) )
            return methods[i];
        }
    return null;
}

InspectionUtils.areTypesCompatible() takes two lists of types, normalizes their primitives, and then verifies that one is “assignable” to the other. So it will handle the case where you have an Integer and are trying to call a method that takes int as well as the case where you have a String and are trying to call a method that takes Object. It does not handle the case of having an int and calling a method that takes float. There has to be some specificity.

The one caveat is that the above method just searches in method order so if there are ambiguities then the selection is arbitrary. I’ve never encountered a real-world issue, so far in practice.

Here is the compatibility check for reference:
public static boolean areTypesCompatible( Class[] targets, Class[] sources ) {
if( targets.length != sources.length )
return false;

    for( int i = 0; i < targets.length; i++ ) {
        if( sources[i] == null )
            continue;

        if( !translateFromPrimitive( targets[i] ).isAssignableFrom( sources[i] ) )
            return false;
        }
    return( true );
}

The code is BSD and mine so the snippets are legal to use. If you decide you’d rather use this util package directly the most recent public release is here:
https://meta-jb.svn.sourceforge.net/svnroot/meta-jb/trunk/dev/m2-repo/org/meta-jb/meta-jb-util/0.17.1/

And I only mention that because there hasn’t been a bundled download in a long time since most of my active users are maven users. I seem to be more fond of writing code than cutting full releases. 😉