Sinn von Reflections

[b1zarRe]

Hi,

ich lese mich gerade in das Thema der Reflections ein und steige
schon dahinter, dass man mithilfe von Reflections quasi dynamisch zur
Laufzeit bestimmen kann, welche Klasse erzeugt wird oder welche Methoden
ausgeführt werden etc.

Aber ich verstehe den Sinn nicht so ganz:

(...)
//Wir sind in der Main Methode
String klassenname = "java.lang.String";
Class cl = Class.forName("klassenname");

System.out.println(cl.getName());
System.out.println();

Method[] methoden = cl.getDeclaredMethods();
for(int i=0; i<methoden.length; i++) {
  System.out.println(methoden[i]);
}

//usw.

(...)

--> Was bringt mir das? Früher oder später, MUSS ich doch irgendwo festlegen, auf welche
Klasse ich zugreife(egal ob im Quellcode selbst oder in einer Properties Datei). Natürlich ist es schnicke, dass man mit einer Stringveränderung alles relevante über eine beliebige Klasse erfährt,
aber steckt da nicht noch mehr Sinn dahinter oder ist das schon alles?... Weil wenn das alles ist, könnte man auch gleich einfach die API aufschlagen...

Besonders in solchen Fällen...

//main
String klasse = "java.lang.String";
Class c = Class.forName(klasse);
Method m = cl.getMethod("length", new Class[0]);

String test = "bla";
System.out.println((int)m.invoke(test, new Object[0]));

.. verstehe ich das ganze nicht??? Was bringt es mir, wenn ich anstelle von:

System.out.println(new String("bla").length);

das alles schreiben muss? Also wie wäre da die Wiederverwendbarkeit? Ich meine, nicht jede
Klasse hat eine Methode lentgh() mit leerem Parameter...


Also wofür das ganze???

 

[kaetzacoatl]

Ich denke, dass sowas
beim debuggen sinnvoll
ist, wenn du die Klasse
eben nicht hast.

 

[Tomate_Salat]

Reflection wird meist auf einer abstrakteren Ebene verwendet. Als Beispiel findest du in meiner Signatur ein Link zu JMapper der viel Reflection einsetzt.

Beispiel JMapper:
JMapper definiert ein Interface anhand von Annotationen (die zur Laufzeit ausgewertet werden) und verbindet so eine Map zu dem Interface. Da ich unmöglich alle Interface-definitionen kennen kann, arbeite ich hier eben sehr abstrakt damit.
Für manche Dinge kann man auch z.B. ein Interface/Klasse voraussetzen, dass dieses vorhanden ist. Über eine Annotation wird dann eine Klasse angegeben und über Reflection erstelle+verwende ich diese.

 

[SlaterB]

wozu baut man Automaten mit komplizierter variabler Erkennung von Münzen/ Scheinen
und nicht genau zu einer Münze passende Hardwäre, gegebenfalls mehrere nebeneinander?

der feste Quellcode eines Programms ist hier die Hardware,
entweder auf einzelne Klassen beschränkt, oder dynamisch für beliebige Dinge ausgelegt,

nicht unbedingt weil man nicht alle vorher kennt, obwohl oft der Fall,
sondern auch weil es einfach zu aufwendig/ fehleranfällig/ teuer/ schlecht wäre, gewissen Code zu verdoppeln

das geht zunächst/ immer auch ohne Reflection, jede Klasse kann sich an ein Interface mit Rückgabe bestimmter benötigter Daten halten
oder man verzichtet komplett auf großes Klassenmodell in einem Bereich,
alles in einer Klasse mit einer Liste/ Type an Attributen, die einen Typ + Wert haben usw.,
zum Teil Abschied von OO, relationale Datenbanken sind auch heute ja noch bisschen was anderes

Reflection ist aber das, was immer da ist,
was die Programmierung nicht auf ein bestimmtes Modell einschränkt (außer eben das Modell Java selber)
und mit beliebigen Klassen etwas anfangen kann

 

[Antoras]

Ein sehr schönes Beispiel für Reflection, wie ich finde, ist z.B.:

Json.fromString(json).extract(Person.class)

Intern wird über Reflection der Aufbau der Klasse Person analysiert, damit danach Instanzen von ihr erzeugt werden können, die mit den Daten aus dem Json-String gefüllt sind.

 

[diggaa1984]

ich nenn als bsp mal nen teil den ich in meiner diplomarbeit damals umgesetzt hatte:

ich habe einen Editor programmiert der Syntaxprüfungen vorgenommen hat .. da ich keine Einschränkung bezüglich er zu erkennenden Grammatik haben drufte, wurden Grammatiken vom Nutzer angegeben, anschließend daraus mit einem Framework ein Parser und Scanner erzeugt, die dann compiliert als *.class vorlagen.

Somit konnte ich dann dynamisch neue Parser und Scanner im Programm verwenden und kannte dabei nur den Klassennamen der erzeugten Dateien. Diese hatten dann ein gewisses Interface implementiert auf das ich intern zugreifen konnte.

Somit kann das Programm nun alle LL(k)-Grammatiken parsen und scannen, ohne Änderungen am Code vornehmen zu müssen.

 

[Brixto]

Ich benutze Reflections zum Beispiel häufig um (fast) alle Variablen einer Klasse über ihre Setter zu befüllen, ohne jeden Setter einzeln aufzurufen.

 

[Spacerat]

...soviel zu den schönen Dingen an Reflections... (okay, schreibt ruhig noch ein paar mehr. )
Es geht natürlich auch hässlich. Mit Reflections können sogar private Methoden oder auf private Member anderer Klassen aufgerufen bzw. zugegriffen werden. Jede Menge Schindluder also. Was ich biher noch nicht versucht habe ist den Wert eines finalen Members einer Klasse zu ändern (in JNI geht das).
Aber immer im Auge behalten: Reflections ist nur dann Mittel zum Zweck, wenn einem die Ideen ausgehen. Sobald man sich damit tiefer beschäftigt hat,neigt man dazu, es für Dinge zu verwenden, die anders viel sauberer jedoch "umständlicher" zu lösen wären. Reflections ist der riesen "Hammer" mit dem man (nahezu?) alles (nicht nur Nägel) in eine Wand bekommt. Wie wäre es z.B. mit 'ner MutableIndexColorModel-Klasse?

package datatypes.graphics;

import java.awt.image.IndexColorModel;
import java.lang.reflect.Field;
import java.math.BigInteger;

public class MutableIndexColorModel extends IndexColorModel {
	private int[] rgb;
	private Field tIndex;

	public MutableIndexColorModel(int bits, int size, byte[] r, byte[] g,
			byte[] b) {
		super(bits, size, r, g, b);
		createFields();
	}

	public MutableIndexColorModel(int bits, int size, byte[] cmap, int start,
			boolean hasalpha) {
		super(bits, size, cmap, start, hasalpha);
		createFields();
	}

	public MutableIndexColorModel(int bits, int size, byte[] r, byte[] g,
			byte[] b, int trans) {
		super(bits, size, r, g, b, trans);
		createFields();
	}

	public MutableIndexColorModel(int bits, int size, byte[] r, byte[] g,
			byte[] b, byte[] a) {
		super(bits, size, r, g, b, a);
		createFields();
	}

	public MutableIndexColorModel(int bits, int size, byte[] cmap, int start,
			boolean hasalpha, int trans) {
		super(bits, size, cmap, start, hasalpha, trans);
		createFields();
	}

	public MutableIndexColorModel(int bits, int size, int[] cmap, int start,
			int transferType, BigInteger validBits) {
		super(bits, size, cmap, start, transferType, validBits);
		createFields();
	}

	public MutableIndexColorModel(int bits, int size, int[] cmap, int start,
			boolean hasalpha, int trans, int transferType) {
		super(bits, size, cmap, start, hasalpha, trans, transferType);
		createFields();
	}

	private void createFields() {
		try {
			Field f = IndexColorModel.class.getDeclaredField("rgb");
			f.setAccessible(true);
			rgb = (int[]) f.get(this);
			tIndex = IndexColorModel.class.getDeclaredField("transparent_index");
			tIndex.setAccessible(true);
		} catch(IllegalAccessException | NoSuchFieldException e) {
			e.printStackTrace();
		}
	}

	public int setRGB(int index, int rgb) {
		int rc = this.rgb[index];
		this.rgb[index] = rgb;
		return rc;
	}

	public int setTransparentPixel(int index) {
		int rc = getTransparentPixel();
		if(rc != index) {
			try {
				tIndex.set(this, index);
			} catch(IllegalAccessException e) {
				e.printStackTrace();
			}
		}
		return rc;
	}
}

 

[b1zarRe]

@Brixto

In Worten verpackst Du als eine Klasse A in ein Class Objekt c und in eine Variable
Methods[] m = c.getDeclaresMethods(); und iterierst dann über m und befüllst dieses, ja?
In dieser Iteration hast du dann als Abfragen, ob eine Methode zb. ein String Parameter verwedent und falls ja machst du
dies und jenes, korrekt?

Wäre nett, wenn hier vielleicht jemand ein kurzen Quellcode als Beispiel hätte.... weil bei dem Bsp.: von Brixto weiß
ich nicht recht wie das funktionieren soll, da jede Methode andere Parameter beinhaltet und einen anderen semantischen
Sinn verfolgt. Wie kannst du dann das einfach automatisert ablaufen lassen?

 

[SlaterB]

üblicherweise gibt es ein Mapping, ob mit Annotations direkt an dem Attribut/ der Methode,
oder in separaten Beschreibungs-Daten,
die sind in ihrer Ausdruckskraft oft auch nicht so kurz wie möglich, aber
<field><name>alter</name><type>int</type></field>
ist in einer Zeile alles was man braucht,
etwas Code, vielleicht nur eine Zeile pro Feld, Aufruf einer größeren Methode, tut es aber auch:
kurz beschreiben, mehrfach die Information zum Aufbau verwenden


Hibernate kann so normale Klassen in DB-Tabellen abspeichern und umgekehrt,
ein anderes Gebiet welches mir immer vorschwebt ist Anzeige auf einer GUI oder einer Webseite mit Formularen

jedes DB-Feld, jedes Formular-Feld will gleich verarbeitet werden, mit Meta-Daten wie 'Pflichtfeld, zu lang befüllt, Fehler rot anzeigen' usw. bearbeitet

in einer Welt braucht man dynamische Daten, gleichzeitig will man die Ergebnisse aber auch in normalen Klassen objektorientiert verarbeiten,

 

[Brixto]

Ob, und wenn ja, wie die Abfrage/Bestimmung von Typen geht, weiß ich nicht.

Ich lese verschiedene Attribute aus einer XML (immer String) und befülle dann alle Variablen.

String[] attr = {"deinAttribut1", "deinAttribut2"};
           Method[] arr_Methods = DeineKlasse.class.getMethods();
            for (int i = 0; i < arr_Methods.length; i++) {
                Method m = arr_Methods[i];
                if (m.getName().toLowerCase().startsWith("set" + attrname.toLowerCase())) {
                    if (m != null) {
                        try {
                            m.invoke(app, Wert);
                        } catch (Exception ex) {
                            ex.printStackTrace();
                        }
                    }
                    i = arr_Methods.length;
                }
            }