CKTIS / Java
Selección e invocación de constructores mediante reflexión
Selecciona el único constructor con `@Inject` o usa uno sin argumentos si ninguno está marcado. Comprueba los tipos de los parámetros y el acceso antes de invocarlo.
Versión: Java SE 21
Sintaxis
import java.lang.reflect.Constructor;
Constructor<?>[] candidates = type.getDeclaredConstructors();
Constructor<?> ctor = type.getDeclaredConstructor(parameterTypes); // Class<?>...; exact signature
Class<?>[] formalTypes = ctor.getParameterTypes();
boolean marked = ctor.isAnnotationPresent(Inject.class);
if (!ctor.canAccess(null)) {
ctor.setAccessible(true);
}
Object instance = ctor.newInstance(arguments); // arguments is Object[]En Java SE 21, java.lang.reflect.Constructor<T> representa un constructor concreto. Class.getDeclaredConstructors() incluye los constructores no públicos y no garantiza ningún orden; Class.getConstructors() solo devuelve los públicos. Selecciona el único constructor con @Inject. Si hay varios marcados, señala la ambigüedad en lugar de elegir el primero. Si no hay ninguno marcado, usa Class.getDeclaredConstructor(); si no existe un constructor sin argumentos, lanza NoSuchMethodException.
Constructor.isAnnotationPresent(Inject.class) comprueba si el propio constructor, no sus parámetros, tiene la anotación indicada visible en tiempo de ejecución. El ejemplo define su propia anotación de marcado @Inject con RetentionPolicy.RUNTIME; la anotación no proporciona dependencias. Constructor.getParameterTypes() devuelve un Class<?>[] en orden de declaración, vacío si no hay parámetros. Contiene los tipos tras el borrado, no los valores de los argumentos ni los detalles genéricos. La búsqueda con getDeclaredConstructor(...) exige los tipos exactos: para int, usa int.class, no Integer.class.
Constructor.setAccessible(true) desactiva las comprobaciones de acceso del lenguaje Java para ese objeto de reflexión, sin cambiar los modificadores del constructor. Comprueba primero canAccess(null). Para un constructor privado de otro módulo, el paquete debe estar abierto al módulo que realiza la llamada; exportarlo no basta. Si las reglas de acceso entre módulos impiden desactivar las comprobaciones, setAccessible(true) lanza InaccessibleObjectException, mientras que trySetAccessible() devuelve false. Un gestor de seguridad puede denegar cualquiera de las dos llamadas con SecurityException. Independientemente del gestor de seguridad, setAccessible(true) lanza SecurityException para un constructor de java.lang.Class, aunque el paquete esté abierto. Para un constructor de esa clase, trySetAccessible() devuelve false, salvo que un gestor de seguridad deniegue la llamada. setAccessible(false) restablece las comprobaciones para ese objeto.
Constructor.newInstance(Object...) invoca el constructor ya seleccionado y devuelve una nueva instancia; no resuelve sobrecargas. Pasa los argumentos en el orden de los parámetros. Se permiten el desempaquetado y las conversiones primitivas de ampliación, pero no las de estrechamiento. Un parámetro varargs del constructor recibe un único array como último argumento: colócalo dentro de un Object[] externo o conviértelo a Object para que la llamada por reflexión no trate sus elementos como argumentos separados. Para una clase interna declarada en un contexto no estático, pasa primero la instancia envolvente.
IllegalArgumentException puede indicar un número incorrecto de argumentos o tipos incompatibles. IllegalAccessException indica que se denegó la invocación con los controles activos, e InstantiationException señala un intento de instanciar una clase abstracta. Una excepción lanzada por el constructor se envuelve en InvocationTargetException; consulta getCause(). Si falla el constructor seleccionado, no recurras por ello al constructor sin argumentos.
Ejemplos
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.CONSTRUCTOR)
@interface Inject {}
public class Main {
static <T> T create(Class<T> type) throws ReflectiveOperationException {
Constructor<?> selected = null;
for (Constructor<?> candidate : type.getDeclaredConstructors()) {
if (candidate.isAnnotationPresent(Inject.class)) {
if (selected != null) {
throw new IllegalArgumentException("Multiple @Inject constructors");
}
selected = candidate;
}
}
if (selected == null) {
selected = type.getDeclaredConstructor();
}
Class<?>[] parameters = selected.getParameterTypes();
Object[] arguments;
if (parameters.length == 0) {
arguments = new Object[0];
} else if (parameters.length == 1 && parameters[0] == String.class) {
arguments = new Object[] {"config"};
} else {
throw new IllegalArgumentException("Unsupported constructor signature");
}
if (!selected.canAccess(null)) {
selected.setAccessible(true);
}
return type.cast(selected.newInstance(arguments));
}
public static void main(String[] args) throws ReflectiveOperationException {
System.out.println(create(Service.class).name);
System.out.println(create(Fallback.class).name);
}
}
final class Service {
final String name;
Service() {
this("no-arg");
}
@Inject
private Service(String name) {
this.name = name;
}
}
final class Fallback {
final String name;
Fallback() {
name = "no-arg";
}
}Resultado
config no-arg
`Service` usa su constructor privado con `@Inject` aunque también tiene uno sin argumentos. `Fallback` no tiene la marca y usa su constructor sin argumentos. El ejemplo pasa `"config"` solo para la firma con un único parámetro `String`.
Lecciones relacionadas
- Java · Lección 59 · Avanzado · Versión: 2