Quels sont les points de connaissance sur le mécanisme de réflexion Java ?

Cycle de déclaration de classe

code source java----->javac-------------->fichier de bytecode java-- --- --------->java----------------->Objet de classe (espace mémoire : métaespace, mémoire locale) --- ----- ----------------nouveau--------->Objet instancié-------------- ----gc- ------------>Désinstaller l'objet

Les objets de classe peuvent être obtenus à différentes étapes# 🎜🎜##🎜 🎜#

Object.getClass() (étape mémoire)
Test.class (métaespace)#🎜🎜 #
• # 🎜🎜#

  class.forName("Nom complet de la classe : nom du package + nom de la classe") : Vous pouvez récupérer l'objet sans entrer dans l'espace mémoire (disque dur)

  #🎜🎜 ##🎜🎜 #
Par exemple, lorsque nous utilisons jdbc pour faire fonctionner la base de données, avant que cette classe n'entre dans la mémoire, nous pouvons utiliser le nom complet de la classe - nom du package + nom de la classe, appeler la classe et utiliser # 🎜🎜## 🎜🎜#

• Scénario de comment obtenir un objet de classe

Class.forName("Class Full name") : principalement utilisé pour les fichiers de configuration, définir le nom de la classe dans le fichier de configuration, lire le fichier de configuration, charger la classe

Class name.class : principalement utilisé pour les paramètres Pass #🎜 🎜#

• Object name.getClass() : principalement utilisé pour obtenir des objets de classe

• Résumé : le même Le fichier chargé par le chargeur de classe ne sera chargé qu'une seule fois lors de l'exécution d'un programme. Quelle que soit la méthode utilisée, l'objet de classe obtenu est le même
  Exemple de code :

package com.reflect;
public class TestReflectPerson {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.class.forName()
        Class class1=Class.forName("com.reflect.Person");
        System.out.println(class1);
        //2.类名.class
        Class class2=Person.class;
        System.out.println(class2);
        //2.对象名.getClass()
        Class class3=new Person().getClass();
        System.out.println(class3);
        System.out.println(class1==class2);  //true
        System.out.println(class2==class3);  //true
    }
}

#🎜 🎜#Fonction de. objet de classe

• Obtenir les variables membres : Obtenez tout : classe object.getDeclaredFields(), obtenez-en une : classe objet.getDeclaredField()

Set valeur définie (Object obj,Object value)

Obtenir la valeur get(Object obj)

# 🎜🎜#Pour obtenir la valeur de réglage d'une variable membre modifiée par n'importe quelle autorisation, vous devez utiliser setAccessible(true)-----violent réflexion

• Méthode membre : Class object.getDeclaredMethods()

  #🎜 🎜#Méthode d'exécution invoquée(Object object,Object… agrs) (le nombre de paramètres est arbitraire, facultatif)

Obtenir le nom de la méthode getName()

• Méthode de construction : classe Object.getDeclaredConstructors()

Bien qu'il soit nécessaire d'avoir un constructeur sans paramètre, l'utilisation de la méthode newInstance() peut omettre les étapes d'obtention du constructeur et d'obtention de l'objet

This la méthode nécessite la situation réelle Attribuer des paramètres réels au constructeur

//获得构造方法对象，
        Constructor cons1 = pcla.getDeclaredConstructor(String.class, int.class);
        Person p2 = (Person)cons1.newInstance("李四",19);
        System.out.println("p2:"+p2.getName());

newInstance() Si vous créez un constructeur sans paramètre pour créer un objet, vous pouvez utiliser un objet de classe pour créer l'objet et ignorer l'obtention du constructeur object

Get

Obtenez le nom de la classe : getName() Imprimez le nom complet : nom de la classe + nom du package

Je veux juste imprimer le nom de la classe unique : getSimpleName()

# 🎜🎜#Obtenir le nom de la variable membre de la classe

Fichier de propriétés : le contenu est connecté par un signe égal sous la forme k=v,

#🎜🎜 #

Exemple de code :

package com.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class TestReflectPerson {
    public static void main(String[] args) throws Exception {
       /* //1.class.forName()
        Class class1=Class.forName("com.reflect.Person");
        System.out.println(class1);
        //2.类名.class
        Class class2=Person.class;
        System.out.println(class2);
        //2.类名.getClass()
        Class class3=new Person().getClass();
        System.out.println(class3);
        System.out.println(class1==class2);
        System.out.println(class2==class3);*/
        //获取对象
        Class tclass=Class.forName("com.reflect.Person");
        //通过类对象获取成员变量们
        Field[] fields = tclass.getDeclaredFields();
        System.out.println("获取Person对象的所有属性对象");
        for (Field field:fields){
           System.out.println(field);
       }
        //指定获取Person对象的属性对象
        System.out.println("指定获取Person对象的属性对象");
        Field age=tclass.getDeclaredField("age");
        System.out.println("age:"+age);
        //通过类对象获取所有的构造方法
        Constructor[] constructors = tclass.getDeclaredConstructors();
        System.out.println("获取Person的所有构造方法对象");
        for (Constructor constructor:constructors){
            System.out.println(constructor);
        }
        //通过类对象获取无参的构造方法
        Constructor constructor = tclass.getDeclaredConstructor();
        System.out.println("constructor:"+constructor);
        //通过类对象获取有参的构造方法
        Constructor constructor1 = tclass.getDeclaredConstructor(String.class,int.class);
        System.out.println("constructor1:"+constructor1);
        //通过类对象获取所有的成员方法
        Method[] methods = tclass.getDeclaredMethods();
        for (Method method:methods){
            System.out.println("method:"+method);
        }
        //通过类对象获取getAge成员方法
        Method getAge = tclass.getDeclaredMethod("getAge");
        System.out.println("getAge："+getAge);
        //通过类对象获取getAge成员方法
        Method setAge = tclass.getDeclaredMethod("setAge", int.class);
        System.out.println("setAge："+setAge);
    }
}

Obtenir le code de la variable membre exemple :

package com.reflect;
import java.lang.reflect.Field;
public class TestField {
    public static void main(String[] args) throws Exception {
        Class pcla=Person.class;
        /*//获取公共访问权限的成员变量
        Field[] fields = pcla.getFields();
        for (Field field:fields){
            System.out.println("getFild:"+field);
        }
        System.out.println();
        //获取所有访问权限的成员变量
        Field[] fielddes = pcla.getDeclaredFields();
        for (Field field:fielddes){
            System.out.println("field:"+field);
        }*/
        Field name = pcla.getDeclaredField("name");
        System.out.println(name);
        Person person=new Person();
        //暴力反射：获取任意访问权限修饰符的安全检查
        name.setAccessible(true);
        //获取公共成员变量的值
        Object value = name.get(person);
        System.out.println(value);
        //获取任意访问权限的成员变量的值
        Object value2 = name.get(person);
        System.out.println("value2:"+value2);
        //设置任意访问权限的成员变量的值
        name.set(person,"张三");
        Object value3=name.get(person);
        System.out.println("name:"+value3);
    }
}

Comment obtenir la valeur d'une variable privée

//暴力反射：获取任意访问权限修饰符的安全检查
name.setAccessible(true);

Juger les processus et les threads en fonction de l'existence ou non d'une méthode principale

Processus : contient sa propre méthode principale, qui peut être démarrée en s'appuyant sur sa propre méthode principale. C'est ce qu'on appelle un processus

Thread : Il n'a pas sa propre méthode principale et doit s'appuyer sur d'autres outils pour le faire. run

Par exemple : la servlet doit être exécutée avec l'aide de tomcate, qui a sa propre méthode principale

Reflection of the background ( Remember)

#🎜 🎜#Exemple : lorsque la servlet est exécutée à l'aide de l'outil tomacate, tomacate ne peut pas accéder aux ressources de la classe lors de l'exécution du projet, ce qui entraîne une réflexion

Pourquoi tomcate prend-il des objets moins que neufs# 🎜🎜#

Explication détaillée : Tomcate ne peut pas être appelé via new, car tomacate est généré et écrit en premier, et la classe est écrite plus tard, donc tomcate ne sait pas quel est l'objet de new , vous pouvez obtenir le fichier. chemin à travers l’analyse des packages, mais vous ne pouvez pas utiliser la nouvelle méthode, ce qui provoque une réflexion.

ate a sa propre méthode principale

Réflexion de l'arrière-plan

Exemple : Lorsque la servlet est exécutée à l'aide de l'outil tomcate, tomacate exécute le project Lorsque la ressource de la classe n'est pas accessible, la réflexion se produit

Pourquoi Tomcate ne parvient-il pas à récupérer le nouvel objet ?

Explication détaillée : Tomcate ne peut pas être appelé via new, car tomacate est généré et écrit en premier, et la classe est écrite plus tard, donc tomcate ne sait pas quel est l'objet de new. Il peut être analysé. la méthode package pour obtenir le chemin du fichier, mais cette méthode ne peut pas utiliser la nouvelle méthode, ce qui entraîne une réflexion.

Lorsque tomcate veut appeler les méthodes doGet et doPost, car ces deux méthodes ne sont pas statiques, elles doivent être appelées via de nouveaux objets, mais tomcate ne peut pas créer d'objets, donc une réflexion est générée pour obtenir le fichier# 🎜 🎜#

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!