wie übergeben mehrere Parameter an eine Methode in java Reflexionen

Hallo, ich bin mit Reflexionen etwas zu erreichen.
Ich habe Klassennamen, Methodennamen der Klasse und die Werte der parameter, die übergeben werden muss, um diese Methode in eine Datei(Nehmen Sie eine beliebige Datei. Kein Zwang).
Ich habe zu nennen, dass die Methode mit den Parametern. Diese Methoden nichts zurück.
Es gibt eine riesige Liste von Methoden dieser Klassen und parameter Liste der einzelnen variiert.

E. g: method1(String, String, int, boolean)
method1(String, int, boolean) und ebenso habe ich verschiedene Permutationen und Kombinationen.
Also, wie kann ich dies erreichen.
Ich habe versucht, hart zu Kodieren Dinge mit verschiedenen switch-Klauseln aber es ist ein echter Aufwand und riskant zu halten.
Können wir dynamisch tun, dieses Ding, wie on-the-fly Lesen Sie den Namen der Methode und deren parameter aus der Datei und nennen Sie es.
Jede kleine code snippets hilfreich sein.
TIA.

Mit Object[]{par1,par2,..}
Denken Sie daran, mit StackOverflow formatieren, müssen Sie die EINGABETASTE drücken, zweimal.
Kannst du die permutation, Kombination der Parameter der Methode ?
hier sind die verschiedenen Beispiele meiner Methoden:
hier sind die verschiedenen Beispiele meiner Methoden: 1) login(String url,String username,String password) 2) login() 3) selectModel(String modelName) 4) selectControl(Stirng controlLabel, String value) 5) selectControl(String controlLabel, int Anzahl, String value) @J. Rush können Sie mir kleinen code-snippet, das von der gleichen auf der Grundlage der oben beschriebenen Methode Proben. ? TIA

InformationsquelleAutor Mrunal Gosar | 2013-04-25

Hallo alle ich habe die Lösung gefunden, um die oben genannte Frage. unten ist der Beispiel-code-snippet.

package reflections;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectionTest {
    public void method1(String str, int number) {
        System.out.println(str + number);
    }

    public void method1(String str) {
        System.out.println(str);
    }

    public void method1() {
        System.out.println("helloworld");
    }

    public static void main(String[] args) throws ClassNotFoundException,
            InstantiationException, IllegalAccessException,
            NoSuchMethodException, SecurityException, IllegalArgumentException,
            InvocationTargetException {
        //Step 1) Make an object array and store the parameters that you wish
        //to pass it.
        Object[] obj = {};//for method1()
        //Object[] obj={"hello"}; for method1(String str)
        //Object[] obj={"hello",1}; for method1(String str,int number)
        //Step 2) Create a class array which will hold the signature of the
        //method being called.
        Class<?> params[] = new Class[obj.length];
        for (int i = 0; i < obj.length; i++) {
            if (obj[i] instanceof Integer) {
                params[i] = Integer.TYPE;
            } else if (obj[i] instanceof String) {
                params[i] = String.class;
            }
            //you can do additional checks for other data types if you want.
        }

        String methoName = "method1"; //methodname to be invoked
        String className = "reflections.ReflectionTest";//Class name
        Class<?> cls = Class.forName(className);
        Object _instance = cls.newInstance();
        Method myMethod = cls.getDeclaredMethod(methoName, params);
        myMethod.invoke(_instance, obj);
    }
}

Ich hoffe das hilft anderen auch.

Zur info: Du format-code durch hinzufügen von vier Leerzeichen vor jeder Zeile ein 😉
ich bin einfach mit der Tastenkombination Strg+K durch auswählen der Zeilen von code formatieren Sie den code. Das, was die code-Formatierung Warnung aufgefordert werden, formatieren Sie den code. Jedenfalls ab dem nächsten mal Mach ich sicher. Dank
Danke Mann, ich bin irgendwie neu auf Java, und ich kämpfte mit diesem, nur eine Frage. Warum verwenden Sie Integer.Art und nicht .Klasse?
wenn Sie diese Zeile sehen, cls.getDeclaredMethod(methoName, params); hier haben wir zu übergeben, als zweites argument als array von parameter-Typen.. So das ist, warum ich verwenden Sie Integer.Geben

InformationsquelleAutor Mrunal Gosar

public class ReflectionSample
{
    private Object mString = null;
    private int mValue;

    public ReflectionSample()
    {
    }

    public ReflectionSample(int oValue)
    {
        mValue = oValue;
    }

    public ReflectionSample(String oString)
    {
        mString = oString;
    }

    public ReflectionSample(String oString, int oValue)
    {
        setValues(oString, oValue);
    }

    public void setValues(String oString, int oValue)
    {
        mString = oString;
        mValue = oValue;
    }

    public String toString()
    {
        return ""+mString+":"+mValue;
    }

    public void run()
    {
        String oInput = "Teststring";
        Class<?> cls;
        String clsname = "main.ReflectionSample";
        Object rs = null;   //ReflectionSample
        Object rsc = null;

        System.out.println(this.getClass().getName());
        try
        {
            System.out.println(clsname);
            cls = Class.forName(clsname);
            if(cls == null)
            {
                System.err.println(clsname + " doesn't exist");
                return;
            }

            //Look for a constructor which has a single string
            Constructor<?> ct = null;
            Class<?>[] param_types = new Class<?>[1];
            Object[] arguments = new Object[1];

            param_types[0] = String.class;

            //get the string constructor
            ct = cls.getConstructor(param_types);

            //We only have one object
            arguments = new Object[1];
            arguments[0] = oInput;

            //Instantiate the object with passed in argument.
            rs = ct.newInstance(arguments);
            System.out.println("String constructor sample: "+rs);

            //Instantiate with default constructor
            param_types = new Class<?>[0];
            arguments = new Object[0];
            ct = cls.getConstructor(param_types);
            rs = ct.newInstance(arguments);
            rsc = rs; //Keep it for later, to lazy to call it again
            System.out.println("Default constructor sample: "+rs);

            //Instantiate with string and int constructor
            param_types = new Class<?>[2];
            arguments = new Object[2];

            //Must be in the same order as the params I think
            param_types[0] = String.class;
            param_types[1] = Integer.TYPE;      //<-- Its a primitive so use TYPE not Class

            arguments[0] = oInput;
            arguments[1] = new Integer(1);

            ct = cls.getConstructor(param_types);
            rs = ct.newInstance(arguments);
            System.out.println("String plus int constructor sample: "+rs);

            //call the setValues method
            param_types[0] = String.class;
            param_types[1] = Integer.TYPE;      //<-- Its a primitive so use TYPE not Class

            arguments[0] = oInput;
            arguments[1] = 1;

            System.out.println("setValues invocation before: "+rsc);
            Method m = cls.getMethod("setValues", param_types);
            m.invoke(rsc, arguments);
            System.out.println("setValues invocation after: "+rsc);

            //An alternative method to pass the parameters
            m = cls.getMethod("setValues", String.class, Integer.TYPE);
            m.invoke(rsc, oInput+"x", 2);
            System.out.println("setValues invocation after: "+rsc);
        }
        catch(Throwable e)
        {
            System.err.println(e.getLocalizedMessage());
        }
    }
}

Ausgabe:

main.ReflectionSample
main.ReflectionSample
String constructor sample: Teststring:0
Default constructor sample: null:0
String plus int constructor sample: Teststring:1
setValues invocation before: null:0
setValues invocation after: Teststring:1

Hoffe, das hilft.

Ich weiß nicht, ob dies ist ein neues feature in Java, aber ich habe gesehen, dass Sie verwenden können, aufrufen, nun mit Parameter, anstelle von einem array, das könnte Ihr code besser zu Lesen (Das ist der alternative Weg). Wenn Sie eine variable Anzahl von Argumenten, und Sie wissen nicht im Voraus, wie viele es sein werden, die Zuweisung der array ist defeinitly funktioniert und sollte auch backwardcompatible.

InformationsquelleAutor Devolus

Eine einfache Lösung wäre eine Class mit dem Argumente übergeben werden:

public class ObjectArguments {
  private PrintWriter out;
  private String productId;
  private int action;

  public ObjectArguments(PrintWriter out, String productId, int action) {
    this.out = out;
    this.productId = productId;
    this.action = action;
  }

  public PrintWriter getOut() {
    return out;
  }

  public String getProductId() {
    return productId;
  }

  public int getAction() {
    return action;
  }
}

Unter der Annahme, dass Sie aufrufen möchten, eine Klasse Foo mit einer Methode namens bar.

Dann wäre es so geschehen.

PrintWriter out = null;
String productId = null;
int action = 0;

Class[] paramArguments = new Class[1];  
paramArguments[0] = ObjectArguments.class;  

ObjectArguments newObj = new ObjectArguments(out,productId,action);

Class cls = Class.forName("Foo");
Object obj = cls.newInstance();

Method method = cls.getDeclaredMethod("bar", paramArguments);
method.invoke(obj, newObj);

InformationsquelleAutor Charindu Edirisooriya

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.