Recuperando los nombres/valores heredados de los atributos usando Java Reflection

Question

Tengo un objeto Java 'ChildObj' que se extiende desde 'ParentObj'. Ahora, si es posible recuperar todos los nombres de atributos y valores de ChildObj, incluidos los atributos heredados también, utilizando el mecanismo de reflexión de Java?

Class.getFields me da la matriz de atributos públicos, y Class.getDeclaredFields me da la matriz de todos los campos, pero ninguno de ellos incluye la lista de campos heredados.

¿Hay alguna forma de recuperar los atributos heredados también?

Answer 1

no, tiene que escribirlo usted mismo. Es un método simple llamada recursiva en Class.getSuperClass():

public static List<Field> getAllFields(List<Field> fields, Class<?> type) { 
    fields.addAll(Arrays.asList(type.getDeclaredFields())); 

    if (type.getSuperclass() != null) { 
     getAllFields(fields, type.getSuperclass()); 
    } 

    return fields; 
} 

@Test 
public void getLinkedListFields() { 
    System.out.println(getAllFields(new LinkedList<Field>(), LinkedList.class)); 
} 

Answer 2

Es necesario llamar:

Class.getSuperclass().getDeclaredFields() 

manera recursiva hasta la jerarquía de herencia, según sea necesario.

Answer 3

que puede probar:

Class parentClass = getClass().getSuperclass(); 
    if (parentClass != null) { 
     parentClass.getDeclaredFields(); 
    } 

Answer 4

private static void addDeclaredAndInheritedFields(Class c, Collection<Field> fields) { 
    fields.addAll(Arrays.asList(c.getDeclaredFields())); 
    Class superClass = c.getSuperclass(); 
    if (superClass != null) { 
     addDeclaredAndInheritedFields(superClass, fields); 
    } 
} 

Answer 5

public static List<Field> getAllFields(Class<?> type) { 
     List<Field> fields = new ArrayList<Field>(); 
     for (Class<?> c = type; c != null; c = c.getSuperclass()) { 
      fields.addAll(Arrays.asList(c.getDeclaredFields())); 
     } 
     return fields; 
    } 

Answer 6

private static void addDeclaredAndInheritedFields(Class<?> c, Collection<Field> fields) { 
    fields.addAll(Arrays.asList(c.getDeclaredFields())); 
    Class<?> superClass = c.getSuperclass(); 
    if (superClass != null) { 
     addDeclaredAndInheritedFields(superClass, fields); 
    }  
} 

versión de "DidYouMeanThatTomHa ..." solución anterior

Answer 7

Las soluciones recursivas están bien de trabajo, el único problema es que devuelvan un superconjunto de miembros declarados y heredados. Tenga en cuenta que el método getDeclaredFields() devuelve también métodos privados. Por lo tanto, dado que navega por toda la jerarquía de superclase, incluirá todos los campos privados declarados en las superclases, y no se heredarán.

Un filtro simple con un Modificador.isPublic || predicado Modifier.isProtected haría:

import static java.lang.reflect.Modifier.isPublic; 
import static java.lang.reflect.Modifier.isProtected; 

(...) 

List<Field> inheritableFields = new ArrayList<Field>(); 
for (Field field : type.getDeclaredFields()) { 
    if (isProtected(field.getModifiers()) || isPublic(field.getModifiers())) { 
     inheritableFields.add(field); 
    } 
} 

Answer 8

Si por el contrario usted quiere depender de una biblioteca de lograr esto, Apache Commons Lang versión 3.2+ ofrece FieldUtils.getAllFieldsList:

import java.lang.reflect.Field; 
import java.util.AbstractCollection; 
import java.util.AbstractList; 
import java.util.AbstractSequentialList; 
import java.util.Arrays; 
import java.util.LinkedList; 
import java.util.List; 

import org.apache.commons.lang3.reflect.FieldUtils; 
import org.junit.Assert; 
import org.junit.Test; 

public class FieldUtilsTest { 

    @Test 
    public void testGetAllFieldsList() { 

     // Get all fields in this class and all of its parents 
     final List<Field> allFields = FieldUtils.getAllFieldsList(LinkedList.class); 

     // Get the fields form each individual class in the type's hierarchy 
     final List<Field> allFieldsClass = Arrays.asList(LinkedList.class.getFields()); 
     final List<Field> allFieldsParent = Arrays.asList(AbstractSequentialList.class.getFields()); 
     final List<Field> allFieldsParentsParent = Arrays.asList(AbstractList.class.getFields()); 
     final List<Field> allFieldsParentsParentsParent = Arrays.asList(AbstractCollection.class.getFields()); 

     // Test that `getAllFieldsList` did truly get all of the fields of the the class and all its parents 
     Assert.assertTrue(allFields.containsAll(allFieldsClass)); 
     Assert.assertTrue(allFields.containsAll(allFieldsParent)); 
     Assert.assertTrue(allFields.containsAll(allFieldsParentsParent)); 
     Assert.assertTrue(allFields.containsAll(allFieldsParentsParentsParent)); 
    } 
} 

Answer 9

más corto y con menos objeto instanciado? ^^

private static Field[] getAllFields(Class<?> type) { 
    if (type.getSuperclass() != null) { 
     return (Field[]) ArrayUtils.addAll(getAllFields(type.getSuperclass()), type.getDeclaredFields()); 
    } 
    return type.getDeclaredFields(); 
} 

Answer 10

Use Reflexiones de biblioteca:

public Set<Field> getAllFields(Class<?> aClass) { 
    return org.reflections.ReflectionUtils.getAllFields(aClass); 
}