CKTIS / Java
Selezionare e invocare un costruttore tramite reflection
Seleziona l’unico costruttore annotato con `@Inject` o usa quello senza argomenti se nessuno è annotato. Prima dell’invocazione, controlla i tipi dei parametri e l’accesso.
Versione: Java SE 21
Sintassi
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[]In Java SE 21, java.lang.reflect.Constructor<T> rappresenta uno specifico costruttore. Class.getDeclaredConstructors() include i costruttori non pubblici e non garantisce alcun ordine; Class.getConstructors() restituisce solo quelli pubblici. Seleziona l’unico costruttore annotato con @Inject. Se ce ne sono più di uno, segnala l’ambiguità invece di prendere il primo. Se nessuno è annotato, usa Class.getDeclaredConstructor(); se manca un costruttore senza argomenti, il metodo lancia NoSuchMethodException.
Constructor.isAnnotationPresent(Inject.class) verifica se il costruttore stesso, non i suoi parametri, porta l’annotazione indicata e visibile a runtime. L’esempio definisce un proprio marcatore @Inject con RetentionPolicy.RUNTIME; l’annotazione non fornisce le dipendenze. Constructor.getParameterTypes() restituisce un Class<?>[] nell’ordine di dichiarazione, vuoto se non ci sono parametri. Contiene i tipi dopo la cancellazione dei tipi generici, non i valori degli argomenti né i dettagli generici. La ricerca con getDeclaredConstructor(...) richiede tipi esatti: per int, usa int.class, non Integer.class.
Constructor.setAccessible(true) disattiva i controlli di accesso del linguaggio Java per quell’oggetto riflessivo senza cambiare i modificatori del costruttore. Controlla prima canAccess(null). Per un costruttore privato di un altro modulo, il package deve essere aperto al modulo chiamante; esportarlo non basta. Se le regole di accesso tra moduli impediscono di disattivare i controlli, setAccessible(true) lancia InaccessibleObjectException, mentre trySetAccessible() restituisce false. Un gestore della sicurezza può negare entrambe le operazioni con SecurityException. Indipendentemente dal gestore della sicurezza, setAccessible(true) lancia SecurityException per un costruttore di java.lang.Class, anche se il package è aperto. Per un costruttore di questa classe, trySetAccessible() restituisce false a meno che un gestore della sicurezza non neghi la richiesta. setAccessible(false) riattiva i controlli per quell’oggetto.
Constructor.newInstance(Object...) invoca il costruttore già selezionato e restituisce una nuova istanza; non risolve gli overload. Passa gli argomenti nell’ordine dei parametri. Sono ammessi l’unboxing e le conversioni primitive di ampliamento, ma non quelle di restringimento. Per un parametro varargs del costruttore, passa un solo array come ultimo argomento: inseriscilo in un Object[] esterno oppure convertilo in Object con un cast, così la chiamata riflessiva non ne tratta gli elementi come argomenti distinti. Per una classe interna dichiarata in un contesto non statico, passa prima l’istanza contenitrice.
IllegalArgumentException può indicare un numero errato di argomenti o tipi incompatibili. IllegalAccessException indica che l’invocazione è stata negata con i controlli attivi; InstantiationException indica un tentativo di istanziare una classe astratta. Un’eccezione lanciata dal costruttore viene racchiusa in InvocationTargetException; esamina getCause(). Un errore del costruttore selezionato non giustifica il ripiego su quello senza argomenti.
Esempi
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";
}
}Risultato
config no-arg
`Service` usa il costruttore privato annotato con `@Inject`, anche se ne ha uno senza argomenti. `Fallback` non ha il marcatore e usa il costruttore senza argomenti. L’esempio passa `"config"` solo per la firma con un unico parametro `String`.
Lezioni correlate
- Java · Lezione 59 · Avanzato · Versione: 2