CKTIS / Java
Choisir et appeler un constructeur par réflexion
Sélectionnez l’unique constructeur annoté `@Inject` ou, si aucun ne l’est, le constructeur sans argument. Vérifiez les types des paramètres et l’accès avant l’appel.
Version : Java SE 21
Syntaxe
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[]Dans Java SE 21, java.lang.reflect.Constructor<T> représente un constructeur précis. Class.getDeclaredConstructors() inclut les constructeurs non publics et ne garantit aucun ordre ; Class.getConstructors() ne renvoie que les constructeurs publics. Sélectionnez l’unique constructeur annoté @Inject. Si plusieurs le sont, signalez l’ambiguïté au lieu de prendre le premier. Si aucun ne l’est, utilisez Class.getDeclaredConstructor() ; en l’absence de constructeur sans argument, cet appel lève NoSuchMethodException.
Constructor.isAnnotationPresent(Inject.class) vérifie si le constructeur lui-même, et non ses paramètres, porte l’annotation indiquée, visible à l’exécution. L’exemple définit sa propre annotation de marquage @Inject avec RetentionPolicy.RUNTIME ; l’annotation ne fournit pas les dépendances. Constructor.getParameterTypes() renvoie un Class<?>[] dans l’ordre de déclaration, vide s’il n’y a pas de paramètres. Il contient les types après effacement, pas les valeurs des arguments ni les détails génériques. getDeclaredConstructor(...) exige les types exacts : pour int, utilisez int.class, et non Integer.class.
Constructor.setAccessible(true) désactive les contrôles d’accès du langage Java pour cet objet de réflexion sans changer les modificateurs du constructeur. Vérifiez d’abord canAccess(null). Pour un constructeur privé situé dans un autre module, le paquet doit être ouvert au module appelant ; l’exporter ne suffit pas. Si les règles d’accès entre modules empêchent la désactivation des contrôles, setAccessible(true) lève InaccessibleObjectException, tandis que trySetAccessible() renvoie false. Un gestionnaire de sécurité peut refuser l’un ou l’autre appel avec SecurityException. Indépendamment du gestionnaire de sécurité, setAccessible(true) lève SecurityException pour un constructeur de java.lang.Class, même si le paquet est ouvert. Pour un tel constructeur, trySetAccessible() renvoie false, sauf si un gestionnaire de sécurité refuse l’appel. setAccessible(false) rétablit les contrôles pour cet objet.
Constructor.newInstance(Object...) appelle le constructeur déjà sélectionné et renvoie une nouvelle instance ; il ne choisit pas de surcharge. Fournissez les arguments dans l’ordre des paramètres. Le déballage et l’élargissement des types primitifs sont autorisés, pas les conversions primitives réductrices. Un paramètre varargs du constructeur attend un seul tableau en dernier argument : placez ce tableau dans un Object[] englobant ou convertissez-le en Object pour que l’appel par réflexion ne traite pas ses éléments comme des arguments distincts. Pour une classe interne déclarée dans un contexte non statique, passez d’abord l’instance englobante.
IllegalArgumentException peut indiquer un nombre incorrect d’arguments ou des types incompatibles. IllegalAccessException indique un appel interdit lorsque les contrôles d’accès sont actifs ; InstantiationException signale une tentative d’instancier une classe abstraite. Une exception levée par le constructeur est encapsulée dans InvocationTargetException ; examinez getCause(). Un échec du constructeur sélectionné ne justifie pas de se rabattre sur le constructeur sans argument.
Exemples
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";
}
}Résultat
config no-arg
`Service` utilise son constructeur privé annoté `@Inject` même s’il possède aussi un constructeur sans argument. `Fallback` n’a pas de marqueur et utilise son constructeur sans argument. L’exemple fournit `"config"` uniquement pour la signature à un seul paramètre `String`.
Leçons associées
- Java · Leçon 59 · Avancé · Version : 2