Rufen Sie alle privaten Felder mithilfe von Reflektion ab

Ich frage mich, ob es eine Möglichkeit gibt, alle privaten Felder einer Klasse in Java und ihren Typ zu erhalten.

Nehmen wir zum Beispiel an, ich habe eine Klasse:

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

Jetzt möchte ich alle privaten Felder (aaa, bbb, ccc) der Klasse SomeClass (Ohne die Namen aller Felder im Voraus zu kennen) und überprüfen Sie deren Typ.

Es ist möglich, alle Felder mit der Methode zu erhalten getDeclaredFields() von Class. Dann müssen Sie den Modifikator jedes Felds überprüfen, um die privaten zu finden:

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

Beachten Sie, dass getDeclaredFields() gibt keine geerbten Felder zurück.

Schließlich erhalten Sie den Typ der Felder mit der Methode Field.getType().

Sie können verwenden Modifier um festzustellen, ob ein Feld privat ist. Verwenden Sie unbedingt die getDeclaredFields -Methode, um sicherzustellen, dass Sie private Felder aus der Klasse abrufen, aufrufen getFields gibt nur die öffentlichen Felder zurück.

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

Versuchen FieldUtils von Apache commons-lang3:

FieldUtils.getAllFieldsList(Class<?> cls)

Verwendung von Java 8:

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

Überprüfen Sie, ob ein Feld privat ist

Sie könnten Filtern Sie die Felder verwenden Modifikator.istPrivat:

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

auf einer einzigen Field Objekt, das zurückkehrt true wenn das Feld ist private

Sammle alle Felder einer Klasse

Zu Sammle alle Felder verwenden:

1) Wenn Sie nur die Felder der Klasse ohne die Felder aus der Klassenhierarchie benötigen, können Sie einfach Folgendes verwenden:

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

2) Wenn Sie das Rad nicht neu erfinden und alle Felder einer Klassenhierarchie erhalten möchten, auf die Sie sich verlassen können Apache Commons Lang Version 3.2+, die bietet 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));
    }
}

Meinst du wie

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