Was sind die Prinzipien und Implementierungsmethoden des Java-Reflexionsmechanismus?

1. Durch Reflexion können wir Instanzen erstellen, die Werte von Mitgliedsvariablen abrufen, Methoden abrufen und sie aufrufen.

Sie können auch Anmerkungen zu Mitgliedsvariablen, Methoden und Methodenparametern definieren lassen.

Als nächstes schauen wir uns die Code-Implementierung an und sprechen dann über das Prinzip.

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);

2. Ermitteln Sie den Wert der definierten Annotation durch Reflexion.

1) Ermitteln Sie die Annotation und den Wert der Mitgliedsvariablen.

@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();

3 Zusammenfassung: Durch Reflektion 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 verwendet Annotation plus Reflection-Technologie und dynamischen Proxy (diese Technologie wird später geteilt)

4 ​​Durch Reflection können die oben genannten Dinge erreicht werden. Was ist das Reflexionsprinzip?

1) Der Quellcode, den wir schreiben, ist eine .java-Datei, die von javac kompiliert wird und zu einer .class-Datei, also einer Bytecode-Datei, wird.

2) 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 umgewandelt. Alles ist ein Objekt, das als Klassenobjekt bezeichnet wird und die Datenstruktur einer Klasse im Metadatenraum beschreibt, einschließlich der in der Klasse definierten Attribute, Methoden, Konstruktoren, Anmerkungen, Schnittstellen.

Der erste Schritt bei allen Überlegungen besteht darin, das Klassenobjekt abzurufen. Sobald Sie das Klassenobjekt erhalten, erhalten Sie auch alles, was in der Klasse definiert ist.

Class clazz = Class.forName("com.example.lib.Person");

Diese Codezeile lädt die Person-Klasse über den Klassenlader in den Speicher und ruft das entsprechende Klassenobjekt ab.

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