Was sind die Wissenspunkte zum Java-Reflexionsmechanismus?

Klassendeklarationszyklus

Java-Quellcode----->javac-------------->Java-Bytecode-Datei-- --- --------->java----------------->Klassenobjekt (Speicherplatz: Metaspace, lokaler Speicher) --- ----- ----------------new--------->Instanziiertes Objekt-------------- ----gc- ------------>Objekt deinstallieren

Klassenobjekte können in verschiedenen Phasen erhalten werden# 🎜🎜##🎜 🎜#

Object.getClass() (Speicherphase)
Test.class (Metaspace)#🎜🎜 #
• # 🎜🎜#

  class.forName("Vollständiger Name der Klasse: Paketname + Klassenname"): Sie können das Objekt erhalten, ohne den Speicherplatz (Festplatte) einzugeben

  #🎜🎜 ##🎜🎜 #
Wenn wir beispielsweise JDBC zum Betreiben der Datenbank verwenden, können wir, bevor diese Klasse in den Speicher gelangt, den vollständigen Namen der Klasse verwenden - Paketname + Klassenname, die Klasse aufrufen und # 🎜🎜## verwenden ?? Wird für Konfigurationsdateien verwendet. Definieren Sie den Klassennamen in der Konfigurationsdatei, lesen Sie die Konfigurationsdatei und laden Sie die Klasse 🎜#

• Objektname.getClass(): Wird hauptsächlich zum Abrufen von Klassenobjekten verwendet.

Zusammenfassung: Das Gleiche Die Datei wurde geladen vom Klassenlader wird während eines Programmlaufs nur einmal geladen, egal welche Methode verwendet wird, das erhaltene Klassenobjekt ist das gleiche

Codebeispiel:

package com.reflect;
public class TestReflectPerson {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.class.forName()
        Class class1=Class.forName("com.reflect.Person");
        System.out.println(class1);
        //2.类名.class
        Class class2=Person.class;
        System.out.println(class2);
        //2.对象名.getClass()
        Class class3=new Person().getClass();
        System.out.println(class3);
        System.out.println(class1==class2);  //true
        System.out.println(class2==class3);  //true
    }
}

#🎜 🎜#Funktion von Klassenobjekt

Mitgliedsvariablen abrufen: Alle abrufen: Klasse object.getDeclaredFields(), eine abrufen: Klasse object.getDeclaredField()

• Setzen value set(Object obj,Object value)

• Wert abrufen get(Object obj)

• # 🎜🎜#Zu erhalten Um den Einstellungswert einer Mitgliedsvariablen durch eine beliebige Berechtigung zu ändern, müssen Sie setAccessible(true)-----gewalttätige Reflexion

Mitgliedsmethode: Klasse object.getDeclaredMethods()

#🎜 verwenden 🎜#Ausführungsmethode invoke(Object object,Object… agrs) (die Anzahl der Parameter ist beliebig, optional)

Methodennamen abrufen getName()

Konstruktionsmethode: Klasse Object.getDeclaredConstructors()

Obwohl ein Konstruktor ohne Parameter erforderlich ist, können bei Verwendung der Methode newInstance() die Schritte zum Abrufen des Konstruktors und des Objekts weggelassen werden

Dies Die Methode erfordert die tatsächliche Situation. Weisen Sie dem Konstruktor tatsächliche Parameter zu.

//获得构造方法对象，
        Constructor cons1 = pcla.getDeclaredConstructor(String.class, int.class);
        Person p2 = (Person)cons1.newInstance("李四",19);
        System.out.println("p2:"+p2.getName());

• newInstance() Wenn Sie einen Konstruktor ohne Parameter erstellen, um ein Objekt zu erstellen, können Sie ein Klassenobjekt verwenden, um das Objekt zu erstellen und das Abrufen des Konstruktors überspringen object
  Get
• Den Namen der Klasse abrufen: getName() Den vollständigen Namen ausdrucken: Klassenname + Paketname
  Ich möchte nur Geben Sie den einzelnen Klassennamen aus: getSimpleName()
# 🎜🎜#Den Mitgliedsvariablennamen der Klasse abrufen

Eigenschaftendatei: der Inhalt ist mit einem Gleichheitszeichen in der Form k=v verbunden Beispiel:

package com.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class TestReflectPerson {
    public static void main(String[] args) throws Exception {
       /* //1.class.forName()
        Class class1=Class.forName("com.reflect.Person");
        System.out.println(class1);
        //2.类名.class
        Class class2=Person.class;
        System.out.println(class2);
        //2.类名.getClass()
        Class class3=new Person().getClass();
        System.out.println(class3);
        System.out.println(class1==class2);
        System.out.println(class2==class3);*/
        //获取对象
        Class tclass=Class.forName("com.reflect.Person");
        //通过类对象获取成员变量们
        Field[] fields = tclass.getDeclaredFields();
        System.out.println("获取Person对象的所有属性对象");
        for (Field field:fields){
           System.out.println(field);
       }
        //指定获取Person对象的属性对象
        System.out.println("指定获取Person对象的属性对象");
        Field age=tclass.getDeclaredField("age");
        System.out.println("age:"+age);
        //通过类对象获取所有的构造方法
        Constructor[] constructors = tclass.getDeclaredConstructors();
        System.out.println("获取Person的所有构造方法对象");
        for (Constructor constructor:constructors){
            System.out.println(constructor);
        }
        //通过类对象获取无参的构造方法
        Constructor constructor = tclass.getDeclaredConstructor();
        System.out.println("constructor:"+constructor);
        //通过类对象获取有参的构造方法
        Constructor constructor1 = tclass.getDeclaredConstructor(String.class,int.class);
        System.out.println("constructor1:"+constructor1);
        //通过类对象获取所有的成员方法
        Method[] methods = tclass.getDeclaredMethods();
        for (Method method:methods){
            System.out.println("method:"+method);
        }
        //通过类对象获取getAge成员方法
        Method getAge = tclass.getDeclaredMethod("getAge");
        System.out.println("getAge："+getAge);
        //通过类对象获取getAge成员方法
        Method setAge = tclass.getDeclaredMethod("setAge", int.class);
        System.out.println("setAge："+setAge);
    }
}

So erhalten Sie den Wert einer privaten Variablen

package com.reflect;
import java.lang.reflect.Field;
public class TestField {
    public static void main(String[] args) throws Exception {
        Class pcla=Person.class;
        /*//获取公共访问权限的成员变量
        Field[] fields = pcla.getFields();
        for (Field field:fields){
            System.out.println("getFild:"+field);
        }
        System.out.println();
        //获取所有访问权限的成员变量
        Field[] fielddes = pcla.getDeclaredFields();
        for (Field field:fielddes){
            System.out.println("field:"+field);
        }*/
        Field name = pcla.getDeclaredField("name");
        System.out.println(name);
        Person person=new Person();
        //暴力反射：获取任意访问权限修饰符的安全检查
        name.setAccessible(true);
        //获取公共成员变量的值
        Object value = name.get(person);
        System.out.println(value);
        //获取任意访问权限的成员变量的值
        Object value2 = name.get(person);
        System.out.println("value2:"+value2);
        //设置任意访问权限的成员变量的值
        name.set(person,"张三");
        Object value3=name.get(person);
        System.out.println("name:"+value3);
    }
}

Beurteilen Sie Prozesse und Threads danach, ob es eine Hauptmethode gibt

Prozess : Enthält eine eigene Hauptmethode, die durch die Verwendung einer eigenen Hauptmethode gestartet werden kann. Dies wird als Prozess bezeichnet.

Thread: Es verfügt nicht über eine eigene Hauptmethode und muss sich auf andere Tools verlassen run

Zum Beispiel: Servlet muss mit Hilfe von Tomcate ausgeführt werden, das über eine eigene Hauptmethode verfügt

Reflexion des Hintergrunds ( Merken)

#🎜 🎜#Beispiel: Wenn das Servlet mit dem Tool tomacate ausgeführt wird, kann tomacate beim Ausführen des Projekts nicht auf die Ressourcen der Klasse zugreifen, was zu Reflexionen führt

Warum nimmt Tomcate Objekte an, die weniger als neu sind# 🎜🎜#

Detaillierte Erklärung: Tomcate kann nicht über new aufgerufen werden, da Tomcate zuerst generiert und geschrieben wird und die Klasse später geschrieben wird, sodass Tomcate nicht weiß, was das Objekt von new ist. Sie können die Datei abrufen Pfad durch das Scannen von Paketen, aber Sie können nicht new verwenden, was zu Reflexionen führt.

ate hat seine eigene Hauptmethode

Spiegelung des Hintergrunds

Beispiel: Wenn das Servlet mit dem Tool Tomcate ausgeführt wird, führt Tomacate das aus Projekt Wenn auf die Ressource der Klasse nicht zugegriffen werden kann, erfolgt eine Reflexion.

Warum kann Tomcate das neue Objekt nicht abrufen?

Detaillierte Erklärung: Tomcate kann nicht über new aufgerufen werden, da tomacate zuerst generiert und geschrieben wird und die Klasse später geschrieben wird, sodass Tomcate nicht weiß, was das Objekt von new ist. Es kann durchsucht werden Verwenden Sie die Paketmethode, um den Dateipfad abzurufen. Diese Methode kann jedoch die neue Methode nicht verwenden, was zu einer Reflektion führt.

Wenn Tomcate die Methoden doGet und doPost aufrufen möchte, müssen sie über neue Objekte aufgerufen werden, da diese beiden Methoden nicht statisch sind. Tomcate kann jedoch keine Objekte erstellen, daher wird eine Reflexion generiert, um die Datei zu erhalten# 🎜 🎜#

Das obige ist der detaillierte Inhalt vonWas sind die Wissenspunkte zum Java-Reflexionsmechanismus?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!