Java Tutorial sull'API Reflection con esempio
James Hartmann
In cosa consiste la Riflessione Java?
Java La riflessione è il processo di analisi e modifica di tutte le funzionalità di una classe in fase di esecuzione. API di riflessione in Java viene utilizzato per manipolare la classe e i suoi membri che includono campi, metodi, costruttore, ecc. in fase di esecuzione.
Un vantaggio dell'API di riflessione in Java è che può manipolare anche i membri privati della classe.
Il pacchetto java.lang.reflect fornisce molte classi per implementare la riflessione java.Methods della classe java.lang.Class viene utilizzato per raccogliere i metadati completi di una particolare classe.
Classe nel pacchetto java.lang.reflect
Di seguito è riportato un elenco di vario Java classi in java.lang.package per implementare la riflessione-
- Settore: questa classe viene utilizzata per raccogliere informazioni dichiarative come tipo di dati, modificatore di accesso, nome e valore di una variabile.
- Metodo: questa classe viene utilizzata per raccogliere informazioni dichiarative come modificatore di accesso, tipo restituito, nome, tipi di parametri e tipo di eccezione di un metodo.
- Costruttore: questa classe viene utilizzata per raccogliere informazioni dichiarative come modificatore di accesso, nome e tipi di parametri di un costruttore.
- Modificare: questa classe viene utilizzata per raccogliere informazioni su un particolare modificatore di accesso.
Metodi utilizzati in java.lang.Class
- Stringa pubblica getName (): Restituisce il nome della classe.
- Classe pubblica getSuperclass(): Restituisce il riferimento alla superclasse
- Classe pubblica[] getInterfaces() : Restituisce un array di interfacce implementate dalla classe specificata
-
Pubblico in getModifiers (): Restituisce un valore intero che rappresenta i modificatori della classe specificata che deve essere passato come parametro a "stringa statica pubblica toString (int i )” metodo che restituisce lo specificatore di accesso per la classe data.
Come ottenere informazioni complete su una classe
Per ottenere informazioni su variabili, metodi e costruttori di una classe, dobbiamo creare un oggetto della 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;
}
}
Esempio 1: come ottenere i metadati della classe
L'esempio seguente mostra come ottenere metadati quali: nome della classe, nome della superclasse, interfacce implementate e modificatori di accesso di una classe.
Otterremo i metadati della classe seguente denominata Guru99Base.class:
import java.io.Serializable;
public abstract class Guru99Base implements Serializable,Cloneable {
}
- Il nome della classe è: Guru99Base
- I suoi modificatori di accesso sono: public e abstract
- Ha implementato interfacce: serializzabile e clonabile
- Poiché non ha esteso esplicitamente alcuna classe, la sua super classe è: java.lang.Object
La classe seguente otterrà i metadati di Guru99Base.class e li stamperà:
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));
}
}
- stampa il nome della classe usando il metodo getName
- Stampa il nome della super classe utilizzando il metodo getSuperClass().getName()
- Stampa il nome delle interfacce implementate
- Stampa i modificatori di accesso utilizzati dalla classe
Esempio 2: come ottenere i metadati della variabile
Gli esempi seguenti mostrano come ottenere i metadati della variabile:
Qui stiamo creando una classe denominata Guru99VariableMetaData .class con alcune variabili:
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";
}
Passaggi per ottenere i metadati sulle variabili nella classe precedente:
-
Crea l'oggetto classe della classe precedente, ovvero Guru99VariableMetaData.class come di seguito:
Guru99VariableMetaData guru99ClassVar = new Guru99VariableMetaData(); Class guru99ClassObjVar = guru99ClassVar.getClass();
-
Ottieni i metadati sotto forma di matrice di campi utilizzando getFields() or getDeclaredFields() metodi come di seguito:
Field[] guru99Field1= guru99ClassObjVar .getFields(); Field[] guru99Fiel2= guru99ClassObjVar .getDeclaredFields();
getFields() Il metodo restituisce i metadati della variabile pubblica dalla classe specificata e dalla sua super classe.
getDeclaredFields() Il metodo restituisce i metadati di tutte le variabili solo della classe specificata.
- Ottieni il nome delle variabili utilizzando il metodo "public String getName()".
- Ottieni il tipo di dati delle variabili utilizzando il metodo "public Class getType()".
-
Ottieni il valore della variabile utilizzando il metodo "public xxx get (Field)".
Qui, xxx potrebbe essere un byte o meno di qualsiasi tipo di valore che vogliamo recuperare.
-
Ottieni i modificatori di accesso delle variabili utilizzando i metodi getModifier() e Modifier.toString(int i).
Qui stiamo scrivendo una classe per ottenere i metadati delle variabili presenti nella 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("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *") ; } } } - Oggetto classe creato per Guru99VariableMetaData.class
- Ho ottenuto tutti i metadati delle variabili in un array Field
- Stampato tutti i nomi delle variabili nella classe Guru99VariableMetaData.class
- Stampati tutti i tipi di dati delle variabili nella classe Guru99VariableMetaData.class
- Stampati tutti i modificatori di accesso delle variabili nella classe Guru99VariableMetaData.class
- Valori stampati di tutte le variabili in Stampati tutti i tipi di dati delle variabili nella classe Guru99VariableMetaData.class
-
Crea l'oggetto classe della classe precedente, ovvero Guru99MethodMetaData.class come di seguito:
Guru99MethodMetaData guru99ClassVar = new Guru99MethodMetaData (); Class guru99ClassObjVar = guru99ClassVar.getClass();
-
Ottieni informazioni sul metodo in un array Method utilizzando getMethods() e il metodo getDeclaredMethods() come di seguito:
Method[] guru99 Method 1= guru99ClassObjVar .get Methods(); Method [] guru99 Method 2= guru99ClassObjVar .getDeclared Method s();
getMetodi() Il metodo restituisce i metadati dei metodi pubblici dalla classe specificata e dalla sua super classe.
getDeclaredMethods() Il metodo restituisce i metadati di tutti i metodi solo della classe specificata.
- Ottieni il nome del metodo utilizzando getName () metodo.
- Ottieni il tipo restituito del metodo utilizzando getReturnType() metodo.
- Ottieni i modificatori di accesso dei metodi utilizzando getModifiers() e Modificatori.toString(int i) metodi.
- Ottieni i tipi di parametri del metodo utilizzando getParameterTypes() metodo che restituisce un array di classi.
-
Ottieni un'eccezione generata utilizzando getExceptionTypes() metodo che restituisce un array di classi.
- Oggetto classe creato per Guru99MethodMetaData.class
- Ho ottenuto tutti i metadati di tutti i metodi in un array di metodi
- Stampati tutti i nomi dei metodi presenti nella classe Guru99MethodMetaData.class
- Tipi restituiti stampati dei metodi nella classe Guru99MethodMetaData.class
- Stampati tutti i modificatori di accesso dei metodi nella classe Guru99MethodMetaData.class
- Tipi di parametri stampati dei metodi in Guru99MethodMetaData.class
-
Le eccezioni stampate vengono generate dai metodi in Guru99MethodMetaData.class
- Oggetto classe creato per Guru99Constructor.class
- Ho ottenuto tutti i metadati di tutti i costruttori in un array Costruttore
- Stampati tutti i nomi dei costruttori presenti nella classe Guru99Constructor.class
- Stampati tutti i modificatori di accesso dei costruttori nella classe Guru99Constructor.class
- Tipi di parametri stampati dei costruttori in Guru99Constructor.class
- Le eccezioni stampate vengono lanciate dai costruttori in Guru99Constructor.class
- La programmazione della riflessione in Java aiuta a recuperare e modificare le informazioni sulle classi e sui membri della classe come variabili, metodi, costruttori.
- API di riflessione in Java può essere implementato utilizzando le classi del pacchetto java.lang.reflect e i metodi della classe java.lang.Class.
- Alcuni metodi comunemente usati della classe java.lang.Class sono getName (), getSuperclass (), getInterfaces (), getModifiers () ecc.
- Alcune classi comunemente utilizzate nel pacchetto java.lang.reflect sono Field, Method, Constructor, Modifier, ecc.
- L'API Reflection può accedere a metodi e variabili privati di una classe che potrebbero rappresentare una minaccia alla sicurezza.
- L'API Reflection è una potente funzionalità fornita da Java, ma comporta alcuni overhead come prestazioni più lente, vulnerabilità di sicurezza e problemi di autorizzazione. Quindi, la reflection API dovrebbe essere considerata come l'ultima risorsa per eseguire un'operazione.
Esempio 3: come ottenere i metadati del metodo
Gli esempi seguenti mostrano come ottenere i metadati di un metodo:
Qui stiamo creando una classe denominata Guru99MethodMetaData .class con alcuni metodi
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");
}
}
Passaggi per ottenere i metadati sui metodi nella classe precedente:
Qui stiamo scrivendo una classe per ottenere i metadati dei metodi presenti nella 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("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ");
}
}
}
Esempio 4: come ottenere i metadati dei costruttori
Gli esempi seguenti mostrano come ottenere i metadati dei costruttori:
Qui stiamo creando una classe denominata Guru99Constructor.class con diversi costruttori:
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{ }
}
Qui stiamo scrivendo una classe per ottenere i metadati dei costruttori presenti nella 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("*******************************************");
}
}
}
