Tutoriel de l'API Java Reflection avec exemple

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

Java Reflection est le processus d'analyse et de modification de toutes les capacités d'une classe au moment de l'exécution. L'API de réflexion en Java est utilisée pour manipuler la classe et ses membres qui incluent des champs, des méthodes, un constructeur, etc. au moment de l'exécution.

L'un des avantages de l'API de réflexion en Java est qu'elle 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 java.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 didacticiel, vous apprendrez-

• Qu'est-ce que la réflexion ?
• Classe 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 de la classe
• Exemple 2 :Comment obtenir les métadonnées d'une variable
• Exemple 3 :Comment obtenir les métadonnées de la méthode
• Exemple 4 :Comment obtenir les métadonnées des constructeurs

Classe dans le package java.lang.reflect

Voici une liste des différentes classes Java dans java.lang.package pour implémenter la réflexion-

• Champ  :Cette classe est utilisée pour 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.
• Méthode  :Cette classe est utilisée pour collecter 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 collecter 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 est utilisée pour recueillir des informations sur un modificateur d'accès particulier.

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

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

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;
		}
	}

L'exemple suivant montre différentes manières de créer un objet de la classe "class" :

Exemple 1 :Comment obtenir les métadonnées de la classe

L'exemple suivant montre comment obtenir des métadonnées telles que :le nom de la classe, le nom de la super classe, les interfaces implémentées et les 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. Le nom de la classe est :Guru99Base
2. Ses modificateurs d'accès sont :public et abstrait
3. Il a implémenté des interfaces :sérialisables et clonables
4. Puisqu'il n'a étendu aucune classe explicitement, sa super classe est :java.lang.Object

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

import java.lang.reflect.Modifier;
public class Guru99GetclassMetaData {

	public static void main (String [] args) throws ClassNotFoundException { 
	// Create Class object for Guru99Base.class 
	Class 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 in the form of Class array using getInterface() method
	class[] guru99InterfaceList = guru99classObj.getInterfaces();
	
	// Print the implemented interfaces using foreach loop 
	system.out.print("Implemented interfaces are : ");
	for (Class guru99class1 : quru99 InterfaceList)	{
		system.out.print guru99class1.getName() + " ");
	}
	system.out.println();
	
	//Get access modifiers using get Modifiers() method and toString() method of java.lang.reflect.Modifier class
	int guru99AccessModifier= guru99classObj.getModifiers(); 
	// Print the access modifiers
	System.Out.println("Access modifiers of the class are : " +Modifier.tostring(guru99AccessModifier));
	
	}
}

1. imprimer le nom de la classe en utilisant la méthode getName
2. Afficher le nom de la super classe à l'aide de la méthode getSuperClass().getName()
3. Imprimer 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 de la 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 :

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

2. Obtenez les métadonnées sous la forme d'un tableau de champs à l'aide de getFields() ou getDeclaredFields() méthodes comme ci-dessous :

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

getFields() renvoie les métadonnées de la variable publique de la classe spécifiée ainsi que de sa super classe.

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

3. Obtenez le nom des variables à l'aide de la méthode "public String getName()".
4. Obtenez le type de données des variables à l'aide de la méthode "public Class getType()".
5. Obtenez la valeur de la variable à l'aide de la méthode "public xxx get (Field)".

   Ici, xxx peut être un octet ou un court de n'importe quel type de valeur que nous voulons récupérer.

6. Obtenez les modificateurs d'accès des variables à l'aide des méthodes getModifier() 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; 
   
   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 Guru99VariableMetaData 
   	Field[] guru99Field1= guru99ClassObjVar.getDeclaredFields();
   	
   	// Print name, datatypes, access modifiers and values of the varibales of the specified class 
   	for(Field field : guru99Field1) { 
   	System.out.println("Variable name : "+field.getName());
   	System.out.println("Datatypes of the variable :"+field.getType());
   	
   	int guru99AccessModifiers = field.getModifiers();
   	System.out.printlln("Access Modifiers of the variable : "+Modifier.toString(guru99AccessModifiers));
   	System.out.println("Value of the variable : "+field.get(guru99ClassVar));
   	System.out.println();
   	system.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *") ;
   	}
   	}
   }
   

1. Objet de classe créé pour Guru99VariableMetaData.class
2. Obtenir toutes les métadonnées des variables dans un tableau Field
3. Imprimé tous les noms de variables dans la classe Guru99VariableMetaData.class
4. Impression de tous les types de données des variables de la classe Guru99VariableMetaData.class
5. Imprimé tous les modificateurs d'accès des variables de la classe Guru99VariableMetaData.class
6. Valeurs imprimées de toutes les variables dans Imprimé tous les types de données des variables dans la classe Guru99VariableMetaData.class



Exemple 3 :Comment obtenir les métadonnées de la méthode

Les exemples suivants montrent 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 Reflextion  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 sur les méthodes de la classe ci-dessus :

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

2. Obtenez les informations de méthode dans un tableau Method en utilisant les méthodes getMethods() et getDeclaredMethods() comme ci-dessous :

   Method[]  guru99 Method 1= guru99ClassObjVar .get Methods();
   Method []  guru99 Method 2= guru99ClassObjVar .getDeclared Method s();

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

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

3. Obtenez le nom de la méthode en utilisant getName() méthode.
4. Obtenez le type de retour de la méthode en utilisant getReturnType() méthode.
5. Obtenir les modificateurs d'accès des méthodes à l'aide de getModifiers() et Modifiers.toString(int i) méthodes.
6. Obtenir les types de paramètres de méthode à l'aide de getParameterTypes() méthode qui renvoie un tableau de classe.
7. Obtenir une exception levée à l'aide de getExceptionTypes() méthode qui renvoie un tableau de classe.

Ici, nous écrivons une classe pour récupérer 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 Guru99Method MetaData.class 
		class guru99ClassObj = Guru99MethodMetaData.class;

		// Get the metadata or information of all the methods of the class using getDeclaredMethods() 
		Method[] guru99Methods=guru99classObj.getDeclaredMethods();

		for(Method method : guru99Methods) { 
		// Print the method names
		System.out.println("Name of the method : "+method.getName());
		
		// Print return type of the methods 
		System.out.println("Return type of the method : "+method.getReturnType());
		
		//Get the access modifier list and print
		int guru99ModifierList = method.getModifiers(); 
		System.Out.printlin ("Method access modifiers : "+Modifier.toString(guru99ModifierList));
		
		// Get and print parameters of the methods 
		Class[] guru99ParamList= method.getParameterTypes(); 
		system.out.print ("Method parameter types : "); 
		for (Class class1 : guru99ParamList){ 
			System.out.println(class1.getName()+" ");
		}
        System.out.println();
		
		// Get and print exception thrown by the method 
		Class[] guru99ExceptionList = method. getExceptionTypes(); 
		system.out.print("Excpetion thrown by method :"); 
		for (Class class1 : guru99ExceptionList) {
			System.out.println (class1.getName() +" "):
		} 
		System.Out.println(); 
		system.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ");
		
		}
 
	}
}

1. Objet de classe créé pour Guru99MethodMetaData.class
2. Obtenir toutes les métadonnées de toutes les méthodes dans un tableau de méthodes
3. Imprimé tous les noms de méthodes présents dans la classe Guru99MethodMetaData.class
4. Types de retour imprimés des méthodes de la classe Guru99MethodMetaData.class
5. Imprimé tous les modificateurs d'accès des méthodes de la classe Guru99MethodMetaData.class
6. Types de paramètres imprimés des méthodes dans Guru99MethodMetaData.class
7. Les exceptions imprimées sont levées par les méthodes de Guru99MethodMetaData.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 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 récupérer les métadonnées des constructeurs présents dans la classe Guru99Constructor.class :



package guru;
import java.lang.reflect.Constructor; 
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) {
			// Print all name of each constructor
			System.out.println("Constrcutor name : "+constructor.getName());
			
			//Get and print access modifiers of each constructor 
			int guru99Modifiers= constructor.getModifiers(); 
			System.Out.printlin ("Constrctor modifier : "+Modifier.toString(guru99Modifiers));
			
			// Get and print parameter types 
			Class[] guru99ParamList=constructor.getParameterTypes();
			System.out.print ("Constrctor parameter types :"); 
			for (Class class1 : guru99ParamList) { 
				System.out.println(class1.getName() +" ");
			}
			System. out.println();

			// Get and print exception thrown by constructors
			Class[] guru99ExceptionList=constructor.getFxceptionTypes();
			System.out.println("Exception thrown by constructors :"); 
			for (Class class1 : guru99ExceptionList) { 
				System.out.println(class1.getName() +" ");
			} 
			System.out.println();
			System.out.println("*******************************************");
		}
	}
}
 

1. Objet de classe créé pour Guru99Constructor.class
2. Obtenir toutes les métadonnées de tous les constructeurs dans un tableau Constructor
3. Impression de tous les noms de constructeurs présents dans la classe Guru99Constructor.class
4. Imprimé tous les modificateurs d'accès des constructeurs de la classe Guru99Constructor.class
5. Types de paramètres imprimés des constructeurs dans Guru99Constructor.class
6. Les exceptions imprimées sont lancées par les constructeurs dans Guru99Constructor.class





Résumé :

• La programmation de réflexion en Java aide à récupérer et à modifier les informations sur les classes et les membres de classe tels que les variables, les méthodes et les constructeurs.
• L'API Reflection en Java peut être implémentée à l'aide des classes du package java.lang.reflect et des méthodes de la classe java.lang.Class.
• Certaines méthodes couramment utilisées de la classe java.lang.Class sont getName (), getSuperclass (), getInterfaces (), getModifiers () etc.
• Certaines classes couramment utilisées dans le package 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 qui pourraient constituer une menace pour la sécurité.
• L'API Reflection est une fonctionnalité puissante fournie par Java, mais elle s'accompagne de certains surcoûts, tels qu'un ralentissement des performances, une vulnérabilité de sécurité et un problème d'autorisation. Par conséquent, l'API de réflexion doit être considérée comme le dernier recours pour effectuer une opération.