Java Tutoriel API Reflection avec exemple

⚡ Résumé intelligent

Java L'API de réflexion analyse et modifie les capacités d'une classe à l'exécution, notamment ses champs, ses méthodes et ses constructeurs. Cette ressource explique le package java.lang.reflect, les principales méthodes de java.lang.Class et présente quatre exemples de lecture des métadonnées d'une classe, d'une variable, d'une méthode et d'un constructeur.

🔍 Définition: La réflexion permet d'inspecter et de modifier les classes et leurs membres lors de l'exécution, même les classes privées.
📦 Pack Réfléchir : Les classes Field, Method, Constructor et Modifier recueillent des informations déclaratives sur leurs membres.
🏷️ Méthodes de classe : getName(), getSuperclass(), getInterfaces() et getModifiers() renvoient les métadonnées de classe de base.
🧪 Exemples résolus : Quatre programmes extracmétadonnées d'une classe, de ses variables, de ses méthodes et de ses constructeurs.
⚠️ Prudence : Reflection permet d'accéder aux membres privés et est plus lent, utilisez-le donc en dernier recours.

Qu'est-ce que la réflexion dans Java?

Java La réflexion est le processus d'analyse et de modification de toutes les capacités d'une classe lors de son exécution. L'API de réflexion dans Java est utilisé pour manipuler une classe et ses membres, notamment les champs, les méthodes, les constructeurs, etc., lors de l'exécution.

Un des avantages de l'API de réflexion dans Java Il peut également manipuler les membres privés de la classe.

Le package java.lang.reflect fournit de nombreuses classes pour implémenter la réflexion. Les méthodes de la classe java.lang.Class permettent de récupérer les métadonnées complètes d'une classe donnée.

Classe dans le package java.lang.reflect

Voici une liste de divers Java les classes dans le package java.lang.reflect pour implémenter la réflexion :

Champ: Cette classe sert à recueillir des informations déclaratives telles que le type de données, le modificateur d'accès, le nom et la valeur d'une variable.
Préparation: Cette classe est utilisée pour recueillir des informations déclaratives telles que le modificateur d'accès, le type de retour, le nom, les types de paramètres et le type d'exception d'une méthode.
Constructeur: Cette classe est utilisée pour recueillir des informations déclaratives telles que le modificateur d'accès, le nom et les types de paramètres d'un constructeur.
Modificateur: Cette classe sert à recueillir des informations sur un modificateur d'accès particulier.

Méthodes utilisées dans java.lang.Class

public String getName(): Renvoie le nom de la classe.
public Class getSuperclass(): Renvoie la référence de la superclasse.
public Class[] getInterfaces(): Renvoie un tableau d'interfaces implémentées par la classe spécifiée.
public int getModifiers(): Renvoie une valeur entière représentant les modificateurs de la classe spécifiée, qui doit être passée comme paramètre à la méthode « public static String toString(int i) » qui renvoie le spécificateur d'accès pour la classe donnée.

Comment obtenir des informations complètes sur une classe

Pour obtenir des informations sur les variablesPour utiliser les méthodes et les constructeurs d'une classe, il est nécessaire de créer un objet de cette classe. L'exemple suivant illustre différentes manières de créer un objet de la classe « Class » :

public class Guru99ClassObjectCreation {
    public static void main(String[] args) throws ClassNotFoundException {
        // 1 - By using Class.forName() method
        Class c1 = Class.forName("Guru99ClassObjectCreation");
        // 2 - By using getClass() method
        Guru99ClassObjectCreation guru99Obj = new Guru99ClassObjectCreation();
        Class c2 = guru99Obj.getClass();
        // 3 - By using .class
        Class c3 = Guru99ClassObjectCreation.class;
    }
}

Exemple 1 : Comment obtenir les métadonnées d’une classe

L'exemple suivant montre comment obtenir des métadonnées telles que le nom de la classe, le nom de la superclasse, les interfaces implémentées et les modificateurs d'accès d'une classe.

Nous allons récupérer les métadonnées de la classe ci-dessous nommée Guru99Base.class :

import java.io.Serializable;
public abstract class Guru99Base implements Serializable, Cloneable {
}

Le nom de la classe est : Guru99Base
Ses modificateurs d'accès sont : public et abstract
Il a implémenté des interfaces : sérialisable et clonable
Puisqu'elle n'étend aucune classe explicitement, sa superclasse est : java.lang.Object

La classe ci-dessous récupérera les métadonnées de Guru99Base.class et imprimez-le :

import java.lang.reflect.Modifier;
public class Guru99GetclassMetaData {
    public static void main(String[] args) throws ClassNotFoundException {
        // Create Class object for Guru99Base.class
        Class<Guru99Base> guru99ClassObj = Guru99Base.class;

        // Print name of the class
        System.out.println("Name of the class is : " + guru99ClassObj.getName());

        // Print super class name
        System.out.println("Name of the super class is : " + guru99ClassObj.getSuperclass().getName());

        // Get the list of implemented interfaces using getInterfaces() method
        Class[] guru99InterfaceList = guru99ClassObj.getInterfaces();

        // Print the implemented interfaces using a for-each loop
        System.out.print("Implemented interfaces are : ");
        for (Class guru99class1 : guru99InterfaceList) {
            System.out.print(guru99class1.getName() + " ");
        }
        System.out.println();

        // Get access modifiers using getModifiers() and Modifier.toString()
        int guru99AccessModifier = guru99ClassObj.getModifiers();
        System.out.println("Access modifiers of the class are : " + Modifier.toString(guru99AccessModifier));
    }
}

Affichez le nom de la classe en utilisant la méthode getName().
Affichez le nom de la superclasse en utilisant la méthode getSuperclass().getName().
Afficher les noms des interfaces implémentées.
Afficher les modificateurs d'accès utilisés par la classe.

Exemple 2 : Comment obtenir les métadonnées d’une variable

L'exemple suivant montre comment obtenir les métadonnées d'une variable.

Ici, nous créons une classe nommée Guru99VariableMetaData.class avec quelques variables :

package guru;
public class Guru99VariableMetaData {
    public static int guru99IntVar1 = 1111;
    static int guru99IntVar2 = 2222;
    static String guru99StringVar1 = "guru99.com";
    static String guru99StringVar2 = "Learning Reflection API";
}

Étapes pour obtenir les métadonnées sur les variables de la classe ci-dessus :

Créez l'objet de classe de la classe ci-dessus, c'est-à-dire, Guru99VariableMetaData.class, comme ci-dessous :

Guru99VariableMetaData guru99ClassVar = new Guru99VariableMetaData();
Class guru99ClassObjVar = guru99ClassVar.getClass();

Récupérez les métadonnées sous forme de tableau de champs en utilisant getFields() or getDeclaredFields () méthodes comme ci-dessous :
```
Field[] guru99Field1 = guru99ClassObjVar.getFields();
Field[] guru99Field2 = guru99ClassObjVar.getDeclaredFields();
```

Le getFields() Cette méthode renvoie les métadonnées des variables publiques de la classe spécifiée ainsi que de sa superclasse.

Le getDeclaredFields () Cette méthode renvoie uniquement les métadonnées de toutes les variables de la classe spécifiée.

Obtenez le nom des variables à l'aide de la méthode « public String getName() ».
Obtenez le type de données des variables à l'aide de la méthode « public Class getType() ».
Récupérez la valeur de la variable à l'aide de la méthode « public xxx get(Field) ». Ici, xxx peut être un octet, un entier court ou tout autre type de valeur à récupérer.
Obtenez les modificateurs d'accès des variables à l'aide des méthodes getModifiers() et Modifier.toString(int i).

Ici, nous écrivons une classe pour obtenir les métadonnées des variables présentes dans la classe. Guru99VariableMetaData.class :

package guru;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Guru99VariableMetaDataTest {
    public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException {
        // Create Class object for Guru99VariableMetaData.class
        Guru99VariableMetaData guru99ClassVar = new Guru99VariableMetaData();
        Class guru99ClassObjVar = guru99ClassVar.getClass();

        // Get the metadata of all the fields of the class
        Field[] guru99Field1 = guru99ClassObjVar.getDeclaredFields();

        // Print name, data types, access modifiers and values of the variables
        for (Field field : guru99Field1) {
            System.out.println("Variable name : " + field.getName());
            System.out.println("Datatype of the variable : " + field.getType());

            int guru99AccessModifiers = field.getModifiers();
            System.out.println("Access Modifiers of the variable : " + Modifier.toString(guru99AccessModifiers));
            System.out.println("Value of the variable : " + field.get(guru99ClassVar));
            System.out.println();
        }
    }
}

Création d'un objet de classe pour Guru99VariableMetaData.class.
J'ai récupéré toutes les métadonnées des variables dans un tableau de champs.
J'ai imprimé tous les noms de variables de la classe. Guru99VariableMetaData.class.
Afficher tous les types de données des variables de la classe.
J'ai imprimé tous les modificateurs d'accès des variables de la classe.
Les valeurs de toutes les variables de la classe ont été affichées.

Exemple 3 : Comment obtenir les métadonnées d’une méthode

L'exemple suivant montre comment obtenir les métadonnées d'une méthode.

Ici, nous créons une classe nommée Guru99MethodMetaData.class avec quelques méthodes :

package guru;
import java.sql.SQLException;
public class Guru99MethodMetaData {

    public void guru99Add(int firstElement, int secondElement, String result)
    throws ClassNotFoundException, ClassCastException {
        System.out.println("Demo method for Reflection API");
    }
    public String guru99Search(String searchString)
    throws ArithmeticException, InterruptedException {
        System.out.println("Demo method for Reflection API");
        return null;
    }
    public void guru99Delete(String deleteString)
    throws SQLException {
        System.out.println("Demo method for Reflection API");
    }
}

Étapes pour obtenir les métadonnées relatives aux méthodes de la classe ci-dessus :

Créez l'objet de classe de la classe ci-dessus, c'est-à-dire, Guru99MethodMetaData.class, comme ci-dessous :

Guru99MethodMetaData guru99ClassVar = new Guru99MethodMetaData();
Class guru99ClassObjVar = guru99ClassVar.getClass();

Obtenez les informations sur les méthodes dans un tableau Method en utilisant les méthodes getMethods() et getDeclaredMethods() comme ci-dessous :
```
Method[] guru99Method1 = guru99ClassObjVar.getMethods();
Method[] guru99Method2 = guru99ClassObjVar.getDeclaredMethods();
```
Le getMethods() Cette méthode renvoie les métadonnées des méthodes publiques de la classe spécifiée ainsi que de sa superclasse. getDeclaredMethods() Cette méthode renvoie uniquement les métadonnées de toutes les méthodes de la classe spécifiée.
Obtenez le nom de la méthode en utilisant getName () méthode.
Obtenez le type de retour de la méthode en utilisant getReturnType() méthode.
Obtenez les modificateurs d'accès des méthodes en utilisant getModifiers() et Modifier.toString(int i) méthodes.
Obtenez les types de paramètres de méthode en utilisant getParameterTypes() méthode, qui renvoie un tableau de classes.
Récupérez les exceptions levées en utilisant getExceptionTypes() méthode, qui renvoie un tableau de classes.

Ici, nous écrivons une classe pour obtenir les métadonnées des méthodes présentes dans la classe. Guru99MethodMetaData.class :

package guru;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Guru99MethodMetaDataTest {

    public static void main(String[] args) {
        // Create Class object for Guru99MethodMetaData.class
        Class guru99ClassObj = Guru99MethodMetaData.class;

        // Get the metadata of all the methods using getDeclaredMethods()
        Method[] guru99Methods = guru99ClassObj.getDeclaredMethods();

        for (Method method : guru99Methods) {
            System.out.println("Name of the method : " + method.getName());
            System.out.println("Return type of the method : " + method.getReturnType());

            int guru99ModifierList = method.getModifiers();
            System.out.println("Method access modifiers : " + Modifier.toString(guru99ModifierList));

            Class[] guru99ParamList = method.getParameterTypes();
            System.out.print("Method parameter types : ");
            for (Class class1 : guru99ParamList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();

            Class[] guru99ExceptionList = method.getExceptionTypes();
            System.out.print("Exception thrown by method : ");
            for (Class class1 : guru99ExceptionList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();
        }
    }
}

Création d'un objet de classe pour Guru99MethodMetaData.class.
J'ai récupéré toutes les métadonnées de toutes les méthodes dans un tableau de méthodes.
Affiche tous les noms de méthodes présents dans la classe.
Affichage des types de retour des méthodes de la classe.
J'ai imprimé tous les modificateurs d'accès des méthodes de la classe.
Affichage des types de paramètres des méthodes.
Les exceptions levées par les méthodes ont été imprimées.

Exemple 4 : Comment obtenir les métadonnées des constructeurs

L'exemple suivant montre comment obtenir les métadonnées des constructeurs.

Ici, nous créons une classe nommée Guru99Constructor.class avec différents constructeurs :

package guru;

import java.rmi.RemoteException;
import java.sql.SQLException;

public class Guru99Constructor {

    public Guru99Constructor(int no) throws ClassCastException, ArithmeticException { }
    public Guru99Constructor(int no, String name) throws RemoteException, SQLException { }
    public Guru99Constructor(int no, String name, String address) throws InterruptedException { }
}

Ici, nous écrivons une classe pour obtenir les métadonnées des constructeurs présents dans la classe. Guru99Constructeur.class :

package guru;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
public class Guru99ConstructorMetaDataTest {

    public static void main(String[] args) {
        // Create Class object for Guru99Constructor.class
        Class guru99Class = Guru99Constructor.class;

        // Get all the constructor information in the Constructor array
        Constructor[] guru99ConstructorList = guru99Class.getConstructors();

        for (Constructor constructor : guru99ConstructorList) {
            System.out.println("Constructor name : " + constructor.getName());

            int guru99Modifiers = constructor.getModifiers();
            System.out.println("Constructor modifier : " + Modifier.toString(guru99Modifiers));

            Class[] guru99ParamList = constructor.getParameterTypes();
            System.out.print("Constructor parameter types : ");
            for (Class class1 : guru99ParamList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();

            Class[] guru99ExceptionList = constructor.getExceptionTypes();
            System.out.print("Exception thrown by constructors : ");
            for (Class class1 : guru99ExceptionList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();
        }
    }
}

Création d'un objet de classe pour Guru99Constructeur.classe.
J'ai récupéré toutes les métadonnées de tous les constructeurs dans un tableau Constructor.
Affiche tous les noms des constructeurs présents dans la classe.
J'ai imprimé tous les modificateurs d'accès des constructeurs de la classe.
Affichage des types de paramètres des constructeurs.
J'ai imprimé les exceptions levées par les constructeurs.

FAQ

La réflexion permet aux frameworks et aux outils d'IA d'inspecter et d'instancier des classes à l'exécution. Elle prend en charge l'injection de dépendances, la sérialisation et la gestion des ORM.pinget le chargement dynamique de plugins sans connaître les classes exactes au moment de la compilation.

L'IA peut générer rapidement du code de réflexion, mais il convient de l'examiner attentivement. La réflexion peut contourner les contrôles d'accès et engendrer des risques de sécurité et de performance ; le code généré doit donc être testé et validé.

La réflexion est plus lente que les appels de méthode directs, peut rompre l'encapsulation en accédant à des membres privés et peut engendrer des problèmes de sécurité et de maintenance. Elle ne devrait être utilisée qu'en dernier recours.

Oui. L'utilisation de `setAccessible(true)` permet à la réflexion de lire et de modifier les champs privés, ainsi que d'appeler des méthodes privées. C'est très utile pour les tests et les frameworks, mais cela peut compromettre l'encapsulation et engendrer des problèmes de sécurité.