Java Tutoriel API Reflection avec exemple
James Hartmann
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 au moment de l'exécution. API de réflexion dans Java est utilisé pour manipuler la classe et ses membres qui incluent des champs, des méthodes, un constructeur, etc. au moment de l'exécution.
Un avantage de l'API de réflexion dans Java c'est-à-dire qu'il peut également manipuler des 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.
Classe dans le package java.lang.reflect
Voici une liste de divers Java les classes dans java.lang.package pour implémenter la réflexion-
- Champ: Cette classe est utilisée pour rassembler 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 rassembler 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 rassembler 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 est utilisée pour collecter 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 à «chaîne statique publique 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;
}
}
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 classe, le nom de 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 {
}
- Le nom de la classe est : Guru99Base
- Ses modificateurs d'accès sont : public et abstrait
- Il a implémenté des interfaces : sérialisable et clonable
- Puisqu'elle n'a étendu explicitement aucune classe, 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));
}
}
- imprimer le nom de la classe en utilisant la méthode getName
- Imprimez le nom de la super classe en utilisant la méthode getSuperClass().getName()
- Imprimer le nom des interfaces implémentées
- Imprimer 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 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();
-
Obtenez 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[] guru99Fiel2= guru99ClassObjVar .getDeclaredFields();
getFields() La méthode 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 uniquement les métadonnées de toutes les variables de la classe spécifiée.
- Obtenez le nom des variables en utilisant la méthode « public String getName() ».
- Obtenez le type de données des variables en utilisant la méthode « public Class getType() ».
-
Obtenez la valeur de la variable en utilisant la méthode « public xxx get (Field) ».
Ici, xxx peut être un octet ou une valeur courte de tout type de valeur que nous souhaitons récupérer.
-
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 récupérer 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("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *") ; } } } - Objet de classe créé pour Guru99VariableMetaData.class
- Vous avez toutes les métadonnées des variables dans un tableau Field
- Imprimé tous les noms de variables dans la classe Guru99VariableMetaData.class
- Imprimé tous les types de données des variables de la classe Guru99VariableMetaData.class
- Imprimé tous les modificateurs d'accès des variables de la classe Guru99VariableMetaData.class
- Valeurs imprimées de toutes les variables dans Imprimé tous les types de données des variables de la classe Guru99VariableMetaData.class
-
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 des informations sur la méthode dans un tableau Method à l’aide des méthodes getMethods() et getDeclaredMethods() comme ci-dessous :
Method[] guru99 Method 1= guru99ClassObjVar .get Methods(); Method [] guru99 Method 2= guru99ClassObjVar .getDeclared Method s();
getMethods() La méthode renvoie les métadonnées des méthodes publiques de la classe spécifiée ainsi que de sa super classe.
getDeclaredMethods() La 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 Modifiers.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.
-
Obtenez une exception levée en utilisant getExceptionTypes() méthode qui renvoie un tableau de classes.
- Objet de classe créé pour Guru99MethodMetaData.class
- Vous avez toutes les métadonnées de toutes les méthodes dans un tableau de méthodes
- Imprimé tous les noms de méthodes présents dans la classe Guru99MethodMetaData.class
- Types de retour imprimés des méthodes de la classe Guru99MethodMetaData.class
- Imprimé tous les modificateurs d'accès des méthodes de la classe Guru99MethodMetaData.class
- Types de paramètres imprimés des méthodes dans Guru99MethodMetaData.class
-
Les exceptions imprimées sont levées par les méthodes dans Guru99MethodMetaData.class
- Objet de classe créé pour Guru99Constructor.class
- Vous avez toutes les métadonnées de tous les constructeurs dans un tableau Constructor
- Imprimé tous les noms de constructeurs présents dans la classe Guru99Constructor.class
- Imprimé tous les modificateurs d'accès des constructeurs dans la classe Guru99Constructor.class
- Types de paramètres imprimés des constructeurs dans Guru99Constructor.class
- Les exceptions imprimées sont levées par les constructeurs dans Guru99Constructor.class
- La programmation de réflexion en Java aide à récupérer et à modifier des informations sur les classes et les membres de la classe, telles que les variables, les méthodes et les constructeurs.
- API de réflexion dans Java peut être implémenté à 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 privées et aux variables d'une classe qui pourraient constituer une menace pour la sécurité.
- L'API Reflection est une fonctionnalité puissante fournie par Java, mais cela implique certains frais généraux tels que des performances plus lentes, une vulnérabilité de sécurité et des problèmes d'autorisation. Par conséquent, l'API de réflexion doit être considérée comme le dernier recours pour effectuer une opération.
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 :
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("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ");
}
}
}
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("*******************************************");
}
}
}
