Java Reflection API Tutorial med exempel

Innehållsförteckning:

Anonim

Vad är reflektion i Java?

Java Reflection är processen att analysera och modifiera alla funktioner i en klass vid körning. Reflection API i Java används för att manipulera klass och dess medlemmar som inkluderar fält, metoder, konstruktör etc. vid körning.

En fördel med reflektions-API i Java är att det också kan manipulera privata medlemmar i klassen.

Paketet java.lang.reflect ger många klasser för att implementera reflektion java.Metoder för klassen java.lang.Class används för att samla hela metadata för en viss klass.

I den här handledningen lär du dig-

  • Vad är reflektion
  • Klass i java.lang.reflect-paketet
  • Metoder som används i java.lang.Class
  • Hur får man fullständig information om en klass
  • Exempel 1: Hur får man metadata i klass
  • Exempel 2: Hur får man metadata för variabel
  • Exempel 3: Hur man får metadata för metoden
  • Exempel 4: Hur får man metadata för konstruktörer

Klass i java.lang.reflect-paketet

Nedan följer en lista över olika Java-klasser i java.lang.package för att implementera reflektion-

  • Fält : Denna klass används för att samla deklarativ information som datatyp, åtkomstmodifierare, namn och värde på en variabel.
  • Metod : Den här klassen används för att samla in deklarationsinformation såsom åtkomstmodifierare, returtyp, namn, parametertyper och undantagstyp för en metod.
  • Konstruktör : Den här klassen används för att samla in deklarativ information, såsom åtkomstmodifierare, namn och parametertyper för en konstruktör.
  • Modifier : Denna klass används för att samla information om en viss accessmodifierare.

Metoder som används i java.lang.Class

  • Public String getName () : Returnerar namnet på klassen.
  • public Class getSuperclass () : Returnerar superklassreferensen
  • Public Class [] getInterfaces () : Returnerar en array med gränssnitt implementerade av den angivna klassen
  • Offentligt i getModifiers (): Returnerar ett heltal som representerar modifierarna för den angivna klassen som måste skickas som en parameter till " public static String toString (int i)" -metoden som returnerar åtkomstspecifikatorn för den givna klassen.

Hur får man fullständig information om en klass

För att få information om variabler, metoder och konstruktörer för en klass måste vi skapa ett objekt av klassen. 
public class Guru99ClassObjectCreation {public static void main (String[] args) throws ClassNotFoundException {//1 - By using Class.forname() methodClass c1 = Class.forName("Guru99ClassObjectCreation");//2- By using getClass() methodGuru99ClassObjectCreation guru99Obj = new Guru99ClassObjectCreation();Class c2 = guru99Obj.getClass();//3- By using .classClass c3= Guru99ClassObjectCreation.class;}}
  • Följande exempel visar olika sätt att skapa objekt av klass "klass":

    • Exempel 1: Hur får man metadata i klass

    Följande exempel visar hur man får metadata som: Klassnamn, superklassnamn, implementerade gränssnitt och åtkomstmodifierare för en klass.

    Vi får metadata för underklassen som heter Guru99Base.class:

    import java.io.Serializable;public abstract class Guru99Base implements Serializable,Cloneable {}
    1. Klassens namn är: Guru99Base
    2. Tillgångsmodifierare är: offentliga och abstrakta
    3. Det har implementerat gränssnitt: Serializable och Cloneable
    4. Eftersom den inte har utvidgat någon klass uttryckligen är den superklassen: java.lang.Object
    Nedanför klassen får du metadata från Guru99Base.class och skriver ut: 
    import java.lang.reflect.Modifier;public class Guru99GetclassMetaData {public static void main (String [] args) throws ClassNotFoundException {// Create Class object for Guru99Base.classClass  guru99ClassObj = Guru99Base.class;// Print name of the classsystem.out.println("Name of the class is : " +guru99ClassObj.getName());// Print Super class namesystem.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() methodclass[] guru99InterfaceList = guru99classObj.getInterfaces();// Print the implemented interfaces using foreach loopsystem.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 classint guru99AccessModifier= guru99classObj.getModifiers();// Print the access modifiersSystem.Out.println("Access modifiers of the class are : " +Modifier.tostring(guru99AccessModifier));}}
    1. skriv ut namnet på klassen med metoden getName
    2. Skriv ut namnet på superklassen med getSuperClass (). GetName () -metoden
    3. Skriv ut namnet på de implementerade gränssnitten
    4. Skriv ut åtkomstmodifierarna som används av klassen

    Exempel 2: Hur får man metadata för variabel

    Följande exempel visar hur man får metadata för variabel:

    Här skapar vi en klass som heter Guru99VariableMetaData .klass med några variabler:

    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";}
    Steg för att få metadata om variablerna i ovanstående klass:
    1. Skapa klassobjektet för ovanstående klass, dvs. Guru99VariableMetaData.class enligt nedan: 
      Guru99VariableMetaData guru99ClassVar = new Guru99VariableMetaData();Class guru99ClassObjVar = guru99ClassVar.getClass();
    2. Hämta metadata i form av fältmatris med hjälp av getFields () eller getDeclaredFields () -metoder enligt nedan: 
      Field[] guru99Field1= guru99ClassObjVar .getFields();Field[] guru99Fiel2= guru99ClassObjVar .getDeclaredFields();

    getFields () -metoden returnerar metadata för den offentliga variabeln från den angivna klassen såväl som från dess superklass.

    getDeclaredFields () -metoden returnerar endast metadata för alla variabler från den angivna klassen.

    1. Få namnet på variablerna med "public String getName ()" -metoden.
    2. Hämta datatypen för variablerna med "public Class getType ()" -metoden.
    3. Få värdet av variabeln med "public xxx get (Field)" -metoden.

      Här kan xxx vara en byte eller kort av vilken typ av värde vi vill hämta.

    4. Få åtkomstmodifierare för variablerna med metoder getModifier () och Modifier.toString (int i).

      Här skriver vi en klass för att få metadata för variablerna som finns i klassen 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.classGuru99VariableMetaData guru99ClassVar = new Guru99VariableMetaData();Class guru99ClassObjVar = guru99ClassVar.getClass();// Get the metadata of all the fields of the class Guru99VariableMetaDataField[] guru99Field1= guru99ClassObjVar.getDeclaredFields();// Print name, datatypes, access modifiers and values of the varibales of the specified classfor(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. Skapat klassobjekt för Guru99VariableMetaData.class
      2. Fick alla metadata för variablerna i en fältmatris
      3. Tryckt alla variabelnamnen i klassen Guru99VariableMetaData.class
      4. Tryckt alla datatyper av variablerna i klassen Guru99VariableMetaData.class
      5. Tryckt alla åtkomstmodifierare för variablerna i klassen Guru99VariableMetaData.class
      6. Tryckta värden för alla variabler i Tryckta alla datatyper för variablerna i klassen Guru99VariableMetaData.class

      Exempel 3: Hur man får metadata för metoden

      Följande exempel visar hur man får metadata för en metod:

      Här skapar vi en klass som heter Guru99MethodMetaData .class med några metoder

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

      Steg för att få metadata om metoderna i ovanstående klass:

      1. Skapa klassobjektet för ovanstående klass, dvs. Guru99MethodMetaData.class enligt nedan: 
        Guru99MethodMetaData guru99ClassVar = new Guru99MethodMetaData ();Class guru99ClassObjVar = guru99ClassVar.getClass();
      2. Få metodinformation i en metodmatris med getMethods () och getDeclaredMethods () -metoden enligt nedan: 
        Method[] guru99 Method 1= guru99ClassObjVar .get Methods();Method [] guru99 Method 2= guru99ClassObjVar .getDeclared Method s();

        getMethods () -metoden returnerar metadata för de offentliga metoderna från den angivna klassen såväl som från dess superklass.

        getDeclaredMethods () -metoden returnerar endast metadata för alla metoderna från den angivna klassen.

      3. Få namnet på metoden med getName () -metoden.
      4. Hämta returtypen för metoden med metoden getReturnType () .
      5. Få åtkomstmodifierare av metoderna med getModifiers () och Modifiers.toString (int i) -metoderna.
      6. Hämta metodparametertyper med getParameterTypes () -metoden som returnerar en klassmatris.
      7. Få undantag med metoden getExceptionTypes () som returnerar en klassmatris.

      Här skriver vi en klass för att få metadata för metoderna som finns i klassen 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.classclass 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 namesSystem.out.println("Name of the method : "+method.getName());// Print return type of the methodsSystem.out.println("Return type of the method : "+method.getReturnType());//Get the access modifier list and printint guru99ModifierList = method.getModifiers();System.Out.printlin ("Method access modifiers : "+Modifier.toString(guru99ModifierList));// Get and print parameters of the methodsClass[] 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 methodClass[] 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. Skapat klassobjekt för Guru99MethodMetaData.class
      2. Fick alla metadata för alla metoder i en metodmatris
      3. Tryckt alla metodnamn som finns i klassen Guru99MethodMetaData.class
      4. Tryckta returtyper av metoderna i klassen Guru99MethodMetaData.class
      5. Tryckt alla åtkomstmodifierare för metoderna i klassen Guru99MethodMetaData.class
      6. Tryckta parametertyper av metoderna i Guru99MethodMetaData.class
      7. Tryckta undantag kastas efter metoder i Guru99MethodMetaData.class

      Exempel 4: Hur får man metadata för konstruktörer

      Följande exempel visar hur man får metadata för konstruktörer:

      Här skapar vi en klass som heter Guru99Constructor.class med olika konstruktörer:

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

      Här skriver vi en klass för att få metadata för konstruktörerna närvarande i klassen Guru99Constructor.class:

      package guru;import java.lang.reflect.Constructor;public class Guru99ConstructorMetaDataTest {public static void main (String[] args) {// Create Class object for Guru99Constructor.classClass guru99Class=Guru99Constructor.class;// Get all the constructor information in the Constructor arrayConstructor[] guru99ConstructorList = guru99Class.getConstructors();for (Constructor constructor : guru99ConstructorList) {// Print all name of each constructorSystem.out.println("Constrcutor name : "+constructor.getName());//Get and print access modifiers of each constructorint guru99Modifiers= constructor.getModifiers();System.Out.printlin ("Constrctor modifier : "+Modifier.toString(guru99Modifiers));// Get and print parameter typesClass[] 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 constructorsClass[] 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. Skapat klassobjekt för Guru99Constructor.class
      2. Fick alla metadata för alla konstruktörer i en Constructor-array
      3. Tryckt alla konstruktörens namn som finns i klassen Guru99Constructor.class
      4. Tryckt alla åtkomstmodifierare för konstruktörerna i klassen Guru99Constructor.class
      5. Tryckta parametertyper av konstruktörerna i Guru99Constructor.class
      6. Tryckta undantag kastas av konstruktörer i Guru99Constructor.class

      Sammanfattning:

      • Reflektionsprogrammering i java hjälper till att hämta och modifiera information om klasser och klassmedlemmar som sådana variabler, metoder, konstruktörer.
      • Reflection API i Java kan implementeras med hjälp av klasser i java.lang.reflect-paketet och metoder för java.lang.Class-klassen.
      • Några vanliga metoder för java.lang.Class-klassen är getName (), getSuperclass (), getInterfaces (), getModifiers () etc.
      • Några vanliga klasser i paketet java.lang.reflect är fält, metod, konstruktör, modifierare etc.
      • Reflection API kan komma åt privata metoder och variabler i en klass som kan vara ett säkerhetshot.
      • Reflection API är en kraftfull funktion som tillhandahålls av Java, men den kommer med vissa omkostnader som långsammare prestanda, säkerhetsproblem och tillståndsproblem. Därför bör reflektions-API behandlas som den sista utväg för att utföra en operation.