Java Tutorial Reflection API cu exemplu

În ce este Reflecția Java?

Java Reflecția este procesul de analiză și modificare a tuturor capabilităților unei clase în timpul execuției. Reflection API în Java este folosit pentru a manipula clasa și membrii acesteia, care includ câmpuri, metode, constructor etc. în timpul execuției.

Un avantaj al reflection API în Java adică poate manipula și membrii privați ai clasei.

Pachetul java.lang.reflect oferă multe clase pentru a implementa reflectarea java.Metodele clasei java.lang.Class sunt folosite pentru a aduna metadatele complete ale unei anumite clase.

Clasă în pachetul java.lang.reflect

În continuare este o listă de diverse Java clase în java.lang.package pentru a implementa reflection-

Câmp: Această clasă este folosită pentru a colecta informații declarative, cum ar fi tipul de date, modificatorul de acces, numele și valoarea unei variabile.
Metodă: Această clasă este folosită pentru a aduna informații declarative, cum ar fi modificatorul de acces, tipul de returnare, numele, tipurile de parametri și tipul de excepție al unei metode.
Constructor: Această clasă este folosită pentru a aduna informații declarative, cum ar fi modificatorul de acces, tipurile de nume și parametri ale unui constructor.
Modificatorul: Această clasă este folosită pentru a aduna informații despre un anumit modificator de acces.

Metode utilizate în java.lang.Class

șir public getName (): Returnează numele clasei.
clasă publică getSuperclass(): Returnează referința super-clasă
Clasa publică[] getInterfaces() : Returnează o serie de interfețe implementate de clasa specificată
Public în getModifiers (): Returnează o valoare întreagă reprezentând modificatorii clasei specificate care trebuie să fie transmisă ca parametru la „public static String toString (int i )” metoda care returnează specificatorul de acces pentru clasa dată.

Cum să obțineți informații complete despre o clasă

Pentru a obține informații despre variabile, metode și constructori ai unei clase, trebuie să creăm un obiect al clasei.

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

Următorul exemplu arată diferite moduri de a crea obiectul clasei „clasa”:

Exemplul 1: Cum să obțineți metadatele clasei

Următorul exemplu arată cum să obțineți metadate, cum ar fi: numele clasei, numele superclasei, interfețele implementate și modificatorii de acces ai unei clase.

Vom obține metadatele clasei de mai jos numite Guru99Base.class:

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

Numele clasei este: Guru99Base
Modificatorii de acces sunt: public și abstract
Are interfețe implementate: Serializabil și Clonabil
Deoarece nu a extins nicio clasă în mod explicit, super-clasa este: java.lang.Object

Clasa de mai jos va obține metadatele Guru99Base.class și le va imprima:

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

tipăriți numele clasei folosind metoda getName
Tipăriți numele superclasei folosind metoda getSuperClass().getName().
Tipăriți numele interfețelor implementate
Tipăriți modificatorii de acces folosiți de clasă

Exemplul 2: Cum să obțineți metadatele variabilei

Următoarele exemple arată cum să obțineți metadatele variabilei:

Aici, creăm o clasă numită Guru99VariableMetaData .class cu câteva variabile:

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

Pași pentru a obține metadatele despre variabilele din clasa de mai sus:

Creați obiectul clasei din clasa de mai sus, adică Guru99VariableMetaData.class ca mai jos:

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

Obțineți metadatele sub formă de matrice de câmp folosind getFields() or getDeclaredFields() metode după cum urmează:
```
Field[]  guru99Field1= guru99ClassObjVar .getFields();
Field[]  guru99Fiel2= guru99ClassObjVar .getDeclaredFields();
```

getFields() metoda returnează metadatele variabilei publice din clasa specificată, precum și din superclasa acesteia.

getDeclaredFields() metoda returnează metadatele tuturor variabilelor din clasa specificată.

Obțineți numele variabilelor folosind metoda „public String getName()”.
Obțineți tipul de date al variabilelor folosind metoda „public Class getType()”.
Obțineți valoarea variabilei folosind metoda „public xxx get (Field)”.

Aici, xxx ar putea fi un octet sau scurt de orice tip de valoare pe care dorim să o obținem.

Obțineți modificatorii de acces ai variabilelor folosind metodele getModifier() și Modifier.toString(int i).

Aici scriem o clasă pentru a obține metadatele variabilelor prezente în clasa 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("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *") ;
	}
	}
}

Obiect de clasă creat pentru Guru99VariableMetaData.class
Am primit toate metadatele variabilelor dintr-o matrice Field
S-au imprimat toate numele variabilelor din clasa Guru99VariableMetaData.class
S-au imprimat toate tipurile de date ale variabilelor din clasa Guru99VariableMetaData.class
S-au imprimat toți modificatorii de acces ai variabilelor din clasa Guru99VariableMetaData.class
Imprimate valorile tuturor variabilelor din Imprimarea tuturor tipurilor de date ale variabilelor din clasa Guru99VariableMetaData.class

Exemplul 3: Cum să obțineți metadatele metodei

Următoarele exemple arată cum să obțineți metadatele unei metode:

Aici, creăm o clasă numită Guru99MethodMetaData .class cu unele metode

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

Pași pentru a obține metadatele despre metodele din clasa de mai sus:

Creați obiectul clasei din clasa de mai sus, adică Guru99MethodMetaData.class ca mai jos:

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

Obțineți informații despre metodă într-o matrice Method folosind metoda getMethods() și getDeclaredMethods(), după cum urmează:
```
Method[]  guru99 Method 1= guru99ClassObjVar .get Methods();
Method []  guru99 Method 2= guru99ClassObjVar .getDeclared Method s();
```
getMethods() metoda returnează metadatele metodelor publice din clasa specificată, precum și din superclasa acesteia.

getDeclaredMethods() metoda returnează metadatele tuturor metodelor numai din clasa specificată.
Obțineți numele metodei folosind getName () metodă.
Obțineți tipul de returnare al metodei folosind getReturnType() metodă.
Obțineți modificatori de acces ai metodelor folosind getModifiers() și Modifiers.toString(int i) metode.
Obține tipuri de parametri de metodă folosind getParameterTypes() metodă care returnează o matrice de clasă.
Obțineți excepție folosind getExceptionTypes() metodă care returnează o matrice de clasă.

Aici scriem o clasă pentru a obține metadatele metodelor prezente în clasa 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("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ");
		
		}
 
	}
}

Obiect de clasă creat pentru Guru99MethodMetaData.class
Am primit toate metadatele tuturor metodelor dintr-o matrice Method
S-au imprimat toate numele metodelor prezente în clasa Guru99MethodMetaData.class
Tipuri de returnare tipărite ale metodelor din clasa Guru99MethodMetaData.class
S-au imprimat toți modificatorii de acces ai metodelor din clasa Guru99MethodMetaData.class
Tipuri de parametri imprimate ale metodelor din Guru99MethodMetaData.class
Excepțiile tipărite sunt aruncate de metodele din Guru99MethodMetaData.class

Exemplul 4: Cum să obțineți metadatele constructorilor

Următoarele exemple arată cum să obțineți metadatele constructorilor:

Aici, creăm o clasă numită Guru99Constructor.class cu diferiți constructori:

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

Aici scriem o clasă pentru a obține metadatele constructorilor prezenți în clasa 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("*******************************************");
		}
	}
}

Obiect de clasă creat pentru Guru99Constructor.class
Am primit toate metadatele tuturor constructorilor dintr-o matrice Constructor
S-au imprimat toate numele constructorilor prezente în clasa Guru99Constructor.class
S-au imprimat toți modificatorii de acces ai constructorilor din clasa Guru99Constructor.class
Tipuri de parametri imprimate ale constructorilor din Guru99Constructor.class
Excepțiile tipărite sunt aruncate de constructori în Guru99Constructor.class

Rezumat

Programarea prin reflectare în java ajută la preluarea și modificarea informațiilor despre clase și membrii clasei, cum ar fi variabile, metode, constructori.
Reflection API în Java poate fi implementat folosind clase din pachetul java.lang.reflect și metodele clasei java.lang.Class.
Unele metode frecvent utilizate ale clasei java.lang.Class sunt getName (), getSuperclass (), getInterfaces (), getModifiers () etc.
Unele clase utilizate în mod obișnuit în pachetul java.lang.reflect sunt Câmp, Metodă, Constructor, Modificator etc.
Reflection API poate accesa metode private și variabile ale unei clase care ar putea reprezenta o amenințare de securitate.
Reflection API este o capacitate puternică oferită de Java, dar vine cu unele cheltuieli generale, cum ar fi performanță mai lentă, vulnerabilitate de securitate și probleme de permisiuni. Prin urmare, reflection API ar trebui tratat ca ultima soluție pentru a efectua o operație.