Java Reflection: Qué Es, Cómo Funciona y Cuándo Usarlo

Reflection es la capacidad de Java para inspeccionar y manipular en tiempo de ejecución clases, métodos, campos y constructores, incluso aquellos declarados como private. Es la base sobre la que funcionan internamente frameworks como Spring o librerías de serialización como Jackson.

¿Qué es la Reflection API en Java?

La Reflection API, disponible en el paquete java.lang.reflect, permite obtener información sobre una clase (sus métodos, campos, anotaciones, constructores) sin conocerla de antemano en tiempo de compilación, y también invocar esos métodos o acceder a esos campos dinámicamente.

¿Cómo funciona Reflection por dentro?

Todo parte del objeto Class<?>, que representa el "metadato" de una clase en tiempo de ejecución. A partir de él puedes navegar hacia sus métodos (Method), campos (Field) y constructores (Constructor), y operar sobre ellos de forma dinámica.

Ejemplo práctico: inspeccionar una clase en runtime

Obtener el objeto Class

class Producto {
    private String nombre = "Teclado";
    private double precio = 45.0;

    private void aplicarDescuento(double porcentaje) {
        precio = precio - (precio * porcentaje / 100);
    }
}

Class<?> clase = Producto.class;

Listar métodos y campos

for (Field campo : clase.getDeclaredFields()) {
    System.out.println("Campo: " + campo.getName());
}

for (Method metodo : clase.getDeclaredMethods()) {
    System.out.println("Método: " + metodo.getName());
}

Invocar un método por reflection

Producto producto = new Producto();

Method metodo = clase.getDeclaredMethod("aplicarDescuento", double.class);
metodo.setAccessible(true); // necesario porque el método es private
metodo.invoke(producto, 10.0);

Field campoPrecio = clase.getDeclaredField("precio");
campoPrecio.setAccessible(true);
System.out.println(campoPrecio.get(producto)); // 40.5

Casos de uso reales (Spring, Jackson, frameworks de testing)

• Spring: usa reflection para inyectar dependencias (@Autowired), instanciar beans y leer anotaciones como @RestController o @Service en tiempo de arranque.
• Jackson: usa reflection para convertir objetos Java a JSON y viceversa, accediendo a getters, setters y campos incluso privados.
• JUnit y frameworks de testing: usan reflection para descubrir e invocar métodos anotados con @Test.
• MapStruct, en cambio, evita reflection generando código en tiempo de compilación, precisamente para ganar rendimiento frente a este enfoque.

Ventajas y riesgos de usar Reflection

Ventajas: permite construir frameworks genéricos, herramientas de testing y librerías de serialización sin conocer de antemano las clases con las que van a trabajar.

Riesgos:

• Rendimiento más bajo que el acceso directo, ya que se salta optimizaciones del compilador.
• Rompe el encapsulamiento al poder acceder a miembros private.
• Los errores de tipo que normalmente detecta el compilador solo aparecen en tiempo de ejecución.
• Puede fallar en entornos con SecurityManager restrictivo o en aplicaciones nativas compiladas con GraalVM sin configuración adicional.

Reflection vs Anotaciones: ¿cuándo usar cada una?

	Reflection	Anotaciones
Qué es	Mecanismo para inspeccionar/manipular en runtime	Metadatos declarativos sobre el código
Uso típico	Leer/invocar dinámicamente	Marcar clases/métodos para que otro código (a menudo reflection) actúe sobre ellos
Relación entre ambas	Se usa para leer las anotaciones	Necesitan reflection para ser procesadas en runtime

En la práctica casi nunca se usan una sin la otra: las anotaciones describen "qué debe pasar" y reflection es el mecanismo que "lo hace pasar" en tiempo de ejecución.

Errores comunes y problemas de rendimiento

• Usar reflection para tareas cotidianas donde no es necesaria, penalizando el rendimiento sin motivo.
• Olvidar setAccessible(true) al intentar acceder a miembros privados, provocando IllegalAccessException.
• No gestionar las excepciones específicas de reflection (NoSuchMethodException, InvocationTargetException), que son checked exceptions.

Preguntas frecuentes

¿Reflection es peligroso? No es peligroso por sí mismo, pero debe usarse con criterio: rompe el encapsulamiento y tiene coste de rendimiento, por lo que no debería usarse en lógica de negocio cotidiana.

¿Spring usa reflection en cada petición HTTP? Principalmente la usa durante el arranque de la aplicación para configurar los beans; en el manejo de peticiones normales el impacto es mucho menor gracias a optimizaciones internas.

¿Puedo acceder a campos privados con reflection? Sí, usando setAccessible(true), aunque debe evitarse fuera de casos justificados como frameworks, testing o herramientas de introspección.

Siguiente paso

Entender reflection ayuda a comprender mejor cómo Spring Boot realiza la inyección de dependencias y la auto-configuración por debajo.