CKTIS / Java
Een constructor kiezen en aanroepen met reflectie
Kies de enige constructor met `@Inject`, of gebruik een constructor zonder argumenten als er geen is gemarkeerd. Controleer de parametertypen en de toegang vóór de aanroep.
Versie: 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 staat java.lang.reflect.Constructor<T> voor één specifieke constructor. Class.getDeclaredConstructors() bevat ook niet-openbare constructors en garandeert geen volgorde; Class.getConstructors() geeft alleen openbare constructors terug. Kies de enige constructor met @Inject. Zijn er meerdere gemarkeerd, meld dan de dubbelzinnigheid in plaats van de eerste te kiezen. Is er geen gemarkeerd, gebruik dan Class.getDeclaredConstructor(); ontbreekt een constructor zonder argumenten, dan volgt NoSuchMethodException.
Constructor.isAnnotationPresent(Inject.class) controleert of de constructor zelf, niet zijn parameters, de opgegeven tijdens runtime zichtbare annotatie heeft. Het voorbeeld definieert een eigen @Inject-markering met RetentionPolicy.RUNTIME; de annotatie levert zelf geen afhankelijkheden. Constructor.getParameterTypes() geeft een Class<?>[] terug in declaratievolgorde, leeg als er geen parameters zijn. De array bevat typen na type-erasure, geen argumentwaarden of generieke details. getDeclaredConstructor(...) vereist exacte typen: gebruik voor int dus int.class, niet Integer.class.
Constructor.setAccessible(true) schakelt de toegangscontroles van de Java-taal uit voor dat reflectieobject, zonder de modifiers van de constructor te wijzigen. Controleer eerst canAccess(null). Voor een private constructor in een andere module moet het pakket openstaan voor de aanroepende module; alleen exporteren is niet voldoende. Als de toegangsregels tussen modules het uitschakelen van de controles verhinderen, gooit setAccessible(true) een InaccessibleObjectException, terwijl trySetAccessible() false teruggeeft. Een securitymanager kan beide aanroepen weigeren met SecurityException. Los daarvan gooit setAccessible(true) bij een constructor van java.lang.Class een SecurityException, ook als het pakket openstaat. Voor zo’n constructor geeft trySetAccessible() false terug, tenzij een securitymanager de aanroep weigert. setAccessible(false) schakelt de controles voor dat object weer in.
Constructor.newInstance(Object...) roept de al gekozen constructor aan en geeft een nieuwe instantie terug; het kiest geen overload. Geef de argumenten in parametervolgorde door. Unboxing en verbredende primitieve conversies zijn toegestaan, vernauwende niet. Geef voor een varargs-parameter van de constructor één array door als laatste argument: plaats die in een overkoepelende Object[] of cast die naar Object, zodat de reflectieve aanroep de elementen niet als losse argumenten behandelt. Geef bij een innerlijke klasse die in een niet-statische context is gedeclareerd eerst de omsluitende instantie door.
IllegalArgumentException kan wijzen op een verkeerd aantal argumenten of incompatibele typen. IllegalAccessException betekent dat de aanroep bij actieve toegangscontroles is geweigerd; InstantiationException duidt op een poging een abstracte klasse te instantiëren. Een uitzondering uit de constructor wordt verpakt in InvocationTargetException; bekijk getCause(). Een fout in de gekozen constructor is geen reden om terug te vallen op de constructor zonder argumenten.
Voorbeelden
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";
}
}Resultaat
config no-arg
`Service` gebruikt zijn private `@Inject`-constructor, hoewel het ook een constructor zonder argumenten heeft. `Fallback` heeft geen markering en gebruikt zijn constructor zonder argumenten. Het voorbeeld geeft `"config"` alleen door voor de signatuur met één `String`-parameter.
Gerelateerde lessen
- Java · Les 59 · Gevorderd · Versie: 2