Reflection

[twomoon]

Hallo zusammen,
ich habe neu angefangen mit Java-reflection zu lernen.
ich erzeuge eine Reihe von Parameter und ich möchte eine Konstruktor mit disen Paramtern innerhalb meiner Quellcode aufrufen und prüfen ob der Konstruktor mit diese Parametern aufrufbar ist.
ich habe folgende Methode:

/* argList : liste von Parametern, die ich an dem Konst eingeben will */
public Boolean checkInstanceToAvailable(Class<?> c,Constructor<?> ctor,List<Object> argList) {

	Boolean aufrufbar = false;
        Class<?>[] param_type = ctor.getParameterTypes();
	ctor.setAccessible(true);
        try {
	ctor.newInstance(/* ich möcte die Parameter hier eingeben können  */);
         aufrufbar = true;
	}catch(Exception e) {
        
         	
	return aufrufbar;
	}

Könnte jemand jemand mir helfen, wie ich das machen kann?

danke für die Hilfe
Grüße

 

[frankyv]

Wie wäre es hier mit ?

import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.List;


public class TwoMoon {

	public static boolean isAvailable(Class<?> cl, List<Object> args){
		//getConstructor() erwartet die Argumente in einem Array aus Klassen:
                Class arrayArgs[] = new Class[args.size()];
		boolean available = true;
		
		for (int i = 0; i < arrayArgs.length; i++){
			arrayArgs[i] = args.get(i).getClass();
		}
		
		try {
			Constructor cons = cl.getConstructor(arrayArgs);
		}
		catch (Exception e) {
			available = false;
		}
		
		return available;
		
		
	}
	
	public static void main(String[] args) {
		List<Object> liste = new ArrayList<Object>();
		
		liste.add("TestString");
		
		if (isAvailable(String.class, liste)){
			System.out.println("Konstruktor gefunden");
		}
		else {
			System.out.println("Kein Konstruktor gefunden");
		}
		
		liste.clear();
		liste.add(5);
		
		if (isAvailable(String.class, liste)){
			System.out.println("Konstruktor gefunden");
		}
		else {
			System.out.println("Kein Konstruktor gefunden");
		}

		
	}
	
}

 

[twomoon]

Hallo frankyv,
Danke für die Antwort.
Das sieht schon gut aus.
soweit ich davon verstehe, ruftst du den Konstruktor mit der Parametertypen. ich möchte aber mit parameter selbst aufrufen.
z.B. ich habe durch reflection den Konstruktor und dessen Parametertypen bekommen. Dann erzeuge ich die Parameter für entsprechende Typen.
Nachdem ich die Parameter erzeugt habe, möchte ich mit diesen Parametern über prüfen ob mit diesen Parametern ein Objekt erzeugt werden kann.
sagen wir eine parametertype war int und ich habe eine -11234 Zahl generiert, obwohl der Konstruktor keine minus Zahlen akzeptiert.

Grüße
TwoMoon

 

[Basti4231]

Der Konstruktor akzeptiert alle Variablen des festgelegten Typs, egal welchen Wert sie haben.
Von daher hast du also eine Überprüfung in deinem Konstruktor. Wieso benutzt du nicht diese, um dann den entsprechenden Vorgang einzuleiten?

 

[frankyv]

@twomoon

du hast geschrieben:

sagen wir eine parametertype war int und ich habe eine -11234 Zahl generiert, obwohl der Konstruktor keine minus Zahlen akzeptiert.

so etwas kann man im Konstruktor in Java nicht ausdrücken.
Sagen wir, innerhalb des Konstruktors fände eine Überprüfung statt, z.B. ob ein Parameter
negativ war. Dann ist das innerhalb des Reflection-Frameworks nicht sichtbar, denn der kennt
nur die Schnittstelle, die Argumente, die der Methode übergeben werden, aber nicht die
interne Implementation.

Natürlich wäre es gut wenn das anders wäre.
In anderen Programmiersprachen gibt es sogenannte Verträge. Darin wird dann zugesichert, welche
Bedingungen an die Parameter gestellt werden.

Ich glaub ich kann dir da nicht weiterhelfen, aber ich wünsch dir alles Gute für dein Projekt.

Grüße...

 

[frankyv]

Ich hab nochmal drüber nachgedacht, auch über das was Basti4231 geschrieben hat.
Ich glaube, er hat recht mit dem.
Mit meiner Methode kannst du herausfinden, ob der Konstruktor prinzipiell bestimmte Parameter
akzeptiert.
Danach kannst du ja den Konstruktor mit newInstance und deinen konkreten Parametern aufrufen.
Wird dann eine Exception geworfen, oder null zurückgegeben, weisst du ja automatisch, dass
was schief gelaufen ist.

 

[frankyv]

Schau mal How do I create an object via its multiparameter constructor using reflection? - Web Tutorials - avajava.com an.

Da wirst du finden, dass man Constructor.newInstance() mit einem Array aus Objekten aufrufen kann.
Benutze also dieselbe Methode, die ich in isAvailable() benutzt habe, um die Objektliste in ein Array zu packen.

Das Array übergib dann an .newInstance().
Wenn Exception geworfen wird, dann weisst du, dass der Konstruktoraufruf ungültig war.

Wenn du dabei noch eine Hilfestellung gebrauchen kannst.
Sag einfach bescheid.

Grüße

 

[twomoon]

Hallo,
@Basti4231
--> ich nehme an, dass in dem Konstruktor so eine Überprüfung stattfindet.

@frankyv
--> ich habe so gemacht aber es wird so ein Exception geworfen
Exceptionmessage:Error beim Instanziierung paht.to.myTestClasses.MatrikelNr.<init>(java.lang.Integer)

	public static boolean isAvailable(Class<?> cl, List<Object> args, StringBuffer prefix) {
		// getConstructor() erwartet die Argumente in einem Array aus Klassen:
		Class arrayArgs[] = new Class[args.size()];
		Object arrayParams[] = new Object[args.size()];
		boolean available = true;
		
		for (int i = 0; i < arrayArgs.length; i++) {
			arrayArgs[i] = args.get(i).getClass();
			arrayParams[i] = args.get(i);
		}
	
		try {
		
			Constructor<?> cons = cl.getConstructor(arrayArgs);
			cons.newInstance(arrayParams);
		} catch (Exception e) {
			System.out.println("Error beim Instanziierung "+e.getMessage());
			available = false;
		}

		return available;

	}

danke euch :noe:

 

[frankyv]

Tut mir leid, dass es nicht richtig funktioniert.
Ich versuche mehr darüber rauszufinden.
Ich meld mich dann bei dir

 

[frankyv]

Probier doch noch mal ob es jetzt funktioniert :noe:

public static boolean isAvailable(Class<?> cl, List<Object> args){
		Class arrayArgs[] = new Class[args.size()];
		Object arrayObjects[] = new Object[args.size()];
		Object result = null;
		
		boolean available = true;
		
		for (int i = 0; i < arrayArgs.length; i++){
			if (args.get(i) instanceof Integer){
				arrayArgs[i] = Integer.TYPE;
			}
			else if (args.get(i) instanceof Double){
				arrayArgs[i] = Double.TYPE;
			}
			else if (args.get(i) instanceof Float){
				arrayArgs[i] = Float.TYPE;
			}
			else if (args.get(i) instanceof Boolean){
				arrayArgs[i] = Boolean.TYPE;
			}
			else {
				arrayArgs[i] = args.get(i).getClass();
			}
		}
		
		for (int i = 0; i < arrayObjects.length; i++){
			arrayObjects[i] = args.get(i);
		}
		
		try {
			Constructor cons = cl.getConstructor(arrayArgs);
			result = cons.newInstance(arrayObjects);
			
		}
		catch (Exception e) {
			
			available = false;
		}
		
		if (result == null) available = false;
		return available;
		
		
	}

 

[twomoon]

Hey danke dir :toll: Meister :applaus:
es funktioniert wurderbar. wenn ich in dem Konstruktor beschränke, dass nur die minus Zahlnen sonst exception dann wird false zurück gegeben.
Das ist auf jeden Fall super. Aber ich muss noch erweitern weil ich die Pramtetern generiere, können viele unterschiedliche Prameterntype sein.
z.B. ein Paramter kann ein objekt sein.

 

[frankyv]

Schön, dass ich dir weiterhelfen konnte.
Ich hoffe sehr, dass du weiterhin gut vorankommst.

Und wenn du nochmal Hilfe von mir brauchen kannst, dann PN mich einfach