Reflection Übergabeparamter überprüfen?

[CK]

Hallo,
Ich habe eine Methode die ein Object, einen Methodennamen als String, und eine Array von Objekten(Übergabeparameter) entgegennimmt.

Hier versuche ich nun per Reflection auf den Übergebenen obejct die Methode mit den Übergebenen Paramtern
aufzurufen.

       try
        {
            if (object != null)
            {
                Class[] classes = new Class[params.size()];

                for (int i = 0; i < params.size(); i++)
                {
                    Class clazz = params.get(i).getClass();

                    classes[i] = clazz;
                }

                Class classOfObject = object.getClass();



                 Method meth = classOfObject.getMethod(method, classes);
                 meth.invoke(object, params.toArray());
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

Das funktioniert auch so weit ganz gut, nur wenn ich jetzt z.B. so eine Methode habe.

   public void set(int a, int b)
    {
        //mach was
    }

Dann würde ich ja, weil meine Parameter alle Objekte sind auf

   public void set(Integer a, Integer b)
    {
        //mach was
    }

überprüfen und dann findet er die Methode natürlich nicht.

Ich weis aber das so ein Methodenaufruf funktioniern würde.


Also zu meiner Frage.
Wie ist es möglich bei einer Methode zu überprüfen ob sie bestimmte Parameter entgegen nehmen kann??

Habe da schon was über isAssignableFrom gelesen, aber das führt mich irgendwie nicht zur Lösung.

Danke schonmal für euere Hilfe.

 

[Marco13]

Hmja, das ist nicht so 100% klar... Ein möglicher Workaround wäre, explizit zu überprüfen, ob die Typen zuweisbar sind, aber das kann natürlich zu uneindeutigkeiten führen.

Wenn du direkt params.get(i).getClass() aufrufst, SIND das natürlich immer Objekte, und damnach kann nur Integer.class zurückgegeben werden. Wenn du die Typen explizit auflisten würdest, könntest du natürlich direkt "int.class" oder "Integer.TYPE" hinschreiben.

Wie auch immer. Hier ein möglicher Ansatz

import java.lang.reflect.*;
import java.util.*;

class TestInt
{
    public void set(int a)
    {
        System.out.println("TestInt#set(int) called");
    }
}

class TestInteger
{
    public void set(Integer a)
    {
        System.out.println("TestInteger#set(Integer) called");
    }
}

class TestBoth
{
    public void set(Integer a)
    {
        System.out.println("TestBoth#set(Integer) called");
    }
    public void set(int a)
    {
        System.out.println("TestBoth#set(int) called");
    }
}


class ReflectionTypeTest
{


    public static void main(String args[])
    {
        test(new TestInt(), "set", Arrays.asList(1));
        test(new TestInteger(), "set", Arrays.asList(1));
        test(new TestBoth(), "set", Arrays.asList(1));
    }


    public static void test(Object object, String methodName, List<?> params)
    {
        try
        {
            if (object != null)
            {
                Class[] classes = new Class[params.size()];

                for (int i = 0; i < params.size(); i++)
                {
                    Class clazz = params.get(i).getClass();

                    classes[i] = clazz;
                }
                Class classOfObject = object.getClass();

                List<Method> methods = findMatchingMethods(classOfObject, methodName, classes);

                if (methods.size() == 0)
                {
                    throw new NoSuchMethodException("No matching method found");
                }
                else if (methods.size() > 1)
                {
                    System.out.println("Warning: Multiple matching methods found:");
                    for (Method m : methods)
                    {
                        System.out.println("         "+m);
                    }
                    System.out.println("         Invoking the first one");
                }
                methods.get(0).invoke(object, params.toArray());
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }


    private static List<Method> findMatchingMethods(Class c, String name, Class classes[])
    {
        List<Method> result = new ArrayList<Method>();
        Method methods[] = c.getMethods();
        for (int i=0; i<methods.length; i++)
        {
            if (methods[i].getName().equals(name))
            {
                Class parameterTypes[] = methods[i].getParameterTypes();
                if (parameterTypes.length == classes.length)
                {
                    boolean matching = true;

                    //System.out.println("Candidate method "+methods[i]+": "+Arrays.toString(parameterTypes)+" for args "+Arrays.toString(classes));

                    for (int j=0; j<parameterTypes.length; j++)
                    {
                        Class ca = classes[j];
                        Class cb = parameterTypes[j];

                        if (cb == byte.class)   matching &= Byte.TYPE.isAssignableFrom(cb);
                        if (cb == char.class)   matching &= Character.TYPE.isAssignableFrom(cb);
                        if (cb == short.class)  matching &= Short.TYPE.isAssignableFrom(cb);
                        if (cb == int.class)    matching &= Integer.TYPE.isAssignableFrom(cb);
                        if (cb == long.class)   matching &= Long.TYPE.isAssignableFrom(cb);
                        if (cb == float.class)  matching &= Float.TYPE.isAssignableFrom(cb);
                        if (cb == double.class) matching &= Double.TYPE.isAssignableFrom(cb);
                    }

                    if (matching)
                    {
                        //System.out.println("Metching method "+methods[i]+": "+Arrays.toString(parameterTypes)+" for args "+Arrays.toString(classes));
                        result.add(methods[i]);
                    }
                }

            }
        }
        return result;

    }

}

 

[Marco13]

So als Nachtrag: Eigentlich müßte man immer den spezifischsten Typ wählen - schau auch mal kurz hier http://www.java-forum.org/de/viewtopic.php?t=67720&highlight= drüber

 

[CK]

Habe das jetzt einfach mit ner Hashmap gemacht und wenns einer der Acht Typen ist, dann rufe ich die Methode auf. Über das AutoBoxing von Java funktioniert das ja dann wenn ich nen Integer übergebe aber int gefprdert ist.

Danke für die Hilfe.