Java Reflection: Inspeccionar y modificar campos

Un objeto Field describe un campo de una clase: su nombre, su tipo, sus modificadores y — dado un instancia — su valor. La reflection te permite listar los campos de una clase, leerlos y escribirlos, incluso cuando son private y no tienen getter ni setter. Así es exactamente como los deserializadores JSON pueblan objetos y cómo los ORM hidratan entidades. Este capítulo cubre cómo obtener objetos Field, leer y escribir valores, la compuerta setAccessible y el caso especial de los campos final.

Este capítulo parte de la introducción a reflection. Para las APIs complementarias, consulta inspección de métodos e inspección de constructores.

Obtener objetos `Field`

Se aplica la misma división público/declarado de la introducción:

Class<?> c = User.class;

Field f1 = c.getField("name");             // public field, incl. inherited — else NoSuchFieldException
Field f2 = c.getDeclaredField("name");     // any access level, this class only

Field[] all   = c.getFields();             // public fields, incl. inherited
Field[] mine  = c.getDeclaredFields();     // all access levels, this class only

getField/getFields solo ven campos public pero siguen la cadena de herencia. getDeclaredField/getDeclaredFields también ven campos private/protected/de paquete, pero solo los declarados literalmente en la clase que se consulta. Para recopilar todos los campos, incluidos los private heredados, recorre getSuperclass() y combínalos.

Metadatos de campo: nombre, tipo, modificadores, genéricos

Un Field responde preguntas sobre sí mismo sin necesitar ninguna instancia:

Field f = User.class.getDeclaredField("age");

f.getName();           // "age"
f.getType();           // int.class           — the erased type
f.getGenericType();    // int                 — Type, keeps generic info
f.getModifiers();      // int bitset
Modifier.isPrivate(f.getModifiers());   // true/false
Modifier.isStatic(f.getModifiers());
Modifier.isFinal(f.getModifiers());
f.getDeclaringClass(); // class …User

getType() da el Class borrado (List); getGenericType() devuelve un Type que, para un campo List<String>, puedes convertir a ParameterizedType para recuperar String. Esa recuperación funciona porque las firmas genéricas de campo se conservan en el archivo de clase aunque las instancias se borren.

Leer y escribir valores

Para leer o escribir necesitas una instancia (o null para un campo static) y debes superar la verificación de acceso:

User u = new User("ada", 36);
Field age = User.class.getDeclaredField("age");
age.setAccessible(true);               // bypass the access check for private

int current = age.getInt(u);           // typed getter for primitives → 36
age.setInt(u, 37);                     // typed setter
Object boxed = age.get(u);             // generic getter, autoboxes → Integer 37
age.set(u, 40);                        // generic setter, autounboxes

Existen accesores tipados — getInt, getBoolean, getDouble, setLong, … — para campos primitivos, y los genéricos get(Object)/set(Object,Object) para cualquier campo (con boxing de primitivos). Para un campo static, pasa null como destino: staticField.get(null).

La compuerta `setAccessible`

Por defecto, un Field aplica las reglas de acceso de Java: leer un campo private de forma reflexiva lanza IllegalAccessException. field.setAccessible(true) suprime esa comprobación para este objeto Field. Eso es lo que permite a la reflection acceder a los internos — y lo que la hace peligrosa.

Dos advertencias desde Java 9:

Límites de módulo. Si el tipo destino está en un módulo que no ha abierto su paquete con opens hacia ti, setAccessible(true) lanza InaccessibleObjectException. Las bibliotecas te piden añadir --add-opens o que el módulo abra el paquete.
Es por objeto. Llamar a setAccessible(true) afecta solo a la instancia Field en la que se llama, no al campo globalmente. Un Field recién obtenido para el mismo miembro comienza bloqueado de nuevo.

Escribir campos `final`

Los campos final son un caso especial y delicado. Para un campo final no estático, a veces aún puedes escribirlo tras setAccessible(true):

Field f = Config.class.getDeclaredField("name");   // private final String
f.setAccessible(true);
f.set(config, "changed");                            // may work…

Pero hay advertencias importantes:

No funciona para constantes static final de tipo primitivo o String — estas son incrustadas por el compilador en cada sitio de uso, por lo que aunque cambies el campo, las lecturas ya compiladas no lo reflejarán.
La JVM y el JIT asumen que los campos final nunca cambian; mutar uno es comportamiento indefinido para la visibilidad y puede ser optimizado.
Los JDKs modernos lo prohíben cada vez más de forma rotunda.

La regla honesta: no mutes campos final de forma reflexiva en producción. Los frameworks de serialización que lo hacen (para reconstruir objetos inmutables) usan maquinaria de bajo nivel Unsafe/VarHandle y aceptan el riesgo deliberadamente. El ejemplo a continuación muestra el caso instance-final funcionando para ilustrar el mecanismo, no como recomendación.

Un ejemplo práctico: un pequeño mapeador basado en campos

El programa refleja sobre los campos declarados de un objeto para construir un Map<String,Object> (un mini serializador), luego toma un mapa y escribe sus valores en una instancia nueva (un mini deserializador) — accediendo a campos private en todo momento, sin getters ni setters en ningún lugar.

java— editable, runs on the server

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.*;

public class ReflectionFieldsDemo {

static class Account {
    private String owner;
    private int balance;
    private final String currency;       // instance-final
    private static int count = 0;         // static, not serialized

Account(String owner, int balance, String currency) {
      this.owner = owner;
      this.balance = balance;
      this.currency = currency;
      count++;
    }
    // deliberately NO getters/setters
    public String toString() {
      return owner + ": " + balance + " " + currency;
    }
  }

// mini-serializer: object -> map, skipping static fields
  static Map<String,Object> toMap(Object obj) throws IllegalAccessException {
    Map<String,Object> map = new LinkedHashMap<>();
    for (Field f : obj.getClass().getDeclaredFields()) {
      if (Modifier.isStatic(f.getModifiers())) continue;   // skip 'count'
      f.setAccessible(true);
      map.put(f.getName(), f.get(obj));
    }
    return map;
  }

// mini-deserializer: map -> object, writing each named field
  static Account fromMap(Map<String,Object> map) throws Exception {
    // build with placeholder values, then overwrite via reflection
    Account a = new Account("?", 0, "?");
    for (Map.Entry<String,Object> e : map.entrySet()) {
      Field f = Account.class.getDeclaredField(e.getKey());
      f.setAccessible(true);
      f.set(a, e.getValue());        // writes private — and even the final 'currency'
    }
    return a;
  }

public static void main(String[] args) throws Exception {
    Account original = new Account("ada", 100, "USD");
    System.out.println("original   : " + original);

Map<String,Object> snapshot = toMap(original);
    System.out.println("serialized : " + snapshot);

// mutate the map as if it came from JSON
    snapshot.put("balance", 250);
    snapshot.put("owner", "grace");

Account rebuilt = fromMap(snapshot);
    System.out.println("rebuilt    : " + rebuilt);

// field metadata, no instance needed
    Field bal = Account.class.getDeclaredField("balance");
    System.out.println("\nbalance type     = " + bal.getType().getSimpleName());
    System.out.println("balance modifiers= \"" + Modifier.toString(bal.getModifiers()) + "\"");
    Field cur = Account.class.getDeclaredField("currency");
    System.out.println("currency final?  = " + Modifier.isFinal(cur.getModifiers()));

// typed primitive accessor and a static read (target null)
    bal.setAccessible(true);
    System.out.println("getInt(rebuilt)  = " + bal.getInt(rebuilt));
    Field cnt = Account.class.getDeclaredField("count");
    cnt.setAccessible(true);
    System.out.println("static count     = " + cnt.get(null));
  }
}

Lo que se puede extraer de la ejecución:

toMap produjo una instantánea de cada campo de instancia sin un solo getter — getDeclaredFields() más setAccessible(true) accedieron directamente al estado private. Eso es, mecánicamente, lo que hacen Jackson y Gson cuando se configuran para acceso por campo. La clase no necesita ninguna API especial; la reflection proporciona la genérica.
El campo estático count fue excluido porque el bucle verificó Modifier.isStatic. Los serializadores habitualmente omiten los campos static, transient y sintéticos; el bitset de modificadores es la forma de tomar esas decisiones de manera uniforme en lugar de codificar nombres de campo.
fromMap escribió el campo private final currency tras setAccessible(true) y tuvo efecto — demostrando el mecanismo instance-final. Esto funcionó solo porque currency es un final no estático reasignado antes de que algún optimizador lo asumiera constante; depender de esto en código real es frágil, y las constantes static final no habrían cambiado.
Leer metadatos (bal.getType(), Modifier.toString(...), isFinal(...)) no requirió ninguna instancia de Account — un Field describe la declaración, que es la misma para cada objeto de la clase. Los valores necesitan una instancia; la forma no.
El getInt(rebuilt) tipado devolvió el primitivo directamente sin boxing, y la lectura del campo static usó cnt.get(null) — pasar null como destino es la convención para los estáticos. Elegir el accesor tipado para primitivos evita una asignación por lectura, lo que importa en rutas de serialización calientes.

Práctica

Una biblioteca JSON deserializa en una clase que tiene campos 'private' y sin setters. Usando reflection llama a 'getDeclaredField(name)' y luego a 'field.set(obj, value)', pero obtiene 'IllegalAccessException' en el primer campo privado. ¿Qué única llamada adicional lo soluciona y por qué es necesaria?

'field.setAccessible(true)' antes de la llamada 'set' — por defecto un 'Field' aplica las reglas de acceso de Java, y 'setAccessible(true)' suprime la comprobación de acceso para ese objeto 'Field' de modo que se puedan escribir miembros privados'field.setFinal(false)' — la excepción significa que el campo es implícitamente final y debe desbloquearse primeroCambiar de 'getDeclaredField' a 'getField' — 'getField' devuelve campos editables mientras que 'getDeclaredField' devuelve campos de solo lecturaEnvuelve el valor en el tipo wrapper correspondiente manualmente; la excepción es en realidad un fallo de autoboxing, no un problema de acceso

Obtener objetos Field