Cos'è la riflessione in Java?
Java Reflection è il processo di analisi e modifica di tutte le capacità di una classe in fase di runtime. L'API Reflection in Java viene utilizzata per manipolare la classe ei 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.
In questo tutorial imparerai-
- Cos'è la riflessione
- Classe nel pacchetto java.lang.reflect
- Metodi utilizzati in java.lang.Class
- Come ottenere informazioni complete su una classe
- Esempio 1: come ottenere i metadati di Class
- Esempio 2: come ottenere i metadati della variabile
- Esempio 3: come ottenere i metadati del metodo
- Esempio 4: come ottenere i metadati dei costruttori
Classe nel pacchetto java.lang.reflect
Di seguito è riportato un elenco di varie classi Java in java.lang.package per implementare la reflection-
- Campo : 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 parametro e tipo di eccezione di un metodo.
- Costruttore : questa classe viene utilizzata per raccogliere informazioni dichiarative come modificatore di accesso, nome e tipi di parametro di un costruttore.
- Modificatore : questa classe viene utilizzata per raccogliere informazioni su un particolare modificatore di accesso.
Metodi utilizzati in java.lang.Class
- Public String getName () : restituisce il nome della classe.
- public Class getSuperclass () : restituisce il riferimento alla super classe
- Classe pubblica [] getInterfaces () : restituisce un array di interfacce implementate dalla classe specificata
- Public in getModifiers (): restituisce un valore intero che rappresenta i modificatori della classe specificata che deve essere passato come parametro al metodo " public static String toString (int i)" 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, è necessario creare un oggetto della classe.public class Guru99ClassObjectCreation {public static void main (String[] args) throws ClassNotFoundException {//1 - By using Class.forname() methodClass c1 = Class.forName("Guru99ClassObjectCreation");//2- By using getClass() methodGuru99ClassObjectCreation guru99Obj = new Guru99ClassObjectCreation();Class c2 = guru99Obj.getClass();//3- By using .classClass c3= Guru99ClassObjectCreation.class;}}
Esempio 1: come ottenere i metadati di Class
L'esempio seguente mostra come ottenere metadati quali: nome della classe, nome della super classe, interfacce implementate e modificatori di accesso di una classe.
Otterremo i metadati della seguente classe 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: pubblico e astratto
- Ha implementato interfacce: Serializzabile e Clonabile
- Poiché non ha esteso esplicitamente alcuna classe, la sua super classe è: java.lang.Object
import java.lang.reflect.Modifier;public class Guru99GetclassMetaData {public static void main (String [] args) throws ClassNotFoundException {// Create Class object for Guru99Base.classClass guru99ClassObj = Guru99Base.class;// Print name of the classsystem.out.println("Name of the class is : " +guru99ClassObj.getName());// Print Super class namesystem.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() methodclass[] guru99InterfaceList = guru99classObj.getInterfaces();// Print the implemented interfaces using foreach loopsystem.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 classint guru99AccessModifier= guru99classObj.getModifiers();// Print the access modifiersSystem.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 usando il metodo getSuperClass (). GetName ()
- Stampa il nome delle interfacce implementate
- Stampa i modificatori di accesso usati dalla classe
Esempio 2: come ottenere i metadati della variabile
I seguenti esempi 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 array di campi utilizzando i metodi getFields () o getDeclaredFields () come di seguito:
Field[] guru99Field1= guru99ClassObjVar .getFields();Field[] guru99Fiel2= guru99ClassObjVar .getDeclaredFields();
Il metodo getFields () restituisce i metadati della variabile pubblica dalla classe specificata e dalla sua super classe.
Il metodo getDeclaredFields () 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 una scorciatoia 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.classGuru99VariableMetaData guru99ClassVar = new Guru99VariableMetaData();Class guru99ClassObjVar = guru99ClassVar.getClass();// Get the metadata of all the fields of the class Guru99VariableMetaDataField[] guru99Field1= guru99ClassObjVar.getDeclaredFields();// Print name, datatypes, access modifiers and values of the varibales of the specified classfor(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
- Ottenuto tutti i metadati delle variabili in un array Field
- Ha stampato tutti i nomi delle variabili nella classe Guru99VariableMetaData.class
- Stampato tutti i tipi di dati delle variabili nella classe Guru99VariableMetaData.class
- Stampati tutti i modificatori di accesso delle variabili nella classe Guru99VariableMetaData.class
- Stampato i valori di tutte le variabili in Stampato 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 di metodi utilizzando il metodo getMethods () e getDeclaredMethods () come di seguito:
Method[] guru99 Method 1= guru99ClassObjVar .get Methods();Method [] guru99 Method 2= guru99ClassObjVar .getDeclared Method s();
Il metodo getMethods () restituisce i metadati dei metodi pubblici dalla classe specificata e dalla sua super classe.
Il metodo getDeclaredMethods () restituisce i metadati di tutti i metodi solo dalla classe specificata.
- Ottieni il nome del metodo usando il metodo getName () .
- Ottieni il tipo di ritorno del metodo utilizzando il metodo getReturnType () .
- Ottieni modificatori di accesso dei metodi utilizzando i metodi getModifiers () e Modifiers.toString (int i) .
- Ottieni i tipi di parametro del metodo utilizzando il metodo getParameterTypes () che restituisce un array di classi.
- Ottieni un'eccezione generata utilizzando il metodo getExceptionTypes () che restituisce un array di classi.
- Oggetto classe creato per Guru99MethodMetaData.class
- Ottenuto tutti i metadati di tutti i metodi in un array di metodi
- Stampato tutti i nomi dei metodi presenti nella classe Guru99MethodMetaData.class
- Tipi restituiti stampati dei metodi nella classe Guru99MethodMetaData.class
- Stampato 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
- Ottenuto tutti i metadati di tutti i costruttori in un array Constructor
- Ha stampato tutti i nomi dei costruttori presenti nella classe Guru99Constructor.class
- Stampato 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 delle classi come variabili, metodi e costruttori.
- L'API Reflection in Java può essere implementata utilizzando le classi nel 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 per la sicurezza.
- L'API di riflessione è una potente funzionalità fornita da Java, ma presenta alcuni costi generali come prestazioni più lente, vulnerabilità di sicurezza e problemi di autorizzazione. Pertanto, l'API di riflessione dovrebbe essere trattata come l'ultima risorsa per eseguire un'operazione.
Esempio 3: come ottenere i metadati del metodo
I seguenti esempi 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.classclass 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 namesSystem.out.println("Name of the method : "+method.getName());// Print return type of the methodsSystem.out.println("Return type of the method : "+method.getReturnType());//Get the access modifier list and printint guru99ModifierList = method.getModifiers();System.Out.printlin ("Method access modifiers : "+Modifier.toString(guru99ModifierList));// Get and print parameters of the methodsClass[] 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 methodClass[] 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
I seguenti esempi 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.classClass guru99Class=Guru99Constructor.class;// Get all the constructor information in the Constructor arrayConstructor[] guru99ConstructorList = guru99Class.getConstructors();for (Constructor constructor : guru99ConstructorList) {// Print all name of each constructorSystem.out.println("Constrcutor name : "+constructor.getName());//Get and print access modifiers of each constructorint guru99Modifiers= constructor.getModifiers();System.Out.printlin ("Constrctor modifier : "+Modifier.toString(guru99Modifiers));// Get and print parameter typesClass[] 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 constructorsClass[] 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("*******************************************");}}}
Sommario: