Viele Mainstream-Frameworks verwenden Reflexionstechnologie. Beispielsweise verwendet das SSH-Framework zwei Technologien: XML als Konfigurationsdatei + Reflexionstechnologie.
Unterrichtspakete zum Thema Reflexion.
java.lang.reflect.*; und java.lang.Class;
Alle Typen in Java (einschließlich Basistypen) entsprechen einem Klassenobjekt, und diese Klasse ist java.lang.Class. Das heißt, jeder Typ verfügt über ein entsprechendes Klassenobjekt in der Klasse. Die Klasse hat keinen öffentlichen Konstruktor. Beachten Sie, dass es nicht darum geht, dass es keinen öffentlichen Zugang gibt.
So erhalten Sie ein Klassenobjekt
Kopieren Sie den Codecode wie folgt:
.Für jedes object.getCalss() können Sie die entsprechende Klasse abrufen.
.Class.forName(String), die Schreibmethode von String: Paketname.Klassenname. Das dem Paketnamen.Klassenname entsprechende Objekt wird erstellt. Hinweis: 1.2 gilt nur für Referenztypen.
.Für Basistypen: TYPE stellt das Class-Objekt des entsprechenden Basistyps dar. TYPE entspricht dem Class-Objekt von int.
.Typ, Klasse. <Typ 4 ist universell.>
Von den vier oben genannten Methoden ist nur Methode 2 dynamisch. Sie verfügt über dynamisches Potenzial. Wenn Sie also wirklich dynamische Programmierung verkörpern möchten, können Sie nur Methode 2 verwenden.
Es gibt nur ein Klassenobjekt jedes Typs, das heißt, sie haben nur eine Adresse, aber die verschiedenen Typen sind unterschiedlich.
Die folgenden Druckergebnisse sind also alle wahr.
Kopieren Sie den Codecode wie folgt:
//Paar- und Referenztypen
Klasse c1 = "".getClass();
Klasse c2 = Class.forName("java.lang.String");
Klasse c3 = String.class;
System.out.println(c1 ==c2);//true
//Für Grundtypen
Klasse num1 = Integer.TYPE;
Klasse num2 = int.class;
System.out.println(num1 == num2);//true
Reflexion, um verwandte Methoden von Mitgliedern in einer Klasse zu erhalten
[Struktur <gemäß Parametertyp> abrufen] (im Allgemeinen ohne Deklaration verwendet)
Kopieren Sie den Codecode wie folgt:
Constructor<T> getConstructor(Class<?>... parameterTypes)
Gibt ein Konstruktorobjekt zurück, das den angegebenen öffentlichen Konstruktor der durch dieses Klassenobjekt dargestellten Klasse widerspiegelt.
Konstruktor<?>[] getConstructors()
Gibt ein Array mit Konstruktorobjekten zurück, die alle öffentlichen Konstruktoren der durch dieses Klassenobjekt dargestellten Klasse widerspiegeln.
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
Gibt ein Konstruktorobjekt zurück, das die angegebene Konstruktormethode für die Klasse oder Schnittstelle widerspiegelt, die durch dieses Klassenobjekt dargestellt wird.
Konstruktor<?>[] getDeclaredConstructors()
Gibt ein Array von Konstruktorobjekten zurück, die alle Konstruktormethoden widerspiegeln, die von der durch dieses Klassenobjekt dargestellten Klasse deklariert werden.
[Attribut <gemäß Attributname> abrufen] (wird normalerweise mit deklariert verwendet, da Attribute im Allgemeinen privat sind)
Kopieren Sie den Codecode wie folgt:
Feld getField(String name)
Gibt ein Field-Objekt zurück, das die angegebenen öffentlichen Mitgliedsfelder der Klasse oder Schnittstelle widerspiegelt, die durch dieses Class-Objekt dargestellt wird.
Feld[] getFields()
Gibt ein Array mit Field-Objekten zurück, die alle zugänglichen öffentlichen Felder der Klasse oder Schnittstelle widerspiegeln, die durch dieses Class-Objekt dargestellt wird.
Feld getDeclaredField(String name)
Gibt ein Field-Objekt zurück, das das angegebene deklarierte Feld der Klasse oder Schnittstelle widerspiegelt, die durch dieses Class-Objekt dargestellt wird.
Feld[] getDeclaredFields()
Gibt ein Array von Field-Objekten zurück, die alle Felder widerspiegeln, die von der Klasse oder Schnittstelle deklariert werden, die durch dieses Class-Objekt dargestellt wird.
[Methode <Methodenname plus Parametertyp> abrufen] (normalerweise ohne Deklaration verwendet)
Kopieren Sie den Codecode wie folgt:
Methode getMethod(String name, Class<?>... parameterTypes)
Gibt ein Methodenobjekt zurück, das die angegebene öffentliche Mitgliedsmethode der Klasse oder Schnittstelle widerspiegelt, die durch dieses Klassenobjekt dargestellt wird.
Methode[] getMethods()
Gibt ein Array mit Methodenobjekten zurück, die die öffentlichen Mitglieder der durch dieses Klassenobjekt dargestellten Klasse oder Schnittstelle widerspiegeln (einschließlich der von dieser Klasse oder Schnittstelle deklarierten und von Superklassen und Superschnittstellen geerbten Methoden).
Methode getDeclaredMethod(String name, Class<?>... parameterTypes)
Gibt ein Methodenobjekt zurück, das die angegebene deklarierte Methode der Klasse oder Schnittstelle widerspiegelt, die durch dieses Klassenobjekt dargestellt wird.
Methode[] getDeclaredMethods()
Gibt ein Array von Methodenobjekten zurück, die alle von der durch dieses Klassenobjekt dargestellten Klasse oder Schnittstelle deklarierten Methoden widerspiegeln, einschließlich öffentlicher, geschützter Methoden, Standardzugriffsmethoden (Paketzugriff) und privater Methoden, jedoch mit Ausnahme geerbter Methoden.
T newInstance()
Erstellt eine neue Instanz der Klasse, die durch dieses Klassenobjekt dargestellt wird. <new Instance() kann Objekte dynamisch erstellen>
String toString()
Konvertieren Sie ein Objekt in einen String.
Beachten: newInstance() ruft einen Konstruktor ohne Parameter auf. Wenn die Klasse keinen Konstruktor ohne Parameter hat, generiert newInstance() eine Ausnahme.
Deklarierte Methoden unterstützen die Privatsphäre, unterstützen jedoch nicht die Vererbung. Nicht deklarierte Methoden unterstützen die Vererbung, unterstützen jedoch nicht die Privatsphäre und können nur öffentliche Dinge herausnehmen.
Daher werden Eigenschaften im Allgemeinen mit einer Deklaration deklariert, da Eigenschaften im Allgemeinen privat sind, Methoden im Allgemeinen ohne Deklaration abgerufen werden und Konstruktoren im Allgemeinen ohne Deklaration abgerufen werden.
Durch die Instanzsimulationsreflexion werden relevante Eigenschaften und Methoden in der Klasse abgerufen
Verwenden von Reflektion, um Eigenschaften Werte zuzuweisen
Methoden im Feld
Objekt get(Objekt obj)
Gibt den Wert des Feldes zurück, das durch dieses Feld für das angegebene Objekt dargestellt wird.
Feld f = c.getXXField(property name);
value = f.get(object);
void set(Objekt obj, Objektwert)
Setzt das von diesem Field-Objekt dargestellte Feld für die angegebene Objektvariable auf den angegebenen neuen Wert.
f.set(object, value);
Klasse<?> getType()
Gibt ein Class-Objekt zurück, das den deklarierten Typ des durch dieses Field-Objekt dargestellten Felds identifiziert.
Wird verwendet, um den Typ des Attributs abzurufen (gibt ein Klassenobjekt zurück).
Kopieren Sie den Codecode wie folgt:
Klasse c = Student.class;
Object obj = c.newInstance(); //Erstelle ein Objekt der Student-Klasse
Feld f = c.getDeclaredField("name"); //Das Namensattribut abrufen
f.setAccessible(true); //Privaten Zugriff festlegen.
f.set(obj, "zhangsan");
System.out.println(f.get(obj)); //Den Wert des Namensattributs von obj abrufen.
Verwenden von Reflektion zum Aufrufen von Konstrukten Der eigentliche Aufruf des Konstruktors erfolgt, wenn die Methode newInstance() aufgerufen wird.
Kopieren Sie den Codecode wie folgt:
Klasse c = Class.forName("com.clazz.reflect.Student");
Konstruktor con = c.getConstructor(); //Es wird keine Konstruktion durchgeführt,
Object cObj = c.getConstructor().newInstance();//Rufen Sie den Parameterlosen Konstruktor auf
Konstruktor conAll = c.getConstructor(int.class,String.class,int.class);
Objekt caobj = conAll.newInstance(1001,"zjamgs",234235);//Rufen Sie den Konstruktor mit Parametern auf.
System.out.println(caobj); //Ausgabe drucken
Aufrufen von Methoden mithilfe von Reflektion Object.Methodenname (Wert 1,2,3);
Methode m = c.getMethoed(Methodenname, Parametertyp...);
m.invoke (Objekt-, Methodenaufrufparameter) Wenn der für die zugrunde liegende Methode erforderliche formale Parameter 0 ist, kann die Länge des bereitgestellten args-Arrays 0 oder null sein.
Kopieren Sie den Codecode wie folgt:
Klasse c = Class.forName("com.clazz.reflect.Student");
Object obj = c.newInstance(); //Erstelle ein Sutdent-Objekt.
Methode msetName = c.getMethod("setName", String.class);//obj muss den Typ nicht konvertieren
msetName.invoke(obj, "zhangsan");//Methode setName aufrufen und Parameter übergeben.
Methode msetId = c.getMethod("setId", int.class);
msetId.invoke(obj, 409090202);
System.out.println(obj);
Beispiele für Reflexionsanwendungen Entitätsklasse
Kopieren Sie den Codecode wie folgt:
Paket org.dennisit.reflect.entity;
import java.io.Serializable;
/**
*
*Benutzer.java
*
* @Version: 1.1
*
* @Autor: Su Ruonian<a href="mailto:
[email protected]">E-Mail senden</a>
*
* @since: 1.0 Erstellungszeit: 26.02.2013 13:43:56 Uhr
*
* TODO: Klasse User.java wird verwendet für ...
*
*/
öffentliche Klasse Benutzer implementiert Serializable{
privater String-Test;
public voidexecute(String name,int age){
System.out.println("name=" + name + ",age=" + age);
}
}
Reflexionstestklasse
Kopieren Sie den Codecode wie folgt:
Paket org.dennisit.reflect.main;
import java.lang.reflect.Field;
/**
*
* ReflectEx.java
*
* @Version: 1.1
*
* @Autor: Su Ruonian<a href="mailto:
[email protected]">E-Mail senden</a>
*
* @since: 1.0 Erstellungszeit: 26.02.2013 13:46:00 Uhr
*
* TODO: Klasse ReflectEx.java wird verwendet für ...
*
*/
öffentliche Klasse ReflectEx {
public static void main(String[] args)wirft eine Ausnahme {
Klasse cls = Class.forName("org.dennisit.reflect.entity.User");
Object obj = cls.newInstance(); //Benutzerobjekt erstellen
Feld f = cls.getDeclaredField("test"); //Testattribut abrufen
f.setAccessible(true); //Zugriffsberechtigungen für privaten Attributtest öffnen
f.set(obj, "zhangsan"); // Zum Testen noch einmal kopieren
System.out.println(f.get(obj)); //Den Testattributwert von obj abrufen
// Methode basierend auf dem Methodennamen abrufen, ausführen
java.lang.reflect.Method m = cls.getMethod("execute", String.class, int.class);
m.invoke(obj, "dennisit",23); //Execute-Methode aufrufen
}
}
Betriebseffekt
Kopieren Sie den Codecode wie folgt:
Zhangsan
Name=Dennisit,Alter=23
Beispiel für das Schreiben einer reflektierenden dynamischen Instanziierungsklasse
Kopieren Sie den Codecode wie folgt:
Paket org.dennisit.reflect.main;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
java.util.Map importieren;
import java.util.Set;
/**
*
* DynamicReflect.java
*
* @Version: 1.1
*
* @Autor: Su Ruonian<a href="mailto:
[email protected]">E-Mail senden</a>
*
* @since: 1.0 Erstellungszeit: 26.02.2013 13:58:12 Uhr
*
* TODO: Beispiel einer dynamischen Instanziierung mittels Reflektion
*
*/
öffentliche Klasse DynamicReflect {
öffentliches statisches Objekt getInstance(String className,Map<String,Object> map)wirft eine Ausnahme{
Klasse c = Class.forName(className);
Object obj = c.newInstance(); //Object object
Set<String> keys = map.keySet(); //Alle entsprechenden Attribute abrufen
Field[] fAll = c.getDeclaredFields(); //Alle Eigenschaften in der Klasse abrufen
for(int i=0;i<fAll.length;i++){
for(String key:keys){ //Schleifenübereinstimmung
if(fAll[i].getName().equals(key)){ //Wenn das vom Benutzer übergebene Attribut mit dem Attributnamen in der erhaltenen Klasse übereinstimmt
Feld f = c.getDeclaredField(key);//Dieses Attribut abrufen
//Konstruieren Sie den Methodennamen setXxx()
String methodName = "set" + key.substring(0,1).toUpperCase()+key.substring(1);
Methode method = c.getMethod(methodName, f.getType());// Rufen Sie die entsprechende Methode basierend auf dem erstellten Benutzernamen ab
method.invoke(obj, map.get(key));//Methodenaufruf
}anders{
weitermachen;
}
}
}
return obj;
}
}
Als nächstes testen wir das von uns geschriebene Beispiel für die Instanziierung dynamischer Reflexionen
Entitätsklasse
Kopieren Sie den Codecode wie folgt:
Paket org.dennisit.reflect.entity;
import java.io.Serializable;
/**
*
*Benutzer.java
*
* @Version: 1.1
*
* @Autor: Su Ruonian<a href="mailto:
[email protected]">E-Mail senden</a>
*
* @since: 1.0 Erstellungszeit: 26.02.2013 13:43:56 Uhr
*
* TODO: Entitätsklasse
*
*/
öffentliche Klasse Benutzer implementiert Serializable{
privater String-Name;
privates Int-Alter;
private String-E-Mail;
public User() { //Darf keinen Parameterkonstruktor haben
}
//getter() und setter()
}
Haupttestklasse
Kopieren Sie den Codecode wie folgt:
Paket org.dennisit.reflect.main;
import java.util.HashMap;
java.util.Map importieren;
import org.dennisit.reflect.entity.User;
/**
*
* ReflectEx.java
*
* @Version: 1.1
*
* @Autor: Su Ruonian<a href="mailto:
[email protected]">E-Mail senden</a>
*
* @since: 1.0 Erstellungszeit: 26.02.2013 13:46:00 Uhr
*
* TODO: Klasse ReflectEx.java wird verwendet für ...
*
*/
öffentliche Klasse ReflectEx {
public static void main(String[] args)wirft eine Ausnahme {
Klasse cls = Class.forName("org.dennisit.reflect.entity.User");
String className = "org.dennisit.reflect.entity.User";
Map<String,Object> map = new HashMap<String, Object>();
map.put("name", "dennisit");
map.put("age", 22);
map.put("email", "[email protected]");
Benutzer user = (Benutzer)DynamicReflect.getInstance(className, map);
System.out.println(user.getName() + "," + user.getAge() + "," + user.getEmail());
}
}
Ergebnisse der Programmausführung
Kopieren Sie den Codecode wie folgt:
