Quel est le principe du mécanisme de réflexion Java

Principe du mécanisme de réflexion Java : 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 lorsque le programme est exécuté, la JVM chargera le classe. fichier de bytecode dans la mémoire. Au sens strict, on dit qu'il est chargé dans la zone de méthode et converti en un objet java.lang.Class. Par réflexion, nous pouvons construire une instance, obtenir la valeur de la variable membre, obtenir. la méthode et appelez-la.

L'environnement d'exploitation de cet article : système Windows 10, version java17, ordinateur Dell g3.

Le principe de la réflexion est le suivant :

Le code source que nous écrivons est un fichier .java, qui devient un fichier .class après avoir été compilé par javac, c'est-à-dire un fichier de bytecode.

Lorsque le programme est exécuté, la JVM chargera le fichier de bytecode dans la mémoire à proprement parler, il sera 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.

Grâce à la réflexion, nous pouvons construire 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.

Code d'implémentation :

1) Construire une instance sans paramètre : appeler 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) Construire 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) Obtenir 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);

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

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 mise à niveau utilise la technologie d'annotation plus de réflexion et un proxy dynamique.

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!