Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Acceso reflexivo a campos en Java

Identifica un campo anotado, consulta su tipo declarado y asígnale una dependencia ya construida respetando las reglas de acceso de Java SE 21.

Versión: Java SE 21

Sintaxis

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 describe un campo, no su valor en un objeto determinado. Class.getDeclaredFields() devuelve los campos declarados en la clase, incluidos los privados, pero no los heredados. Field.isAnnotationPresent(Inject.class) devuelve true si el campo tiene la anotación de declaración @Inject. Para que una anotación propia sea visible mediante reflexión necesita @Retention(RetentionPolicy.RUNTIME). Leer estos metadatos no requiere suprimir las comprobaciones de acceso.

Field.getType() devuelve el tipo declarado como Class<?>, no el tipo del valor actual. Para List<String> devuelve List.class y para int, int.class. Usa getGenericType() para examinar los argumentos de tipo genéricos declarados. Para inyectar una dependencia en un campo, decide qué construir a partir del tipo, termina de construir la dependencia de forma recursiva y luego asígnala.

Field.setAccessible(true) suprime las comprobaciones de acceso de Java para ese objeto Field cuando está permitido; false las restablece. No cambia los modificadores del campo. Para acceder así a un campo private desde otro módulo, el paquete debe estar abierto al módulo que realiza la llamada; exports por sí solo no basta. Si no se pueden suprimir las comprobaciones, el método lanza InaccessibleObjectException; en ese caso, trySetAccessible() devuelve false. Ambos métodos pueden lanzar SecurityException si un gestor de seguridad activo deniega el permiso.

Field.set(obj, value) escribe el valor. Si el campo es de instancia, obj debe ser una instancia compatible: null provoca NullPointerException y un receptor de tipo incorrecto provoca IllegalArgumentException. Si el campo es static, obj se ignora y puede ser null. El valor debe ser compatible con el tipo del campo; en un campo primitivo se desempaqueta el valor y se admite el ensanchamiento, no el estrechamiento. Un valor incompatible provoca IllegalArgumentException.

IllegalAccessException es una excepción comprobada que se lanza al escribir si se deniega el acceso o no se puede modificar el campo final. Ni siquiera al suprimir las comprobaciones se pueden modificar los campos static final ni los campos final de registros o clases ocultas. Evita escribir en campos final; prefiere la inyección por constructor cuando controles la clase.

Ejemplos

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";
    }
}

Resultado

ready

`build` crea `Service`, detecta `@Inject` y crea `Repository` de forma recursiva antes de escribir en el campo privado `repository`. La salida esperada es `ready`. El ejemplo se limita a clases concretas con constructores accesibles sin argumentos; no resuelve ciclos ni elige implementaciones de interfaces.

Lecciones relacionadas

  • Java · Lección 59 · Avanzado · Versión: 2

Fuentes