web-dev-qa-db-fra.com

Java réflexion récupère tous les champs privés

Je me demande s’il existe un moyen d’obtenir tous les champs privés d’une classe dans Java et leur type.

Par exemple, supposons que j'ai une classe

class SomeClass {
    private String aaa;
    private SomeOtherClass bbb;
    private double ccc;
}

Maintenant, je voudrais obtenir tous les champs privés (aaa, bbb, ccc) de la classe SomeClass (sans connaître le nom de tous les champs à l’avance) et cocher leur type.

javareflectionfieldprivate
68
user2152361

Il est possible d'obtenir tous les champs avec la méthode getDeclaredFields() de Class. Ensuite, vous devez vérifier le modificateur de chaque champ pour trouver les champs privés:

List<Field> privateFields = new ArrayList<>();
Field[] allFields = SomeClass.class.getDeclaredFields();
for (Field field : allFields) {
    if (Modifier.isPrivate(field.getModifiers())) {
        privateFields.add(field);
    }
}

Notez que getDeclaredFields() ne retournera pas les champs hérités.

Finalement, vous obtenez le type des champs avec la méthode Field.getType () .

114
Cyrille Ka

Vous pouvez utiliser Modifier pour déterminer si un champ est privé. Veillez à utiliser la méthode getDeclaredFields pour récupérer les champs privés de la classe. L'appel de getFields ne renverra que les champs publics.

public class SomeClass {

    private String aaa;
    private Date date;
    private double ccc;
    public int notPrivate;

    public static void main(String[] args) {
        List<Field> fields = getPrivateFields(SomeClass.class);
        for(Field field: fields){
            System.out.println(field.getName());
        }
    }

    public static List<Field> getPrivateFields(Class<?> theClass){
        List<Field> privateFields = new ArrayList<Field>();

        Field[] fields = theClass.getDeclaredFields();

        for(Field field:fields){
            if(Modifier.isPrivate(field.getModifiers())){
                privateFields.add(field);
            }
        }
        return privateFields;
    }
}
13
Kevin Bowersox

Essayez FieldUtils de Apache commons-lang3:

FieldUtils.getAllFieldsList(Class<?> cls)
9
Martin Schröder

Utilisation de Java 8:

Field[] fields = String.class.getDeclaredFields();
List<Field> privateFieldList = Arrays.asList(fields).stream().filter(field -> Modifier.isPrivate(field.getModifiers())).collect(
        Collectors.toList());
8
Sahil Chhabra

Vérifier si un champ est privé

Vous pouvez filtrer les champs en utilisant Modifier.isPrivate :

import Java.lang.reflect.Field;
import Java.lang.reflect.Modifier;
// ...
Field field = null;
// retrieve the field in some way
// ...
Modifier.isPrivate(field.getModifiers())

sur un seul objet Field qui renvoie true si le champ est private

Recueillir tous les champs d'une classe

Pour collecter tous les champs utiliser:

1) Si vous n'avez besoin que des champs de la classe sans les champs issus de la hiérarchie des classes, vous pouvez simplement utiliser:

Field[] fields = SomeClass.class.getDeclaredFields();

2) Si vous ne voulez pas réinventer la roue et obtenir tous les champs d’une hiérarchie de classe sur laquelle vous pouvez compter Apache Commons Lang version 3.2+ qui fournit 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));
    }
}
7
madx

Tu veux dire comme

Field[] fields = SomeClass.class.getDeclaredFields();
4
Peter Lawrey