Java Reflection API-Tutorial mit Beispiel

Was ist Reflexion in Java?

Java Reflexion ist der Prozess der Analyse und Änderung aller Fähigkeiten einer Klasse zur Laufzeit. Reflection API in Java wird verwendet, um die Klasse und ihre Mitglieder, einschließlich Felder, Methoden, Konstruktoren usw., zur Laufzeit zu manipulieren.

Ein Vorteil der Reflection-API in Java ist, dass es auch private Mitglieder der Klasse manipulieren kann.

Das Paket java.lang.reflect stellt viele Klassen zum Implementieren der Reflektion bereit. Die Methoden der Klasse java.lang.Class werden zum Sammeln der vollständigen Metadaten einer bestimmten Klasse verwendet.

Klasse im java.lang.reflect-Paket

Es folgt eine Liste von verschiedene Java Unterricht in java.lang.package zur Implementierung von Reflection-

Feld: Diese Klasse wird zum Sammeln deklarativer Informationen wie Datentyp, Zugriffsmodifikator, Name und Wert einer Variablen verwendet.
Methodik: Diese Klasse wird verwendet, um deklarative Informationen wie Zugriffsmodifikator, Rückgabetyp, Name, Parametertypen und Ausnahmetyp einer Methode zu sammeln.
Bauherr: Diese Klasse wird zum Sammeln deklarativer Informationen wie Zugriffsmodifikator, Name und Parametertypen eines Konstruktors verwendet.
Veränderung: Diese Klasse wird verwendet, um Informationen über einen bestimmten Zugriffsmodifikator zu sammeln.

In java.lang.Class verwendete Methoden

Öffentlicher String getName (): Gibt den Namen der Klasse zurück.
öffentliche Klasse getSuperclass(): Gibt die Superklassenreferenz zurück
Öffentliche Klasse[] getInterfaces() : Gibt ein Array von Schnittstellen zurück, die von der angegebenen Klasse implementiert werden
Öffentlich in getModifiers(): Gibt einen ganzzahligen Wert zurück, der die Modifikatoren der angegebenen Klasse darstellt und als Parameter an „ übergeben werden muss.öffentlicher statischer String toString (int i )“ Methode, die den Zugriffsspezifizierer für die angegebene Klasse zurückgibt.

So erhalten Sie vollständige Informationen zu einer Klasse

Um Informationen zu erhalten Variablen, Methoden und Konstruktoren einer Klasse verwenden, müssen wir ein Objekt der Klasse erstellen.

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

Das folgende Beispiel zeigt verschiedene Möglichkeiten zum Erstellen eines Objekts der Klasse „class“:

Beispiel 1: So erhalten Sie Metadaten einer Klasse

Das folgende Beispiel zeigt, wie Metadaten wie Klassenname, Name der Superklasse, implementierte Schnittstellen und Zugriffsmodifikatoren einer Klasse abgerufen werden.

Wir erhalten die Metadaten der folgenden Klasse mit dem Namen Guru99Base.class:

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

Der Name der Klasse ist: Guru99Base
Die Zugriffsmodifikatoren sind: öffentlich und abstrakt
Es verfügt über implementierte Schnittstellen: Serialisierbar und Klonbar
Da keine Klasse explizit erweitert wurde, ist ihre Superklasse: java.lang.Object

Die folgende Klasse ruft die Metadaten von Guru99Base.class ab und druckt sie aus:

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

Geben Sie den Namen der Klasse mit der getName-Methode aus
Geben Sie den Namen der Superklasse mit der Methode getSuperClass().getName() aus
Geben Sie den Namen der implementierten Schnittstellen aus
Gibt die von der Klasse verwendeten Zugriffsmodifikatoren aus

Beispiel 2: So erhalten Sie Metadaten einer Variablen

Die folgenden Beispiele zeigen, wie Metadaten einer Variablen abgerufen werden:

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

Schritte zum Abrufen der Metadaten zu den Variablen in der obigen Klasse:

Erstellen Sie das Klassenobjekt der oben genannten Klasse, d. h. Guru99VariableMetaData.class, wie folgt:

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

Rufen Sie die Metadaten in Form eines Feldarrays ab getFields() or getDeclaredFields() Methoden wie folgt:

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

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

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

Rufen Sie den Namen der Variablen mit der Methode „public String getName()“ ab.
Rufen Sie den Datentyp der Variablen mit der Methode „public Class getType()“ ab.
Rufen Sie den Wert der Variablen mit der Methode „public xxx get (Field)“ ab.

Hier könnte xxx ein Byte oder weniger eines beliebigen Werttyps sein, den wir abrufen möchten.

Rufen Sie die Zugriffsmodifikatoren der Variablen mit den Methoden getModifier() und Modifier.toString(int i) ab.

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

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

Klassenobjekt für Guru99VariableMetaData.class erstellt
Habe alle Metadaten der Variablen in einem Feldarray erhalten
Alle Variablennamen in der Klasse Guru99VariableMetaData.class werden gedruckt
Alle Datentypen der Variablen in der Klasse Guru99VariableMetaData.class werden gedruckt
Alle Zugriffsmodifikatoren der Variablen in der Klasse Guru99VariableMetaData.class werden gedruckt
Gedruckte Werte aller Variablen in Gedruckt alle Datentypen der Variablen in der Klasse Guru99VariableMetaData.class

Beispiel 3: So erhalten Sie Metadaten der Methode

Die folgenden Beispiele zeigen, wie Metadaten einer Methode abgerufen werden:

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

Schritte zum Abrufen der Metadaten zu den Methoden in der obigen Klasse:

Erstellen Sie das Klassenobjekt der oben genannten Klasse, d. h. Guru99MethodMetaData.class, wie folgt:

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

Rufen Sie Methodeninformationen in einem Methodenarray mit den Methoden getMethods() und getDeclaredMethods() wie folgt ab:
```
Method[]  guru99 Method 1= guru99ClassObjVar .get Methods();
Method []  guru99 Method 2= guru99ClassObjVar .getDeclared Method s();
```
getMethods() Die Methode gibt Metadaten der öffentlichen Methoden der angegebenen Klasse sowie ihrer Superklasse zurück.

getDeclaredMethods() Die Methode gibt nur Metadaten aller Methoden der angegebenen Klasse zurück.
Rufen Sie den Namen der verwendeten Methode ab getName () Methode.
Rufen Sie den Rückgabetyp der Methode ab, die verwendet wird getReturnType() Methode.
Rufen Sie Zugriffsmodifikatoren der verwendeten Methoden ab getModifiers() und Modifiers.toString(int i) Methoden.
Methodenparametertypen abrufen mit getParameterTypes() Methode, die ein Klassenarray zurückgibt.
Ausnahme mit ausgelöst bekommen getExceptionTypes() Methode, die ein Klassenarray zurückgibt.

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

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

Klassenobjekt für Guru99MethodMetaData.class erstellt
Habe alle Metadaten aller Methoden in einem Methodenarray erhalten
Gibt alle in der Klasse Guru99MethodMetaData.class vorhandenen Methodennamen aus
Gedruckte Rückgabetypen der Methoden in der Klasse Guru99MethodMetaData.class
Alle Zugriffsmodifikatoren der Methoden in der Klasse Guru99MethodMetaData.class werden gedruckt
Gedruckte Parametertypen der Methoden in Guru99MethodMetaData.class
Gedruckte Ausnahmen werden von Methoden in Guru99MethodMetaData.class ausgelöst

Beispiel 4: So erhalten Sie Metadaten von Konstruktoren

Die folgenden Beispiele zeigen, wie Metadaten von Konstruktoren abgerufen werden:

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 abzurufen:

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

Klassenobjekt für Guru99Constructor.class erstellt
Habe alle Metadaten aller Konstruktoren in einem Konstruktor-Array erhalten
Gibt alle in der Klasse Guru99Constructor.class vorhandenen Konstruktornamen aus
Alle Zugriffsmodifikatoren der Konstruktoren in der Klasse Guru99Constructor.class werden gedruckt
Gedruckte Parametertypen der Konstruktoren in Guru99Constructor.class
Gedruckte Ausnahmen werden von Konstruktoren in Guru99Constructor.class ausgelöst

Zusammenfassung

Die Reflection-Programmierung in Java hilft beim Abrufen und Ändern von Informationen über Klassen und Klassenmitglieder wie Variablen, Methoden und Konstruktoren.
Reflection API in Java kann mithilfe von Klassen im Paket java.lang.reflect und Methoden der Klasse java.lang.Class implementiert werden.
Einige häufig verwendete Methoden der Klasse java.lang.Class sind getName (), getSuperclass (), getInterfaces (), getModifiers () usw.
Einige häufig verwendete Klassen im Paket java.lang.reflect sind Feld, Methode, Konstruktor, Modifikator usw.
Die Reflection-API kann auf private Methoden und Variablen einer Klasse zugreifen, was ein Sicherheitsrisiko darstellen könnte.
Reflection API ist eine leistungsstarke Funktion von Java, aber es bringt einige Nachteile mit sich, wie z. B. langsamere Leistung, Sicherheitslücken und Berechtigungsprobleme. Daher sollte die Reflection-API nur als letzte Möglichkeit zur Durchführung einer Operation betrachtet werden.