Java Tutorial sull'API Reflection con esempio

⚡ Riepilogo intelligente

Java L'API Reflection analizza e modifica le funzionalità di una classe in fase di esecuzione, inclusi campi, metodi e costruttori. Questa risorsa illustra il pacchetto java.lang.reflect, i metodi principali di java.lang.Class e presenta quattro esempi che leggono i metadati di una classe, una variabile, un metodo e un costruttore.

  • 🔍 Definizione: La reflection analizza e modifica le classi e i loro membri in fase di esecuzione, anche quelli privati.
  • 📦 Pacchetto Reflect: Le classi Field, Method, Constructor e Modifier raccolgono informazioni dichiarative sui membri.
  • 🏷️ Metodi di classe: Le funzioni getName(), getSuperclass(), getInterfaces() e getModifiers() restituiscono i metadati principali della classe.
  • 🧪 Esempi pratici: Quattro programmi extracmetadati di una classe, variabili, metodi e costruttori.
  • ⚠️ Attenzione: Reflection può accedere ai membri privati ​​ed è più lento, quindi usalo solo come ultima risorsa.

Java Tutorial sull'API Reflection

In cosa consiste la Riflessione Java?

Java La reflection è il processo di analisi e modifica di tutte le capacità di una classe in fase di esecuzione. L'API Reflection in Java Viene utilizzato per manipolare una classe e i suoi membri, che includono campi, metodi, costruttori, ecc., in fase di esecuzione.

Un vantaggio dell'API Reflection in Java La sua caratteristica principale è che può manipolare anche i membri privati ​​della classe.

Il pacchetto java.lang.reflect fornisce numerose classi per implementare la reflection. I metodi della classe java.lang.Class vengono utilizzati per raccogliere i metadati completi di una particolare classe.

Classe nel pacchetto java.lang.reflect

Di seguito è riportato un elenco di vario Java classi nel pacchetto java.lang.reflect per implementare la reflection:

  • Settore: Questa classe viene utilizzata per raccogliere informazioni dichiarative come il tipo di dati, il modificatore di accesso, il nome e il valore di una variabile.
  • Metodo: Questa classe viene utilizzata per raccogliere informazioni dichiarative come il modificatore di accesso, il tipo di ritorno, il nome, i tipi di parametro e il tipo di eccezione di un metodo.
  • Costruttore: Questa classe viene utilizzata per raccogliere informazioni dichiarative come il modificatore di accesso, il nome e i tipi di parametro di un costruttore.
  • Modificare: Questa classe viene utilizzata per raccogliere informazioni su uno specifico modificatore di accesso.

Metodi utilizzati in java.lang.Class

  • public String getName(): Restituisce il nome della classe.
  • public Class getSuperclass(): Restituisce il riferimento alla superclasse.
  • public Class[] getInterfaces(): Restituisce un array di interfacce implementate dalla classe specificata.
  • int getModifiers(): pubblico 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 variabiliPer creare un oggetto di una classe, dobbiamo prima definire i metodi e i costruttori. L'esempio seguente mostra diversi modi per creare un oggetto della classe "Class":

Metodi utilizzati in java.lang.Class

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 di una classe

L'esempio seguente mostra come ottenere metadati quali il nome della classe, il nome della superclasse, le interfacce implementate e i modificatori di accesso di una classe.

Otterremo i metadati della classe seguente denominata Guru99Base.class:

Ottieni metadati della classe

import java.io.Serializable;
public abstract class Guru99Base implements Serializable, Cloneable {
}
  1. Il nome della classe è: Guru99 Base
  2. I suoi modificatori di accesso sono: pubblico e assolutotract
  3. Ha implementato interfacce: serializzabile e clonabile
  4. Poiché non ha esteso esplicitamente alcuna classe, la sua superclasse è: java.lang.Object

La classe seguente otterrà i metadati di Guru99Base.class e stampalo:

Ottieni metadati della classe

import java.lang.reflect.Modifier;
public class Guru99GetclassMetaData {
    public static void main(String[] args) throws ClassNotFoundException {
        // Create Class object for Guru99Base.class
        Class<Guru99Base> 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 using getInterfaces() method
        Class[] guru99InterfaceList = guru99ClassObj.getInterfaces();

        // Print the implemented interfaces using a for-each loop
        System.out.print("Implemented interfaces are : ");
        for (Class guru99class1 : guru99InterfaceList) {
            System.out.print(guru99class1.getName() + " ");
        }
        System.out.println();

        // Get access modifiers using getModifiers() and Modifier.toString()
        int guru99AccessModifier = guru99ClassObj.getModifiers();
        System.out.println("Access modifiers of the class are : " + Modifier.toString(guru99AccessModifier));
    }
}
  1. Stampa il nome della classe utilizzando il metodo getName().
  2. Stampa il nome della superclasse utilizzando il metodo getSuperclass().getName().
  3. Stampa i nomi delle interfacce implementate.
  4. Stampa i modificatori di accesso utilizzati dalla classe.

Ottieni metadati della classe

Ottieni metadati della classe

Esempio 2: Come ottenere i metadati di una variabile

L'esempio seguente mostra come ottenere i metadati di una variabile.

Qui stiamo creando una classe chiamata 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:

  1. Crea l'oggetto classe della classe sopra indicata, ovvero: Guru99VariableMetaData.class, come di seguito:
    Guru99VariableMetaData guru99ClassVar = new Guru99VariableMetaData();
    Class guru99ClassObjVar = guru99ClassVar.getClass();
  2. Ottieni i metadati sotto forma di un array di campi utilizzando il getFields() or getDeclaredFields() metodi come di seguito:
    Field[] guru99Field1 = guru99ClassObjVar.getFields();
    Field[] guru99Field2 = guru99ClassObjVar.getDeclaredFields();

Migliori getFields() Il metodo restituisce i metadati delle variabili pubbliche della classe specificata, nonché della sua superclasse.

Migliori getDeclaredFields() Il metodo restituisce i metadati di tutte le variabili appartenenti esclusivamente alla classe specificata.

  1. Ottieni il nome delle variabili utilizzando il metodo “public String getName()”.
  2. Ottieni il tipo di dati delle variabili utilizzando il metodo “public Class getType()”.
  3. Ottieni il valore della variabile utilizzando il metodo "public xxx get(Field)". Qui, xxx può essere un byte, uno short o qualsiasi altro tipo di valore che vogliamo recuperare.
  4. Ottieni i modificatori di accesso delle variabili utilizzando i metodi getModifiers() e Modifier.toString(int i).

Qui stiamo scrivendo una classe per ottenere i metadati delle variabili presenti nella classe Guru99VariableMetaData.class:

Ottieni metadati della variabile

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

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
        Field[] guru99Field1 = guru99ClassObjVar.getDeclaredFields();

        // Print name, data types, access modifiers and values of the variables
        for (Field field : guru99Field1) {
            System.out.println("Variable name : " + field.getName());
            System.out.println("Datatype of the variable : " + field.getType());

            int guru99AccessModifiers = field.getModifiers();
            System.out.println("Access Modifiers of the variable : " + Modifier.toString(guru99AccessModifiers));
            System.out.println("Value of the variable : " + field.get(guru99ClassVar));
            System.out.println();
        }
    }
}
  1. Creato un oggetto di classe per Guru99VariableMetaData.class.
  2. Ho ottenuto tutti i metadati delle variabili in un array di campi.
  3. Stampati tutti i nomi delle variabili nella classe Guru99VariableMetaData.class.
  4. Sono stati stampati tutti i tipi di dati delle variabili della classe.
  5. Sono stati stampati tutti i modificatori di accesso delle variabili della classe.
  6. Sono stati stampati i valori di tutte le variabili della classe.

Ottieni metadati del metodo

Ottieni metadati del metodo

Esempio 3: Come ottenere i metadati di un metodo

L'esempio seguente mostra come ottenere i metadati di un metodo.

Qui stiamo creando una classe chiamata Guru99MethodMetaData.class con alcuni metodi:

Ottieni metadati del metodo

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 Reflection 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");
    }
}

Procedura per ottenere i metadati relativi ai metodi della classe sopra descritta:

  1. Crea l'oggetto classe della classe sopra indicata, ovvero: Guru99MethodMetaData.class, come di seguito:
    Guru99MethodMetaData guru99ClassVar = new Guru99MethodMetaData();
    Class guru99ClassObjVar = guru99ClassVar.getClass();
  2. Ottieni le informazioni sui metodi in un array Method utilizzando i metodi getMethods() e getDeclaredMethods() come mostrato di seguito:
    Method[] guru99Method1 = guru99ClassObjVar.getMethods();
    Method[] guru99Method2 = guru99ClassObjVar.getDeclaredMethods();

    Migliori getMetodi() Il metodo restituisce i metadati dei metodi pubblici della classe specificata e della sua superclasse. getDeclaredMethods() Il metodo restituisce i metadati di tutti i metodi della sola classe specificata.

  3. Ottieni il nome del metodo utilizzando il getName () metodo.
  4. Ottieni il tipo di ritorno del metodo utilizzando il getReturnType() metodo.
  5. Ottieni i modificatori di accesso dei metodi utilizzando il getModifiers() and Modificatore.toStringa(int i) metodi.
  6. Ottieni i tipi di parametri del metodo utilizzando getParameterTypes() metodo che restituisce un array di Class.
  7. Ottieni le eccezioni generate utilizzando il getExceptionTypes() metodo che restituisce un array di Class.

Qui stiamo scrivendo una classe per ottenere i metadati dei metodi presenti nella classe Guru99MethodMetaData.class:

Ottieni metadati del metodo

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 Guru99MethodMetaData.class
        Class guru99ClassObj = Guru99MethodMetaData.class;

        // Get the metadata of all the methods using getDeclaredMethods()
        Method[] guru99Methods = guru99ClassObj.getDeclaredMethods();

        for (Method method : guru99Methods) {
            System.out.println("Name of the method : " + method.getName());
            System.out.println("Return type of the method : " + method.getReturnType());

            int guru99ModifierList = method.getModifiers();
            System.out.println("Method access modifiers : " + Modifier.toString(guru99ModifierList));

            Class[] guru99ParamList = method.getParameterTypes();
            System.out.print("Method parameter types : ");
            for (Class class1 : guru99ParamList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();

            Class[] guru99ExceptionList = method.getExceptionTypes();
            System.out.print("Exception thrown by method : ");
            for (Class class1 : guru99ExceptionList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();
        }
    }
}
  1. Creato un oggetto di classe per Guru99MethodMetaData.class.
  2. Ho ottenuto tutti i metadati di tutti i metodi in un array Method.
  3. Vengono stampati tutti i nomi dei metodi presenti nella classe.
  4. Vengono stampati i tipi di ritorno dei metodi della classe.
  5. Sono stati stampati tutti i modificatori di accesso dei metodi della classe.
  6. Vengono stampati i tipi di parametri dei metodi.
  7. Vengono stampate le eccezioni generate dai metodi.

Ottieni metadati del metodo

Ottieni metadati del metodo

Esempio 4: Come ottenere i metadati dei costruttori

L'esempio seguente mostra come ottenere i metadati dei costruttori.

Qui stiamo creando una classe chiamata Guru99Classe costruttore con costruttori diversi:

Ottieni metadati dei 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 Guru99Costruttore.classe:

Ottieni metadati dei costruttori

package guru;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
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) {
            System.out.println("Constructor name : " + constructor.getName());

            int guru99Modifiers = constructor.getModifiers();
            System.out.println("Constructor modifier : " + Modifier.toString(guru99Modifiers));

            Class[] guru99ParamList = constructor.getParameterTypes();
            System.out.print("Constructor parameter types : ");
            for (Class class1 : guru99ParamList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();

            Class[] guru99ExceptionList = constructor.getExceptionTypes();
            System.out.print("Exception thrown by constructors : ");
            for (Class class1 : guru99ExceptionList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();
        }
    }
}
  1. Creato un oggetto di classe per Guru99Costruttore.classe.
  2. Ho ottenuto tutti i metadati di tutti i costruttori in un array di costruttori.
  3. Stampati tutti i nomi dei costruttori presenti nella classe.
  4. Sono stati stampati tutti i modificatori di accesso dei costruttori della classe.
  5. Vengono stampati i tipi di parametri dei costruttori.
  6. Vengono stampate le eccezioni generate dai costruttori.

Ottieni metadati dei costruttori

Ottieni metadati dei costruttori

DOMANDE FREQUENTI

La reflection consente ai framework e agli strumenti di IA di ispezionare e istanziare le classi in fase di esecuzione. Alimenta l'iniezione delle dipendenze, la serializzazione e la mappatura ORM.pinge caricamento dinamico dei plugin senza conoscere le classi esatte in fase di compilazione.

L'intelligenza artificiale può generare rapidamente codice tramite reflection, ma è necessario esaminarlo attentamente. La reflection può aggirare i controlli di accesso e introdurre rischi per la sicurezza e le prestazioni, quindi il codice generato necessita di test e convalida.

La reflection è più lenta delle chiamate dirette ai metodi, può violare l'incapsulamento accedendo a membri privati ​​e può causare problemi di sicurezza e manutenzione. Dovrebbe essere utilizzata solo quando non è disponibile un approccio più semplice.

Sì. Utilizzando setAccessible(true), la reflection può leggere e modificare campi privati ​​e richiamare metodi privati. Questo è utile per i test e i framework, ma può compromettere l'incapsulamento e creare problemi di sicurezza.

Riassumi questo post con: