CKTIS / Java
Accès réflexif aux champs en Java
Repérez un champ annoté, lisez son type déclaré et affectez-lui une dépendance construite en respectant les règles d’accès de Java SE 21.
Version : Java SE 21
Syntaxe
java.lang.reflect.Field — instance methods in Java SE 21
Class<?> getType()
boolean isAnnotationPresent(Class<? extends java.lang.annotation.Annotation> annotationClass)
void set(Object obj, Object value) throws IllegalArgumentException, IllegalAccessException
void setAccessible(boolean flag)java.lang.reflect.Field décrit un champ, pas sa valeur dans un objet précis. Class.getDeclaredFields() renvoie les champs déclarés par la classe, y compris les champs privés, mais pas ceux hérités. Field.isAnnotationPresent(Inject.class) renvoie true si l’annotation de déclaration @Inject est présente sur le champ. Une annotation personnalisée doit avoir @Retention(RetentionPolicy.RUNTIME) pour être visible par réflexion. Lire ces métadonnées ne nécessite pas de désactiver les contrôles d’accès.
Field.getType() renvoie le type déclaré sous forme de Class<?>, et non le type de la valeur actuelle. Pour List<String>, il renvoie List.class ; pour int, int.class. Utilisez getGenericType() pour examiner les arguments de type génériques déclarés. Pour injecter une dépendance dans un champ, déterminez à partir du type ce qu’il faut construire, terminez la construction récursive de la dépendance, puis affectez-la.
Field.setAccessible(true) désactive les contrôles d’accès du langage Java pour cet objet Field lorsque c’est autorisé ; false les rétablit. Les modificateurs du champ ne changent pas. Pour accéder ainsi à un champ private depuis un autre module, le paquet doit être ouvert au module appelant ; exports ne suffit pas. Si les contrôles ne peuvent pas être désactivés, la méthode lève InaccessibleObjectException, tandis que trySetAccessible() renvoie false. Les deux méthodes peuvent lever SecurityException si un gestionnaire de sécurité actif refuse l’autorisation.
Field.set(obj, value) écrit la valeur. Pour un champ d’instance, obj doit être une instance compatible : null provoque NullPointerException et un objet de type incorrect provoque IllegalArgumentException. Pour un champ static, obj est ignoré et peut valoir null. La valeur doit être compatible avec le type du champ ; pour un type primitif, la méthode extrait la valeur de son objet enveloppe et accepte un élargissement, pas un rétrécissement. Une valeur incompatible provoque IllegalArgumentException.
IllegalAccessException est une exception contrôlée levée lors de l’écriture si l’accès est refusé ou si le champ final n’est pas modifiable. Même en désactivant les contrôles, on ne peut pas écrire dans les champs static final ni dans les champs final des records ou des classes cachées. Évitez de modifier les champs final ; préférez l’injection par constructeur si vous maîtrisez la classe.
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.Field;
public class Main {
public static void main(String[] args) throws ReflectiveOperationException {
System.out.println(build(Service.class).message());
}
private static <T> T build(Class<T> type) throws ReflectiveOperationException {
T instance = type.getDeclaredConstructor().newInstance();
for (Field field : type.getDeclaredFields()) {
if (!field.isAnnotationPresent(Inject.class)) {
continue;
}
Object dependency = build(field.getType());
field.setAccessible(true);
field.set(instance, dependency);
}
return instance;
}
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Inject {}
class Service {
@Inject
private Repository repository;
String message() {
return repository.message();
}
}
class Repository {
String message() {
return "ready";
}
}Résultat
ready
`build` crée `Service`, détecte `@Inject` et crée `Repository` récursivement avant d’écrire dans le champ privé `repository`. La sortie attendue est `ready`. L’exemple se limite volontairement aux classes concrètes munies d’un constructeur accessible sans argument ; il ne gère ni les cycles ni le choix d’implémentations pour les interfaces.
Leçons associées
- Java · Leçon 59 · Avancé · Version : 2