Java Reflection API oktatóanyag példával

Miben reflexió Java?

Java A reflexió egy osztály összes képességének futásidejű elemzésének és módosításának folyamata. Reflection API be Java az osztály és tagjainak manipulálására szolgál, amelyek futás közben mezőket, metódusokat, konstruktort stb. tartalmaznak.

A reflektív API egyik előnye Java vagyis manipulálni tudja az osztály privát tagjait is.

A java.lang.reflect csomag számos osztályt biztosít a tükrözés megvalósításához java. A java.lang.Class osztály módszerei egy adott osztály teljes metaadatainak összegyűjtésére szolgálnak.

Osztály a java.lang.reflect csomagban

Az alábbiakban egy lista található különféle Java osztályok a java.lang.package-ben a reflektálás megvalósításához-

• Mező: Ezt az osztályt olyan deklaratív információk gyűjtésére használják, mint például az adattípus, a hozzáférés-módosító, a változó neve és értéke.
• Módszer: Ezt az osztályt olyan deklaratív információk gyűjtésére használják, mint a hozzáférés-módosító, a visszatérési típus, a név, a paramétertípusok és a metódus kivételtípusa.
• építész: Ez az osztály olyan deklaratív információk gyűjtésére szolgál, mint a hozzáférés módosító, a konstruktor neve és paramétertípusai.
• változás: Ez az osztály arra szolgál, hogy információkat gyűjtsön egy adott hozzáférés-módosítóról.

A java.lang.Class-ban használt módszerek

• Nyilvános karakterlánc getName (): Az osztály nevét adja vissza.
• nyilvános osztály getSuperclass(): Visszaadja a szuperosztály referenciát
• Nyilvános osztály[] getInterfaces() : A megadott osztály által megvalósított interfészek tömbjét adja vissza
• Nyilvános a getModifiers-ben (): A megadott osztály módosítóit képviselő egész értéket ad vissza, amelyet paraméterként kell átadni a "nyilvános statikus String toString (int i )” metódus, amely visszaadja az adott osztály hozzáférési specifikációját.

Hogyan szerezhet teljes információt egy osztályról

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

1. példa: Hogyan szerezhető be az osztály metaadatai

A következő példa bemutatja, hogyan szerezhet be metaadatokat, például: Osztálynév, szuperosztálynév, megvalósított felületek és egy osztály hozzáférés-módosítói.

Az alábbi, Guru99Base.class nevű osztály metaadatait fogjuk megkapni:

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

1. Az osztály neve: Guru99Base
2. Hozzáférési módosítói a következők: nyilvános és absztrakt
3. Megvalósított interfészekkel rendelkezik: Sorosozható és Klónozható
4. Mivel egyetlen osztályt sem terjesztett ki kifejezetten, szuperosztálya: java.lang.Object

Az alábbi osztály megkapja a Guru99Base.class metaadatait, és kinyomtatja:

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

1. nyomtatja ki az osztály nevét a getName metódussal
2. Nyomtassa ki a szuperosztály nevét a getSuperClass().getName() metódussal
3. Nyomtassa ki a megvalósított interfészek nevét
4. Nyomtassa ki az osztály által használt hozzáférés-módosítókat

2. példa: A változó metaadatainak beszerzése

A következő példák bemutatják, hogyan lehet a változó metaadatait lekérni:

Itt létrehozunk egy Guru99VariableMetaData .class nevű osztályt néhány változóval:

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. Hozza létre a fenti osztály, azaz a Guru99VariableMetaData.class osztályobjektumát az alábbiak szerint:

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

2. Szerezze be a metaadatokat mezőtömb formájában getFields() or getDeclaredFields() módszerek az alábbiak szerint:

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

getFields() metódus a nyilvános változó metaadatait adja vissza a megadott osztályból, valamint annak szuperosztályából.

getDeclaredFields() metódus csak a megadott osztály összes változójának metaadatait adja vissza.

3. Kérje le a változók nevét a „public String getName()” metódussal.
4. Szerezze meg a változók adattípusát a „public Class getType()” metódussal.
5. Szerezze meg a változó értékét a „public xxx get (Field)” metódussal.

   Itt az xxx bármely lekérni kívánt érték bájtja vagy rövidítése lehet.

6. Szerezze be a változók hozzáférés-módosítóit a getModifier() és Modifier.toString(int i) metódusokkal.

   Itt írunk egy osztályt a Guru99VariableMetaData .class osztályban lévő változók metaadatainak beszerzéséhez:

   

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

1. Osztályobjektum létrehozva a Guru99VariableMetaData.class számára
2. Megszerezte a változók összes metaadatát egy Field tömbben
3. Kinyomtatta a Guru99VariableMetaData.class osztály összes változónevét
4. Kinyomtatta a Guru99VariableMetaData.class osztály változóinak összes adattípusát
5. Kinyomtatta a Guru99VariableMetaData.class osztály változóinak összes hozzáférési módosítóját
6. A Guru99VariableMetaData.class osztály változóinak összes adattípusa kinyomtatott értéke





3. példa: A módszer metaadatainak beszerzése

A következő példák bemutatják, hogyan lehet egy metódus metaadatait lekérni:

Itt létrehozunk egy Guru99MethodMetaData .class nevű osztályt néhány metódussal



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

A fenti osztály metódusaival kapcsolatos metaadatok beszerzésének lépései:

1. Hozza létre a fenti osztály, azaz a Guru99MethodMetaData.class osztályobjektumát az alábbiak szerint:

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

2. Metódusinformációkat szerezhet be egy Method tömbben a getMethods() és getDeclaredMethods() metódusokkal az alábbiak szerint:

   Method[]  guru99 Method 1= guru99ClassObjVar .get Methods();
   Method []  guru99 Method 2= guru99ClassObjVar .getDeclared Method s();

   getMethods() Metódus visszaadja a nyilvános metódusok metaadatait a megadott osztályból, valamint annak szuperosztályából.

   getDeclaredMethods() A metódus csak a megadott osztály összes metódusának metaadatait adja vissza.

3. Szerezze meg a módszer nevét getName () módszer.
4. Szerezze meg a metódus visszatérési típusát getReturnType() módszer.
5. A metódusok hozzáférés-módosítóinak lekérése getModifiers() és a Modifiers.toString(int i) mód.
6. Metódusparaméter-típusok lekérése a használatával getParameterTypes() metódus, amely egy osztálytömböt ad vissza.
7. Get dobott kivétel segítségével getExceptionTypes() metódus, amely egy osztálytömböt ad vissza.

Itt írunk egy osztályt a Guru99MethodMetaData.class osztályban lévő metódusok metaadatainak beszerzéséhez:



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

1. Osztályobjektum létrehozva a Guru99MethodMetaData.class számára
2. Megszerezte az összes metódus összes metaadatát egy Method tömbben
3. A Guru99MethodMetaData.class osztályban található összes metódusnevet kinyomtatta
4. A Guru99MethodMetaData.class osztály metódusainak nyomtatott visszatérési típusai
5. Kinyomtatta a Guru99MethodMetaData.class osztály metódusainak összes hozzáférés-módosítóját
6. A Guru99MethodMetaData.class metódusainak nyomtatott paramétertípusai
7. A nyomtatott kivételeket a Guru99MethodMetaData.class metódusai dobják

   



4. példa: A konstruktorok metaadatainak beszerzése

A következő példák bemutatják, hogyan szerezheti be a konstruktorok metaadatait:

Itt létrehozunk egy Guru99Constructor.class nevű osztályt különböző konstruktorokkal:



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

Itt írunk egy osztályt a Guru99Constructor.class osztályban lévő konstruktorok metaadatainak beszerzéséhez:



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

1. Osztályobjektum létrehozva a Guru99Constructor.class számára
2. Megszerezte az összes konstruktor összes metaadatát egy Constructor tömbben
3. A Guru99Constructor.class osztályban található összes konstruktor nevét kinyomtatta
4. Kinyomtatta a Guru99Constructor.class osztály konstruktorainak összes hozzáférési módosítóját
5. A Guru99Constructor.class konstruktorainak nyomtatott paramétertípusai
6. A nyomtatott kivételeket a Guru99Constructor.class konstruktorai dobják





Összegzésként

• A java reflexiós programozása segít az osztályokkal és osztálytagokkal, például változókkal, metódusokkal és konstruktorokkal kapcsolatos információk lekérésében és módosításában.
• Reflection API be Java megvalósítható a java.lang.reflect csomag osztályaival és a java.lang.Class osztály metódusaival.
• A java.lang.Class osztály néhány gyakran használt metódusa a getName (), a getSuperclass (), a getInterfaces (), a getModifiers () stb.
• Néhány gyakran használt osztály a java.lang.reflect csomagban: Field, Method, Constructor, Modifier stb.
• A Reflection API hozzáférhet egy osztály privát metódusaihoz és változóihoz, amelyek biztonsági fenyegetést jelenthetnek.
• A Reflection API egy hatékony képesség, amelyet a Java, de bizonyos költségekkel jár, mint például a lassabb teljesítmény, a biztonsági rések és az engedélyekkel kapcsolatos problémák. Ezért a tükrözési API-t a művelet végrehajtásának utolsó eszközeként kell kezelni.