Maîtriser l'API Reflection Java : Guide Pratique avec Exemples de Code

Qu'est-ce que la Réflexion en Java ?

La Réflexion Java est le processus d'analyse et de modification de toutes les capacités d'une classe à l'exécution. L'API Reflection en Java est utilisée pour manipuler une classe et ses membres – champs, méthodes, constructeurs, etc. – à l'exécution.

Un avantage de l'API Reflection en Java est qu'elle peut manipuler les membres privés d'une 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 sont utilisées pour rassembler les métadonnées complètes d'une classe particulière.

Dans ce tutoriel, vous apprendrez :

• Qu'est-ce que la Réflexion
• Classes dans le package java.lang.reflect
• Méthodes utilisées dans java.lang.Class
• Comment obtenir des informations complètes sur une classe
• Exemple 1 : Comment obtenir les métadonnées d'une classe
• Exemple 2 : Comment obtenir les métadonnées d'une variable
• Exemple 3 : Comment obtenir les métadonnées d'une méthode
• Exemple 4 : Comment obtenir les métadonnées des constructeurs

Classes dans le package java.lang.reflect

Voici une liste des diverses classes Java dans java.lang.package pour implémenter la réflexion :

• Field : Cette classe rassemble des informations déclaratives telles que le type de données, le modificateur d'accès, le nom et la valeur d'une variable.
• Method : Cette classe rassemble 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.
• Constructor : Cette classe rassemble des informations déclaratives telles que le modificateur d'accès, le nom et les types de paramètres d'un constructeur.
• Modifier : Cette classe rassemble des informations sur un modificateur d'accès particulier.

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

• Public String getName() : Retourne le nom de la classe.
• public Class getSuperclass() : Retourne la référence de la super-classe.
• Public Class[] getInterfaces() : Retourne un tableau des interfaces implémentées par la classe spécifiée.
• Public int getModifiers() : Retourne une valeur entière représentant les modificateurs de la classe spécifiée, qui doit être passée en paramètre à la méthode public static String toString(int i) qui retourne 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 variables, méthodes et constructeurs d'une classe, nous devons créer un objet de la classe.

public class Guru99CreationObjetClasse {
    public static void main (String[] args) throws ClassNotFoundException {
        //1 - En utilisant la méthode Class.forName()
        Class c1 = Class.forName("Guru99CreationObjetClasse");
        //2- En utilisant la méthode getClass()
        Guru99CreationObjetClasse guru99Obj = new Guru99CreationObjetClasse();
        Class c2 = guru99Obj.getClass();
        //3- En utilisant .class
        Class c3 = Guru99CreationObjetClasse.class;
    }
}

L'exemple suivant montre différentes façons de créer un objet de la classe "class" :

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

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

Nous obtiendrons les métadonnées de la classe ci-dessous nommée Guru99Base.class :

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

1. Nom de la classe : Guru99Base
2. Ses modificateurs d'accès : public et abstract
3. Interfaces implémentées : Serializable et Cloneable
4. Comme elle n'a pas explicitement étendu de classe, sa super-classe est : java.lang.Object

La classe ci-dessous obtiendra les métadonnées de Guru99Base.class et les affichera :

import java.lang.reflect.Modifier;
public class Guru99ObtenirMetadonneesClasse {
    public static void main (String [] args) throws ClassNotFoundException {
        // Créer un objet Class pour Guru99Base.class
        Class<Guru99Base> guru99ClassObj = Guru99Base.class;
        // Afficher le nom de la classe
        System.out.println("Nom de la classe est : " + guru99ClassObj.getName());
        // Afficher le nom de la super-classe
        System.out.println("Nom de la super-classe est : " + guru99ClassObj.getSuperclass().getName());
        // Obtenir la liste des interfaces implémentées sous forme de tableau Class en utilisant getInterfaces()
        Class[] guru99InterfaceList = guru99ClassObj.getInterfaces();
        // Afficher les interfaces implémentées en utilisant une boucle for-each
        System.out.print("Interfaces implémentées sont : ");
        for (Class guru99class1 : guru99InterfaceList) {
            System.out.print(guru99class1.getName() + " ");
        }
        System.out.println();
        // Obtenir les modificateurs d'accès en utilisant getModifiers() et toString() de java.lang.reflect.Modifier
        int guru99AccessModifier = guru99ClassObj.getModifiers();
        // Afficher les modificateurs d'accès
        System.out.println("Modificateurs d'accès de la classe sont : " + Modifier.toString(guru99AccessModifier));
    }
}

1. Afficher le nom de la classe en utilisant la méthode getName
2. Afficher le nom de la super-classe en utilisant getSuperClass().getName()
3. Afficher le nom des interfaces implémentées
4. Afficher les modificateurs d'accès utilisés par la classe

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

Les exemples suivants montrent comment obtenir les métadonnées d'une variable :

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

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

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

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

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

2. Obtenir les métadonnées sous forme de tableau de Field en utilisant les méthodes getFields() ou getDeclaredFields() comme ci-dessous :

   Field[] guru99Field1 = guru99ClassObjVar.getFields();
   Field[] guru99Field2 = guru99ClassObjVar.getDeclaredFields();

getFields() retourne les métadonnées des variables publiques de la classe spécifiée ainsi que de sa super-classe.

getDeclaredFields() retourne les métadonnées de toutes les variables de la classe spécifiée uniquement.

3. Obtenir le nom des variables en utilisant la méthode "public String getName()".
4. Obtenir le type de données des variables en utilisant "public Class getType()".
5. Obtenir la valeur de la variable en utilisant "public xxx get(Field)". Ici, xxx peut être un byte, short ou tout type de valeur que nous voulons récupérer.
6. Obtenir les modificateurs d'accès des variables en utilisant getModifier() et Modifier.toString(int i).

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

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

public class Guru99TestMetadonneesVariable {
    public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException {
        // Créer un objet Class pour Guru99MetadonneesVariable.class
        Guru99MetadonneesVariable guru99ClassVar = new Guru99MetadonneesVariable();
        Class guru99ClassObjVar = guru99ClassVar.getClass();
        // Obtenir les métadonnées de tous les champs de la classe Guru99MetadonneesVariable
        Field[] guru99Field1 = guru99ClassObjVar.getDeclaredFields();
        // Afficher le nom, types de données, modificateurs d'accès et valeurs des variables de la classe spécifiée
        for (Field field : guru99Field1) {
            System.out.println("Nom de la variable : " + field.getName());
            System.out.println("Type de données de la variable : " + field.getType());
            int guru99AccessModifiers = field.getModifiers();
            System.out.println("Modificateurs d'accès de la variable : " + Modifier.toString(guru99AccessModifiers));
            System.out.println("Valeur de la variable : " + field.get(guru99ClassVar));
            System.out.println();
            System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");
        }
    }
}

1. Créé objet de classe pour Guru99MetadonneesVariable.class
2. Obtenu toutes les métadonnées des variables dans un tableau Field
3. Affiché tous les noms de variables dans la classe Guru99MetadonneesVariable.class
4. Affiché tous les types de données des variables dans la classe Guru99MetadonneesVariable.class
5. Affiché tous les modificateurs d'accès des variables dans la classe Guru99MetadonneesVariable.class
6. Affiché les valeurs de toutes les variables dans la classe Guru99MetadonneesVariable.class

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

Les exemples suivants montrent comment obtenir les métadonnées d'une méthode :

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

package guru;
import java.sql.SQLException;

public class Guru99MetadonneesMethode {
    public void guru99Ajouter(int premierElement, int deuxiemeElement, String resultat) throws ClassNotFoundException, ClassCastException {
        System.out.println("Méthode de démo pour API Reflection");
    }
    public String guru99Rechercher(String chaineRecherche) throws ArithmeticException, InterruptedException {
        System.out.println("Méthode de démo pour API Reflection");
        return null;
    }
    public void guru99Supprimer(String chaineSuppression) throws SQLException {
        System.out.println("Méthode de démo pour API Reflection");
    }
}

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

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

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

2. Obtenir les informations de méthode dans un tableau Method en utilisant getMethods() et getDeclaredMethods() :

   Method[] guru99Method1 = guru99ClassObjVar.getMethods();
   Method[] guru99Method2 = guru99ClassObjVar.getDeclaredMethods();

   getMethods() retourne les métadonnées des méthodes publiques de la classe spécifiée ainsi que de sa super-classe.

   getDeclaredMethods() retourne les métadonnées de toutes les méthodes de la classe spécifiée uniquement.

3. Obtenir le nom de la méthode en utilisant getName().
4. Obtenir le type de retour de la méthode en utilisant getReturnType().
5. Obtenir les modificateurs d'accès des méthodes en utilisant getModifiers() et Modifier.toString(int i).
6. Obtenir les types de paramètres de la méthode en utilisant getParameterTypes() qui retourne un tableau de Class.
7. Obtenir les exceptions lancées en utilisant getExceptionTypes() qui retourne un tableau de Class.

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

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

public class Guru99TestMetadonneesMethode {
    public static void main(String[] args) {
        // Créer objet Class pour Guru99MetadonneesMethode.class
        Class guru99ClassObj = Guru99MetadonneesMethode.class;
        // Obtenir les métadonnées de toutes les méthodes de la classe en utilisant getDeclaredMethods()
        Method[] guru99Methods = guru99ClassObj.getDeclaredMethods();
        for (Method method : guru99Methods) {
            // Afficher les noms des méthodes
            System.out.println("Nom de la méthode : " + method.getName());
            // Afficher le type de retour des méthodes
            System.out.println("Type de retour de la méthode : " + method.getReturnType());
            // Obtenir la liste des modificateurs d'accès et l'afficher
            int guru99ModifierList = method.getModifiers();
            System.out.println("Modificateurs d'accès de la méthode : " + Modifier.toString(guru99ModifierList));
            // Obtenir et afficher les paramètres des méthodes
            Class[] guru99ParamList = method.getParameterTypes();
            System.out.print("Types de paramètres de la méthode : ");
            for (Class class1 : guru99ParamList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();
            // Obtenir et afficher les exceptions lancées par la méthode
            Class[] guru99ExceptionList = method.getExceptionTypes();
            System.out.print("Exceptions lancées par la méthode : ");
            for (Class class1 : guru99ExceptionList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();
            System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");
        }
    }
}

1. Créé objet de classe pour Guru99MetadonneesMethode.class
2. Obtenu toutes les métadonnées de toutes les méthodes dans un tableau Method
3. Affiché tous les noms de méthodes présents dans la classe Guru99MetadonneesMethode.class
4. Affiché les types de retour des méthodes dans la classe Guru99MetadonneesMethode.class
5. Affiché tous les modificateurs d'accès des méthodes dans la classe Guru99MetadonneesMethode.class
6. Affiché les types de paramètres des méthodes dans Guru99MetadonneesMethode.class
7. Affiché les exceptions lancées par les méthodes dans Guru99MetadonneesMethode.class

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

Les exemples suivants montrent comment obtenir les métadonnées des constructeurs :

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

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

public class Guru99Constructeur {
    public Guru99Constructeur(int no) throws ClassCastException, ArithmeticException {
    }
    public Guru99Constructeur(int no, String nom) throws RemoteException, SQLException {
    }
    public Guru99Constructeur(int no, String nom, String adresse) 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 Guru99TestMetadonneesConstructeur {
    public static void main(String[] args) {
        // Créer objet Class pour Guru99Constructeur.class
        Class guru99Class = Guru99Constructeur.class;
        // Obtenir toutes les informations des constructeurs dans le tableau Constructor
        Constructor[] guru99ConstructorList = guru99Class.getConstructors();
        for (Constructor constructor : guru99ConstructorList) {
            // Afficher le nom de chaque constructeur
            System.out.println("Nom du constructeur : " + constructor.getName());
            // Obtenir et afficher les modificateurs d'accès de chaque constructeur
            int guru99Modifiers = constructor.getModifiers();
            System.out.println("Modificateurs du constructeur : " + Modifier.toString(guru99Modifiers));
            // Obtenir et afficher les types de paramètres
            Class[] guru99ParamList = constructor.getParameterTypes();
            System.out.print("Types de paramètres du constructeur : ");
            for (Class class1 : guru99ParamList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();
            // Obtenir et afficher les exceptions lancées par les constructeurs
            Class[] guru99ExceptionList = constructor.getExceptionTypes();
            System.out.println("Exceptions lancées par les constructeurs :");
            for (Class class1 : guru99ExceptionList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();
            System.out.println("*******************************************");
        }
    }
}

1. Créé objet de classe pour Guru99Constructeur.class
2. Obtenu toutes les métadonnées de tous les constructeurs dans un tableau Constructor
3. Affiché tous les noms de constructeurs présents dans la classe Guru99Constructeur.class
4. Affiché tous les modificateurs d'accès des constructeurs dans la classe Guru99Constructeur.class
5. Affiché les types de paramètres des constructeurs dans Guru99Constructeur.class
6. Affiché les exceptions lancées par les constructeurs dans Guru99Constructeur.class

Résumé :

• La programmation par réflexion en Java aide à récupérer et modifier des informations sur les Classes et leurs membres (variables, méthodes, constructeurs).
• L'API Reflection en Java peut être implémentée en utilisant les classes du package java.lang.reflect et les méthodes de la classe java.lang.Class.
• Certaines méthodes couramment utilisées de java.lang.Class sont getName(), getSuperclass(), getInterfaces(), getModifiers() etc.
• Certaines classes couramment utilisées dans java.lang.reflect sont Field, Method, Constructor, Modifier, etc.
• L'API Reflection peut accéder aux méthodes et variables privées d'une classe, ce qui pourrait être une menace de sécurité.
• L'API Reflection est une capacité puissante fournie par Java, mais elle s'accompagne de certains inconvénients tels que des performances plus lentes, une vulnérabilité de sécurité et des problèmes de permissions. Par conséquent, l'API Reflection doit être traitée comme dernier recours pour effectuer une opération.