Einführung in die Analyse der Java-Reflexion

Dieses Dokument beschreibt die Analyse und Einführung der Java-Reflexion

1 Was ist Reflexion?
Aus der Baidu-Enzyklopädie können wir erkennen, dass sich die Java-Reflektion im laufenden Zustand befindet. Wir können alle Eigenschaften und Methoden dieser Klasse kennen und jede ihrer Methoden und Eigenschaften aufrufen kann seine Eigenschaften ändern. Und aus diesem Grund gilt Java als dynamisch (oder quasi-dynamisch, warum heißt es quasi-dynamisch, denn die allgemeine Definition einer dynamischen Sprache ist, dass sie bei laufendem Programm die Programmstruktur oder den Variablentyp ermöglicht Diese Sprache wird als dynamische Sprache bezeichnet. Aus dieser Sicht sind Perl, Python und Ruby dynamische Sprachen, und C++, Java und C# sind keine dynamischen Sprachen.) Eine Schlüsseleigenschaft von Sprachen.

2. Was kann Reflexion bewirken?
Wir wissen, dass der Reflexionsmechanismus es dem Programm ermöglicht, zur Laufzeit die internen Informationen jeder Klasse mit einem bekannten Namen abzurufen, einschließlich ihrer Modifikatoren (Modifikatoren), Felder (Eigenschaften), Methoden (Methoden) usw. und kann sein Der Inhalt von Feldern oder Aufrufmethoden wird zur Laufzeit geändert. Dann können wir Code flexibler schreiben und den Code zur Laufzeit zusammenstellen, ohne dass eine Quellcodeverknüpfung zwischen Komponenten erforderlich ist, wodurch die Kopplung des Codes verringert wird. Es gibt jedoch auch dynamische Proxy-Implementierungen usw.; zur unsachgemäßen Verwendung von Reflexion. Es wird sehr kostspielig sein!

3. Spezifische Umsetzung der Reflexion

Das Folgende ist eine grundlegende Klassenperson

package com.ys.reflex;
public class Person {
    //私有属性
    private String name = "Tom";
    //公有属性
    public int age = 18;
    //构造方法
    public Person() {    
    }
    //私有方法
    private void say(){
        System.out.println("private say()...");
    }
    //公有方法
    public void work(){
        System.out.println("public work()...");
    }
}

① Die drei Methoden

//1、通过对象调用 getClass() 方法来获取,通常应用在：比如你传过来一个 Object
//  类型的对象，而我不知道你具体是什么类，用这种方法
　　Person p1 = new Person();
　　Class c1 = p1.getClass();
        
//2、直接通过 类名.class 的方式得到,该方法最为安全可靠，程序性能更高
//  这说明任何一个类都有一个隐含的静态成员变量 class
　　Class c2 = Person.class;
        
//3、通过 Class 对象的 forName() 静态方法来获取，用的最多，
//   但可能抛出 ClassNotFoundException 异常
　　Class c3 = Class.forName("com.ys.reflex.Person");

Es ist zu beachten, dass: Eine Klasse nur eine Klasseninstanz in der JVM hat, d. h. die c1, die wir oben erhalten haben , c2 und c3 werden mit Gleichen verglichen und als wahr befunden

②, Mitgliedsvariablen, Mitgliedsmethoden, Schnittstellen, Superklassen, Konstruktoren usw. abrufen die Klassenklasse

Wenn Sie sich die API ansehen, können Sie sehen, dass die Klasse viele Methoden hat:

　getName(): Den vollständigen Namen der Klasse abrufen.
GetFields(): Ruft die öffentlichen Typattribute der Klasse ab.
　getDeclaredFields(): Alle Attribute der Klasse abrufen. Einschließlich privater deklarierter und geerbter Klassen
　getMethods(): Ruft die öffentliche Typmethode der Klasse ab.
　getDeclaredMethods(): Alle Methoden der Klasse abrufen. Einschließlich privater deklarierter und geerbter Klassen
　getMethod(String name, Class[] parameterTypes): Ruft die spezifische Methode der Klasse ab, der Parameter name gibt den Namen der Methode an und der Parameter parameterTypes gibt den Parametertyp der Methode an.
GetConstructors(): Ruft den öffentlichen Typkonstruktor der Klasse ab.
　getConstructor(Class[] parameterTypes): Ruft die spezifische Konstruktormethode der Klasse ab. Der Parameter „parameterTypes“ gibt den Parametertyp der Konstruktormethode an.
　newInstance(): Erstellt ein Objekt dieser Klasse über die Konstruktormethode der Klasse ohne Parameter.

Wir verwenden ein Beispiel, um die obige Methode umfassend zu demonstrieren:

//获得类完整的名字
String className = c2.getName();
System.out.println(className);//输出com.ys.reflex.Person
        
//获得类的public类型的属性。
Field[] fields = c2.getFields();
for(Field field : fields){
   System.out.println(field.getName());//age
}
        
//获得类的所有属性。包括私有的和继承类的
Field [] allFields = c2.getDeclaredFields();
for(Field field : allFields){
    System.out.println(field.getName());//name    age
}
        
//获得类的public类型的方法。这里包括 Object 类的一些方法
Method [] methods = c2.getMethods();
for(Method method : methods){
    System.out.println(method.getName());//work waid equls toString hashCode等
}
        
//获得类的所有方法。
Method [] allMethods = c2.getDeclaredMethods();
for(Method method : allMethods){
    System.out.println(method.getName());//work say
}
        
//获得指定的属性
Field f1 = c2.getField("age");
System.out.println(f1);
//获得指定的私有属性
Field f2 = c2.getDeclaredField("name");
//启用和禁用访问安全检查的开关，值为 true，则表示反射的对象在使用时应该取消 java 语言的访问检查；反之不取消
f2.setAccessible(true);
System.out.println(f2);
                
//创建这个类的一个对象
Object p2 =  c2.newInstance();
//将 p2 对象的  f2 属性赋值为 Bob，f2 属性即为 私有属性 name
f2.set(p2,"Bob");
//使用反射机制可以打破封装性，导致了java对象的属性不安全。 
System.out.println(f2.get(p2)); //Bob
        
//获取构造方法
Constructor [] constructors = c2.getConstructors();
for(Constructor constructor : constructors){
    System.out.println(constructor.toString());//public com.ys.reflex.Person()
}

4. Zusammenfassung der Reflexion

Die flexible Verwendung von Reflexion kann unseren Code flexibler machen, hier ist Ein Beispiel für den Registrierungstreiber für nativen JDBC-Code, die Entitätsklasse von Hibernate, AOP von Spring usw. verfügen alle über Reflexionsimplementierungen. Aber alles hat zwei Seiten: Die Wahrheit ist, dass Reflexion die Leistung und Komplexität des Systems erhöht.

Das obige ist der detaillierte Inhalt vonEinführung in die Analyse der Java-Reflexion. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!