CKTIS / Java
Accesso riflessivo ai campi in Java
Individua un campo annotato, leggine il tipo dichiarato e assegnagli una dipendenza già costruita nel rispetto delle regole di accesso di Java SE 21.
Versione: Java SE 21
Sintassi
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 descrive un campo, non il suo valore in un oggetto specifico. Class.getDeclaredFields() restituisce i campi dichiarati nella classe, inclusi quelli privati ma non quelli ereditati. Field.isAnnotationPresent(Inject.class) restituisce true se sul campo è presente l’annotazione di dichiarazione @Inject. Un’annotazione personalizzata richiede @Retention(RetentionPolicy.RUNTIME) per essere visibile tramite riflessione. Per leggere questi metadati non occorre disattivare i controlli di accesso.
Field.getType() restituisce il tipo dichiarato come Class<?>, non il tipo del valore attuale. Per List<String> restituisce List.class, per int restituisce int.class. Usa getGenericType() per esaminare gli argomenti di tipo generici dichiarati. Per iniettare una dipendenza in un campo, usa il tipo per decidere cosa costruire, completane la costruzione ricorsiva e poi assegnala.
Field.setAccessible(true) disattiva, dove consentito, i controlli di accesso del linguaggio Java per quell’oggetto Field; false li ripristina. Non cambia i modificatori del campo. Per accedere in questo modo a un campo private da un altro modulo, il package deve essere aperto al modulo chiamante: exports non basta. Se non è possibile disattivare i controlli, il metodo lancia InaccessibleObjectException, mentre trySetAccessible() restituisce false. Entrambi i metodi possono lanciare SecurityException se un gestore della sicurezza attivo nega il permesso.
Field.set(obj, value) scrive il valore. Per un campo di istanza, obj deve essere un’istanza compatibile: null provoca NullPointerException e un destinatario di tipo errato provoca IllegalArgumentException. Per un campo static, obj è ignorato e può essere null. Il valore deve essere compatibile con il tipo del campo; per un campo primitivo, il metodo esegue l’unboxing e ammette conversioni di ampliamento, non di restringimento. Un valore incompatibile provoca IllegalArgumentException.
IllegalAccessException è un’eccezione controllata che il metodo lancia in scrittura se l’accesso è negato o se il campo final non è scrivibile. Disattivare i controlli non permette di scrivere campi static final o campi final di record e classi nascoste. Evita di scrivere nei campi final; se controlli la classe, preferisci l’iniezione tramite costruttore.
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.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";
}
}Risultato
ready
`build` crea `Service`, rileva `@Inject` e crea ricorsivamente `Repository` prima di scrivere nel campo privato `repository`. L’output atteso è `ready`. L’esempio si limita a classi concrete con costruttori accessibili senza argomenti; non gestisce cicli né sceglie implementazioni per le interfacce.
Lezioni correlate
- Java · Lezione 59 · Avanzato · Versione: 2