Quels sont les principes et les méthodes de mise en œuvre du mécanisme de réflexion Java ?

1. Grâce à la réflexion, nous pouvons créer des instances, obtenir les valeurs des variables membres, obtenir des méthodes et les appeler.

Vous pouvez également obtenir des annotations définies sur les variables membres, les méthodes et les paramètres de méthode.

Ensuite, regardons l'implémentation du code, puis parlons du principe.

1) Construire une instance sans paramètre : appelez le constructeur sans paramètre par réflexion

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

2) Construisez une instance paramétrée :

        //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) Obtenez la valeur de la variable membre par réflexion.

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

4) Appelez la méthode de l'objet par réflexion.

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

5). Obtenez la valeur des variables statiques par réflexion.

       //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. Obtenez la valeur de l'annotation définie par réflexion

1) Obtenez l'annotation et la valeur de la variable membre.

@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) Obtenez les annotations et les valeurs définies sur la méthode et les paramètres de la méthode par réflexion

@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) Obtenez les types de paramètres et de valeurs de retour de la méthode.

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

3 Résumé : grâce à la réflexion, vous pouvez obtenir les valeurs des variables membres sur l'objet, appeler des méthodes et obtenir des annotations définies sur les variables membres, les méthodes et les paramètres de méthode. La rénovation utilise la technologie d'annotation et de réflexion et un proxy dynamique (cette technologie sera partagée plus tard)

4 Grâce à la réflexion, les choses ci-dessus peuvent être réalisées. Quel est le principe de la réflexion ?

1) Le code source que nous écrivons est un fichier .java, qui est compilé par javac et devient un fichier .class, c'est-à-dire un fichier de bytecode.

2) Lorsque le programme est exécuté, la JVM chargera le fichier de bytecode dans la mémoire à proprement parler, il est chargé dans la zone méthode et converti en un objet

java.lang.Class. Tout est un objet. La classe est appelée un objet de classe, qui décrit la structure des données d'une classe dans l'espace des métadonnées, y compris les attributs, les méthodes, les constructeurs, les annotations, les interfaces et d'autres informations définies dans la classe.

La première étape de toute réflexion consiste à obtenir l'objet Classe. Une fois que vous obtenez l’objet Class, vous obtenez également tout ce qui est défini dans la classe.

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

Cette ligne de code charge la classe Person en mémoire via le chargeur de classe et obtient l'objet Class correspondant.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!