Java Reflection API meistern: Praktischer Leitfaden mit Code-Beispielen

In diesem Tutorial lernen Sie:

• Was Reflection ist
• Klassen im java.lang.reflect Package
• In java.lang.Class verwendete Methoden
• Wie man vollständige Informationen über eine Klasse erhält
• Beispiel 1: Metadaten einer Klasse erhalten
• Beispiel 2: Metadaten einer Variable erhalten
• Beispiel 3: Metadaten einer Methode erhalten
• Beispiel 4: Metadaten von Konstruktoren erhalten

Klassen im java.lang.reflect Package

Nachfolgend eine Liste verschiedener Java-Klassen in java.lang.package zur Implementierung von Reflection:

• Field: Sammelt deklarative Informationen wie Datentyp, Zugriffsmodifikator, Name und Wert einer Variable.
• Method: Sammelt deklarative Informationen wie Zugriffsmodifikator, Rückgabetyp, Name, Parametertypen und Exception-Typ einer Methode.
• Constructor: Sammelt deklarative Informationen wie Zugriffsmodifikator, Name und Parametertypen eines Konstruktors.
• Modifier: Sammelt Informationen über einen bestimmten Zugriffsmodifikator.

In java.lang.Class verwendete Methoden

• Public String getName(): Gibt den Namen der Klasse zurück.
• public Class getSuperclass(): Gibt die Superklassen-Referenz zurück.
• Public Class[] getInterfaces(): Gibt ein Array der von der angegebenen Klasse implementierten Interfaces zurück.
• Public int getModifiers(): Gibt einen Integer-Wert zurück, der die Modifikatoren der angegebenen Klasse repräsentiert, der als Parameter an public static String toString(int i) übergeben werden muss, um den Zugriffsspezifizierer für die gegebene Klasse zurückzugeben.

Vollständige Informationen über eine Klasse erhalten

public class Guru99ClassObjectCreation {
    public static void main (String[] args) throws ClassNotFoundException {
        // 1 - Durch Verwendung der Class.forName() Methode
        Class c1 = Class.forName("Guru99ClassObjectCreation");
        // 2 - Durch Verwendung der getClass() Methode
        Guru99ClassObjectCreation guru99Obj = new Guru99ClassObjectCreation();
        Class c2 = guru99Obj.getClass();
        // 3 - Durch Verwendung von .class
        Class c3 = Guru99ClassObjectCreation.class;
    }
}

Beispiel 1: Metadaten einer Klasse erhalten

Das folgende Beispiel zeigt, wie man Metadaten wie Klassenname, Superklassenname, implementierte Interfaces und Zugriffsmodifikatoren einer Klasse erhält.

Wir erhalten die Metadaten der unten genannten Klasse namens Guru99Base.class:

import java.io.Serializable;
public abstract class Guru99Base implements Serializable, Cloneable {
}

1. Name der Klasse ist: Guru99Base
2. Seine Zugriffsmodifikatoren sind: public und abstract
3. Es hat implementierte Interfaces: Serializable und Cloneable
4. Da es keine Klasse explizit erweitert, ist seine Superklasse: java.lang.Object

Die folgende Klasse erhält die Metadaten von Guru99Base.class und gibt sie aus:

import java.lang.reflect.Modifier;
public class Guru99GetclassMetaData {
    public static void main (String [] args) throws ClassNotFoundException {
        // Class-Objekt für Guru99Base.class erstellen
        Class<Guru99Base> guru99ClassObj = Guru99Base.class;
        // Namen der Klasse ausgeben
        System.out.println("Name of the class is : " + guru99ClassObj.getName());
        // Superklassenname ausgeben
        System.out.println("Name of the super class is : " + guru99ClassObj.getSuperclass().getName());
        // Liste der implementierten Interfaces als Class-Array mit getInterfaces() Methode
        Class[] guru99InterfaceList = guru99ClassObj.getInterfaces();
        // Implementierte Interfaces mit foreach-Schleife ausgeben
        System.out.print("Implemented interfaces are : ");
        for (Class guru99class1 : guru99InterfaceList) {
            System.out.print(guru99class1.getName() + " ");
        }
        System.out.println();
        // Zugriffsmodifikatoren mit getModifiers() und toString() Methode von java.lang.reflect.Modifier
        int guru99AccessModifier = guru99ClassObj.getModifiers();
        // Zugriffsmodifikatoren ausgeben
        System.out.println("Access modifiers of the class are : " + Modifier.toString(guru99AccessModifier));
    }
}

1. Klassennamen mit getName-Methode ausgeben
2. Superklassenname mit getSuperClass().getName() ausgeben
3. Namen der implementierten Interfaces ausgeben
4. Von der Klasse verwendete Zugriffsmodifikatoren ausgeben

Beispiel 2: Metadaten einer Variable erhalten

Das folgende Beispiel zeigt, wie man Metadaten einer Variable erhält:

Hier erstellen wir eine Klasse namens Guru99VariableMetaData.class mit einigen Variablen:

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

1. Erstellen Sie das Klassenobjekt der obigen Klasse, also Guru99VariableMetaData.class wie unten:

   Guru99VariableMetaData guru99ClassVar = new Guru99VariableMetaData();
   Class guru99ClassObjVar = guru99ClassVar.getClass();

2. Metadaten in Form eines Field-Arrays mit getFields() oder getDeclaredFields() erhalten:

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

getFields() gibt Metadaten der öffentlichen Variablen der angegebenen Klasse sowie ihrer Superklasse zurück.

getDeclaredFields() gibt Metadaten aller Variablen der angegebenen Klasse zurück.

3. Namen der Variablen mit „public String getName()“ erhalten.
4. Datentyp der Variablen mit „public Class getType()“ erhalten.
5. Wert der Variable mit „public xxx get(Field)“ erhalten. Hier kann xxx byte, short oder jeder Typ sein, den wir abrufen wollen.
6. Zugriffsmodifikatoren der Variablen mit getModifier() und Modifier.toString(int i) Methoden erhalten.

   Hier schreiben wir eine Klasse, um die Metadaten der in der Klasse Guru99VariableMetaData.class vorhandenen Variablen zu erhalten:

   

   package guru;
   import java.lang.reflect.Field;
   import java.lang.reflect.Modifier;
   public class Guru99VariableMetaDataTest {
       public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException {
           // Class-Objekt für Guru99VariableMetaData.class erstellen
           Guru99VariableMetaData guru99ClassVar = new Guru99VariableMetaData();
           Class guru99ClassObjVar = guru99ClassVar.getClass();
           // Metadaten aller Felder der Klasse Guru99VariableMetaData erhalten
           Field[] guru99Field1 = guru99ClassObjVar.getDeclaredFields();
           // Namen, Datentypen, Zugriffsmodifikatoren und Werte der Variablen der angegebenen Klasse ausgeben
           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.println("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. Klassenobjekt für Guru99VariableMetaData.class erstellt
2. Alle Metadaten der Variablen in einem Field-Array erhalten
3. Alle Variablennamen in der Klasse Guru99VariableMetaData.class ausgegeben
4. Alle Datentypen der Variablen in der Klasse Guru99VariableMetaData.class ausgegeben
5. Alle Zugriffsmodifikatoren der Variablen in der Klasse Guru99VariableMetaData.class ausgegeben
6. Werte aller Variablen in der Klasse Guru99VariableMetaData.class ausgegeben

Beispiel 3: Metadaten einer Methode erhalten

Das folgende Beispiel zeigt, wie man Metadaten einer Methode erhält:

Hier erstellen wir eine Klasse namens Guru99MethodMetaData.class mit einigen Methoden:

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

Schritte zum Erhalten der Metadaten über die Methoden in der obigen Klasse:

1. Klassenobjekt der obigen Klasse erstellen, also Guru99MethodMetaData.class:

   Guru99MethodMetaData guru99ClassVar = new Guru99MethodMetaData();
   Class guru99ClassObjVar = guru99ClassVar.getClass();

2. Methodeninformationen in einem Method-Array mit getMethods() und getDeclaredMethods() erhalten:

   Method[] guru99Method1 = guru99ClassObjVar.getMethods();
   Method[] guru99Method2 = guru99ClassObjVar.getDeclaredMethods();

   getMethods() gibt Metadaten der öffentlichen Methoden der angegebenen Klasse sowie ihrer Superklasse zurück.

   getDeclaredMethods() gibt Metadaten aller Methoden der angegebenen Klasse zurück.

3. Methodennamen mit getName() erhalten.
4. Rückgabetyp der Methode mit getReturnType() erhalten.
5. Zugriffsmodifikatoren der Methoden mit getModifiers() und Modifier.toString(int i) erhalten.
6. Methodenparametertypen mit getParameterTypes() erhalten, was ein Class-Array zurückgibt.
7. Geworfene Exceptions mit getExceptionTypes() erhalten, was ein Class-Array zurückgibt.

Hier schreiben wir eine Klasse, um die Metadaten der in der Klasse Guru99MethodMetaData.class vorhandenen Methoden zu erhalten:

package guru;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class Guru99MethodMetaDataTest {
    public static void main(String[] args) {
        // Class-Objekt für Guru99MethodMetaData.class erstellen
        Class guru99ClassObj = Guru99MethodMetaData.class;
        // Metadaten aller Methoden der Klasse mit getDeclaredMethods() erhalten
        Method[] guru99Methods = guru99ClassObj.getDeclaredMethods();
        for (Method method : guru99Methods) {
            // Methodennamen ausgeben
            System.out.println("Name of the method : " + method.getName());
            // Rückgabetyp der Methoden ausgeben
            System.out.println("Return type of the method : " + method.getReturnType());
            // Zugriffsmodifikatorliste erhalten und ausgeben
            int guru99ModifierList = method.getModifiers();
            System.out.println("Method access modifiers : " + Modifier.toString(guru99ModifierList));
            // Parameter der Methoden erhalten und ausgeben
            Class[] guru99ParamList = method.getParameterTypes();
            System.out.print("Method parameter types : ");
            for (Class class1 : guru99ParamList) {
                System.out.println(class1.getName() + " ");
            }
            System.out.println();
            // Geworfene Exceptions der Methode erhalten und ausgeben
            Class[] guru99ExceptionList = method.getExceptionTypes();
            System.out.print("Exception thrown by method : ");
            for (Class class1 : guru99ExceptionList) {
                System.out.println(class1.getName() + " ");
            }
            System.out.println();
            System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ");
        }
    }
}

1. Klassenobjekt für Guru99MethodMetaData.class erstellt
2. Alle Metadaten aller Methoden in einem Method-Array erhalten
3. Alle Methodennamen in der Klasse Guru99MethodMetaData.class ausgegeben
4. Rückgabetypen der Methoden in der Klasse Guru99MethodMetaData.class ausgegeben
5. Alle Zugriffsmodifikatoren der Methoden in der Klasse Guru99MethodMetaData.class ausgegeben
6. Parametertypen der Methoden in Guru99MethodMetaData.class ausgegeben
7. Geworfene Exceptions der Methoden in Guru99MethodMetaData.class ausgegeben

Beispiel 4: Metadaten von Konstruktoren erhalten

Das folgende Beispiel zeigt, wie man Metadaten von Konstruktoren erhält:

Hier erstellen wir eine Klasse namens Guru99Constructor.class mit verschiedenen Konstruktoren:

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

Hier schreiben wir eine Klasse, um die Metadaten der in der Klasse Guru99Constructor.class vorhandenen Konstruktoren zu erhalten:

package guru;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
public class Guru99ConstructorMetaDataTest {
    public static void main(String[] args) {
        // Class-Objekt für Guru99Constructor.class erstellen
        Class guru99Class = Guru99Constructor.class;
        // Alle Konstruktorinformationen in einem Constructor-Array erhalten
        Constructor[] guru99ConstructorList = guru99Class.getConstructors();
        for (Constructor constructor : guru99ConstructorList) {
            // Namen jedes Konstruktors ausgeben
            System.out.println("Constructor name : " + constructor.getName());
            // Zugriffsmodifikatoren jedes Konstruktors erhalten und ausgeben
            int guru99Modifiers = constructor.getModifiers();
            System.out.println("Constructor modifier : " + Modifier.toString(guru99Modifiers));
            // Parametertypen erhalten und ausgeben
            Class[] guru99ParamList = constructor.getParameterTypes();
            System.out.print("Constructor parameter types : ");
            for (Class class1 : guru99ParamList) {
                System.out.println(class1.getName() + " ");
            }
            System.out.println();
            // Geworfene Exceptions der Konstruktoren erhalten und ausgeben
            Class[] guru99ExceptionList = constructor.getExceptionTypes();
            System.out.println("Exception thrown by constructors : ");
            for (Class class1 : guru99ExceptionList) {
                System.out.println(class1.getName() + " ");
            }
            System.out.println();
            System.out.println("*******************************************");
        }
    }
}

1. Klassenobjekt für Guru99Constructor.class erstellt
2. Alle Metadaten aller Konstruktoren in einem Constructor-Array erhalten
3. Alle Konstruktornamen in der Klasse Guru99Constructor.class ausgegeben
4. Alle Zugriffsmodifikatoren der Konstruktoren in der Klasse Guru99Constructor.class ausgegeben
5. Parametertypen der Konstruktoren in Guru99Constructor.class ausgegeben
6. Geworfene Exceptions der Konstruktoren in Guru99Constructor.class ausgegeben

Zusammenfassung:

• Reflection-Programmierung in Java hilft beim Abrufen und Modifizieren von Informationen über Klassen und Klassenmember wie Variablen, Methoden, Konstruktoren.
• Reflection API in Java kann mit Klassen im java.lang.reflect Package und Methoden der java.lang.Class Klasse implementiert werden.
• Häufig verwendete Methoden der java.lang.Class Klasse sind getName(), getSuperclass(), getInterfaces(), getModifiers() etc.
• Häufig verwendete Klassen im java.lang.reflect Package sind Field, Method, Constructor, Modifier etc.
• Reflection API kann auf private Methoden und Variablen einer Klasse zugreifen, was eine Sicherheitsbedrohung darstellen könnte.
• Reflection API ist eine mächtige Fähigkeit von Java, bringt aber Overhead wie langsamere Performance, Sicherheitslücken und Berechtigungsprobleme mit sich. Daher sollte Reflection API als letzte Option für eine Operation betrachtet werden.