Was ist das Prinzip des Java-Reflexionsmechanismus?

Prinzip des Java-Reflexionsmechanismus: Der von uns geschriebene Quellcode ist eine .java-Datei, die von javac kompiliert wird und zu einer .class-Datei wird, also zu einer Bytecode-Datei. Wenn das Programm ausgeführt wird, lädt die JVM die Klasse Im engeren Sinne wird die Bytecode-Datei in den Methodenbereich geladen und in ein java.lang.Class-Objekt konvertiert. Durch Reflektion können wir eine Instanz erstellen und den Wert der Mitgliedsvariablen abrufen die Methode und rufen Sie sie auf.

Die Betriebsumgebung dieses Artikels: Windows 10-System, Java17-Version, Dell G3-Computer.

Das Reflexionsprinzip lautet:

Der Quellcode, den wir schreiben, ist eine .java-Datei, die nach der Kompilierung durch javac zu einer .class-Datei wird, also einer Bytecode-Datei.

Wenn das Programm ausgeführt wird, lädt die JVM die Bytecode-Datei in den Speicher. Genau genommen wird sie in den Methodenbereich geladen und in ein java.lang.Class-Objekt konvertiert. Alles ist ein Objekt, das als Klassenobjekt bezeichnet wird und die Datenstruktur einer Klasse im Metadatenraum beschreibt, einschließlich Attribute, Methoden, Konstruktoren, Anmerkungen, Schnittstellen und andere in der Klasse definierte Informationen.

Durch Reflexion können wir Instanzen konstruieren, die Werte von Mitgliedsvariablen abrufen, Methoden abrufen und sie aufrufen. Sie können auch Anmerkungen zu Mitgliedsvariablen, Methoden und Methodenparametern definieren lassen.

Implementierungscode:

1) Erstellen Sie eine Parameterlose Instanz: Rufen Sie den Parameterlosen Konstruktor durch Reflexion auf

//1.通过全类名加载字节码对象
Class clazz = Class.forName("com.example.lib.Person");
//2.通过类的字节码拿到定义的构造函数
Constructor constructor = clazz.getConstructor();
//3.通过构造方法创建对象
Object obj = constructor.newInstance();

2) Erstellen Sie eine parametrisierte Instanz:

//1.通过全类名加载字节码对象
Class clazz = Class.forName("com.example.lib.Person");
//2.通过类的字节码拿到定义的构造函数
Constructor constructor = clazz.getConstructor(int.class,String.class);
//3.通过构造方法创建对象
Object obj = constructor.newInstance(20,"xiaohua");

3) Erhalten Sie den Wert der Mitgliedsvariablen durch Reflexion.

//4.通过属性名获取属性
Field field = clazz.getDeclaredField("age");
field.setAccessible(true);
//5.调用get方法拿到对象obj属性age的值
Integer age = (Integer) field.get(obj);

4) Rufen Sie die Methode des Objekts durch Reflexion auf.

//4.通过方法名和参数类型，拿到方法
method = clazz.getMethod("setAge", int.class);
//5.调用方法 obj是哪个对象身上的方法。
method.invoke(obj, 21);
method =  clazz.getMethod("getAge");
method.invoke(obj);

5) Ermitteln Sie den Wert statischer Variablen durch Reflexion.

//1.通过全类名加载字节码对象
 Class clazz = Class.forName("com.example.lib.Person");
 //2.获取静态属性ID
 Field  field = clazz.getField("ID");
 field.setAccessible(true);
 //3.拿到静态属性ID的值。
 // 因为静态变量存在方法区，在对象创建之前，就已经加装到了内存
 //所以，没有对象，也可以获取变量的值，这里传null也是可以的。
 int id = (int) field.get(null);

Erhalten Sie den Wert der definierten Annotation durch Reflektion

1) Rufen Sie die Annotation und den Wert der Mitgliedsvariablen ab.

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface BindView {
    int value();
}

public class MainActivity {
    @BindView(10000)
    TextView textView;
}

//10通过反射拿到定义在属性上的注解
Class  clazz = MainActivity.class;
Field textView = clazz.getDeclaredField("textView");
BindView bindView = textView.getAnnotation(BindView.class);
int txtId = bindView.value();

3) Rufen Sie die für die Methode und Methodenparameter definierten Anmerkungen und Werte durch Reflektion ab

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Post {
    String value() default "";
}

public interface NetWorkInterface {
    @Post("http://www.baidu.com")
    Call getPerson(@Queue("name") String name, @Queue("200") int price);
}

//11通过反射拿到方法上定义的注解
  clazz = NetWorkInterface.class;
  Method method = clazz.getMethod("getPerson", String.class, int.class);
  //获取Post注解
  Post post = method.getAnnotation(Post.class);
  //获取值
  String url = post.value();

//12通过反射拿到参数上的注解
//为是个二维数组，因为方法参数会有多个，一个参数有可能定义多个注解
Annotation[][] annotations = method.getParameterAnnotations();
for (Annotation[] ans : annotations) {
    for (Annotation an : ans) {
        if (an instanceof Queue) {
            Queue queue = (Queue) an;
            String value = queue.value();
        }
    }
}

4) Rufen Sie die Parameter- und Rückgabewerttypen der Methode ab.

//13.拿到方法参数的类型。
Type[] types = method.getGenericParameterTypes();
for (Type type : types) {
    System.out.println(type.toString());
}
//14.获取方法返回值类型
Type type = method.getGenericReturnType();

Zusammenfassung:

Durch Reflexion können Sie die Werte von Mitgliedsvariablen für das Objekt abrufen, Methoden aufrufen und Anmerkungen erhalten, die für Mitgliedsvariablen, Methoden und Methodenparameter definiert sind. Retrofit nutzt Annotation plus Reflection-Technologie und dynamischen Proxy.

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