CKTIS / Java
Konstruktoren per Reflection auswählen und aufrufen
Wähle den einzigen mit `@Inject` markierten Konstruktor oder, wenn keiner markiert ist, den parameterlosen Konstruktor. Prüfe vor dem Aufruf Parametertypen und Zugriff.
Version: Java SE 21
Syntax
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 steht java.lang.reflect.Constructor<T> für einen bestimmten Konstruktor. Class.getDeclaredConstructors() liefert auch nicht öffentliche Konstruktoren und garantiert keine Reihenfolge; Class.getConstructors() liefert nur öffentliche. Wähle den einzigen mit @Inject markierten Konstruktor. Sind mehrere markiert, melde die Mehrdeutigkeit, statt den ersten zu nehmen. Ist keiner markiert, verwende Class.getDeclaredConstructor(); fehlt ein parameterloser Konstruktor, wird NoSuchMethodException ausgelöst.
Constructor.isAnnotationPresent(Inject.class) prüft, ob der Konstruktor selbst, nicht seine Parameter, die angegebene zur Laufzeit sichtbare Annotation trägt. Das Beispiel definiert eine eigene Markierung @Inject mit RetentionPolicy.RUNTIME; die Annotation stellt keine Abhängigkeiten bereit. Constructor.getParameterTypes() liefert ein Class<?>[] in Deklarationsreihenfolge, ohne Parameter ein leeres Array. Es enthält Typen nach der Typlöschung, keine Argumentwerte oder generischen Typdetails. getDeclaredConstructor(...) verlangt exakte Typen: für int etwa int.class, nicht Integer.class.
Constructor.setAccessible(true) unterdrückt die Java-Sprachzugriffsprüfungen für dieses Reflection-Objekt, ohne die Modifikatoren des Konstruktors zu ändern. Prüfe zuerst canAccess(null). Für einen privaten Konstruktor in einem anderen Modul muss das Paket für das aufrufende Modul geöffnet sein; ein Export allein genügt nicht. Lassen die Zugriffsregeln der Module das Unterdrücken der Prüfungen nicht zu, löst setAccessible(true) eine InaccessibleObjectException aus, während trySetAccessible() false liefert. Ein Sicherheitsmanager kann beide Aufrufe mit SecurityException ablehnen. Unabhängig davon löst setAccessible(true) bei einem Konstruktor von java.lang.Class auch dann eine SecurityException aus, wenn das Paket geöffnet ist. Für einen solchen Konstruktor liefert trySetAccessible() false, sofern kein Sicherheitsmanager den Aufruf ablehnt. setAccessible(false) aktiviert die Prüfungen für dieses Objekt wieder.
Constructor.newInstance(Object...) ruft den bereits ausgewählten Konstruktor auf und liefert eine neue Instanz; es findet keine Überladungsauflösung statt. Übergib die Argumente in Parameterreihenfolge. Unboxing und erweiternde primitive Konvertierungen sind möglich, verengende nicht. Für einen Varargs-Parameter des Konstruktors übergib als letztes Argument ein einzelnes Array. Lege es in ein äußeres Object[] oder caste es zu Object, damit der Reflection-Aufruf seine Elemente nicht als einzelne Argumente behandelt. Bei einer in einem nicht statischen Kontext deklarierten inneren Klasse steht die umschließende Instanz an erster Stelle.
IllegalArgumentException kann auf eine falsche Anzahl oder inkompatible Argumenttypen hinweisen. IllegalAccessException meldet einen bei aktiver Zugriffsprüfung verbotenen Aufruf, InstantiationException den Versuch, eine abstrakte Klasse zu instanziieren. Eine vom Konstruktor ausgelöste Ausnahme wird in InvocationTargetException verpackt; prüfe getCause(). Ein Fehler im ausgewählten Konstruktor ist kein Grund, auf den parameterlosen Konstruktor auszuweichen.
Beispiele
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";
}
}Ergebnis
config no-arg
`Service` verwendet den privaten `@Inject`-Konstruktor, obwohl es auch einen parameterlosen gibt. `Fallback` hat keine Markierung und verwendet seinen parameterlosen Konstruktor. Das Beispiel übergibt `"config"` nur bei einer Signatur mit genau einem `String`-Parameter.
Zugehörige Lektionen
- Java · Lektion 59 · Fortgeschritten · Version: 2