Tutorial de API de reflexión de Java con ejemplo

¿Qué es Reflection en Java?

Java Reflection es el proceso de analizar y modificar todas las capacidades de una clase en tiempo de ejecución. Reflection API en Java se usa para manipular la clase y sus miembros, que incluyen campos, métodos, constructores, etc. en tiempo de ejecución.

Una ventaja de la API de reflexión en Java es que también puede manipular miembros privados de la clase.

El paquete java.lang.reflect proporciona muchas clases para implementar la reflexión java. Los métodos de la clase java.lang.Class se utilizan para recopilar los metadatos completos de una clase en particular.

En este tutorial, aprenderá-

Qué es la reflexión
Clase en paquete java.lang.reflect
Métodos utilizados en java.lang.Class
Cómo obtener información completa sobre una clase
Ejemplo 1:cómo obtener metadatos de clase
Ejemplo 2:Cómo obtener metadatos de variable
Ejemplo 3:Cómo obtener metadatos del método
Ejemplo 4:Cómo obtener metadatos de constructores

Clase en paquete java.lang.reflect

A continuación se muestra una lista de varias clases de Java en java.lang.package para implementar la reflexión-

Campo :esta clase se utiliza para recopilar información declarativa, como el tipo de datos, el modificador de acceso, el nombre y el valor de una variable.
Método :esta clase se utiliza para recopilar información declarativa, como el modificador de acceso, el tipo de valor devuelto, el nombre, los tipos de parámetros y el tipo de excepción de un método.
Constructora :esta clase se utiliza para recopilar información declarativa, como el modificador de acceso, el nombre y los tipos de parámetros de un constructor.
Modificador :esta clase se utiliza para recopilar información sobre un modificador de acceso en particular.

Métodos utilizados en java.lang.Class

Cadena pública getName () :Devuelve el nombre de la clase.
clase pública getSuperclass() :Devuelve la referencia de superclase
Clase pública[] getInterfaces() :Devuelve una matriz de interfaces implementadas por la clase especificada
Público en getModifiers (): Devuelve un valor entero que representa los modificadores de la clase especificada que debe pasarse como parámetro a “public static String toString (int i )” método que devuelve el especificador de acceso para la clase dada.

Cómo obtener información completa sobre una clase

Para obtener información sobre variables, métodos y constructores de una clase, necesitamos crear un objeto de la clase.

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

El siguiente ejemplo muestra diferentes formas de crear un objeto de clase "clase":

Ejemplo 1:cómo obtener metadatos de clase

El siguiente ejemplo muestra cómo obtener metadatos como:nombre de clase, nombre de superclase, interfaces implementadas y modificadores de acceso de una clase.

Obtendremos los metadatos de la siguiente clase llamada Guru99Base.class:

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

El nombre de la clase es:Guru99Base
Sus modificadores de acceso son:público y abstracto
Tiene interfaces implementadas:Serializable y Clonable
Dado que no ha extendido ninguna clase explícitamente, su superclase es:java.lang.Object

La siguiente clase obtendrá los metadatos de Guru99Base.class y los imprimirá:

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

imprime el nombre de la clase usando el método getName
Imprime el nombre de la superclase usando el método getSuperClass().getName()
Imprime el nombre de las interfaces implementadas
Imprime los modificadores de acceso usados por la clase

Ejemplo 2:Cómo obtener metadatos de variable

Los siguientes ejemplos muestran cómo obtener metadatos de la variable:

Aquí, estamos creando una clase llamada Guru99VariableMetaData .class con algunas variables:

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

Pasos para obtener los metadatos sobre las variables de la clase anterior:

Cree el objeto de clase de la clase anterior, es decir, Guru99VariableMetaData.class como se muestra a continuación:

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

Obtenga los metadatos en forma de matriz de campo usando getFields() o getDeclaredFields() métodos de la siguiente manera:
```
Field[]  guru99Field1= guru99ClassObjVar .getFields();
Field[]  guru99Fiel2= guru99ClassObjVar .getDeclaredFields();
```

getFields() El método devuelve metadatos de la variable pública de la clase especificada, así como de su superclase.

getDeclaredFields() El método devuelve metadatos de todas las variables de la clase especificada únicamente.

Obtenga el nombre de las variables utilizando el método "public String getName()".
Obtenga el tipo de datos de las variables utilizando el método "public Class getType()".
Obtenga el valor de la variable mediante el método "public xxx get (Field)".
Aquí, xxx podría ser un byte o menos de cualquier tipo de valor que queramos obtener.

Obtenga los modificadores de acceso de las variables usando los métodos getModifier() y Modifier.toString(int i).

Aquí estamos escribiendo una clase para obtener los metadatos de las variables presentes en la clase 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("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *") ;
	}
	}
}

Objeto de clase creado para Guru99VariableMetaData.class
Obtuve todos los metadatos de las variables en una matriz de campo
Imprimí todos los nombres de variables en la clase Guru99VariableMetaData.class
Imprimió todos los tipos de datos de las variables en la clase Guru99VariableMetaData.class
Imprimí todos los modificadores de acceso de las variables en la clase Guru99VariableMetaData.class
Valores impresos de todas las variables en Impreso todos los tipos de datos de las variables en la clase Guru99VariableMetaData.class

Ejemplo 3:Cómo obtener metadatos del método

Los siguientes ejemplos muestran cómo obtener metadatos de un método:

Aquí, estamos creando una clase llamada Guru99MethodMetaData .class con algunos métodos

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

Pasos para obtener los metadatos sobre los métodos de la clase anterior:

Cree el objeto de clase de la clase anterior, es decir, Guru99MethodMetaData.class como se muestra a continuación:

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

Obtenga información del método en una matriz de métodos usando los métodos getMethods() y getDeclaredMethods() como se muestra a continuación:
```
Method[]  guru99 Method 1= guru99ClassObjVar .get Methods();
Method []  guru99 Method 2= guru99ClassObjVar .getDeclared Method s();
```
getMethods() El método devuelve metadatos de los métodos públicos de la clase especificada, así como de su superclase.

getDeclaredMethods() El método devuelve metadatos de todos los métodos de la clase especificada únicamente.
Obtenga el nombre del método usando getName() método.
Obtenga el tipo de retorno del método usando getReturnType() método.
Obtenga modificadores de acceso de los métodos usando getModifiers() y Modificadores.toString(int i) métodos.
Obtener tipos de parámetros de métodos usando getParameterTypes() método que devuelve una matriz de clase.
Obtenga una excepción lanzada usando getExceptionTypes() método que devuelve una matriz de clase.

Aquí, estamos escribiendo una clase para obtener los metadatos de los métodos presentes en la clase 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("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ");
		
		}
 
	}
}

Objeto de clase creado para Guru99MethodMetaData.class
Obtuve todos los metadatos de todos los métodos en una matriz de métodos
Imprimió todos los nombres de métodos presentes en la clase Guru99MethodMetaData.class
Tipos de retorno impresos de los métodos en la clase Guru99MethodMetaData.class
Imprimí todos los modificadores de acceso de los métodos en la clase Guru99MethodMetaData.class
Tipos de parámetros impresos de los métodos en Guru99MethodMetaData.class
Las excepciones impresas son lanzadas por métodos en Guru99MethodMetaData.class

Ejemplo 4:Cómo obtener metadatos de constructores

Los siguientes ejemplos muestran cómo obtener metadatos de constructores:

Aquí estamos creando una clase llamada Guru99Constructor.class con diferentes constructores:

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

Aquí, estamos escribiendo una clase para obtener los metadatos de los constructores presentes en la clase 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("*******************************************");
		}
	}
}

Objeto de clase creado para Guru99Constructor.class
Obtuve todos los metadatos de todos los constructores en una matriz de constructores
Imprimió todos los nombres de los constructores presentes en la clase Guru99Constructor.class
Imprimí todos los modificadores de acceso de los constructores en la clase Guru99Constructor.class
Tipos de parámetros impresos de los constructores en Guru99Constructor.class
Los constructores lanzan excepciones impresas en Guru99Constructor.class

Resumen:

La programación de reflexión en Java ayuda a recuperar y modificar información sobre las clases y los miembros de la clase, como variables, métodos y constructores.
La API Reflection en Java se puede implementar usando clases en el paquete java.lang.reflect y métodos de la clase java.lang.Class.
Algunos métodos comúnmente utilizados de la clase java.lang.Class son getName (), getSuperclass (), getInterfaces (), getModifiers (), etc.
Algunas clases de uso común en el paquete java.lang.reflect son Campo, Método, Constructor, Modificador, etc.
La API de Reflection puede acceder a métodos privados y variables de una clase que podría ser una amenaza para la seguridad.
La API de Reflection es una capacidad poderosa proporcionada por Java, pero conlleva algunos gastos generales, como un rendimiento más lento, vulnerabilidad de seguridad y problemas de permisos. Por lo tanto, la API de reflexión debe tratarse como el último recurso para realizar una operación.

Java BufferedReader:cómo leer un archivo en Java con un ejemplo Tutorial Groovy Script para principiantes

Java