Java反射，有没有一种简单的方法可以通过“字段路径”获取字段值？

Question

I have a pretty complex class, like,

classA {
  public classB b;
}

classB {
  public classC c;
}

classC {
  public List<classD> d;
}
...

Now, given an instance of classA, and a field path like 'bcdefg', is there an easy way to get the target field value via reflection? Any existing library or something?

Many thanks.

Answer 1

There is not an "easy" way (and there is definitely not an easy way to navigate into a List of classD elements by using a field path like bcdef , as (at some point) you would need to specify which element in the list you are looking at.

Nevertheless, you can use reflection to navigate down a queue of fields, like so:

public static void main(final String args[]) throws Exception
{
    // Initialize all variables
    final ClassA a = new ClassA();
    a.b = new ClassB();
    a.b.c = new ClassC();
    a.b.c.d = new ArrayList<>();
    a.b.c.d.add(new ClassD("Success!"));

    final String fieldPath = "b.c.d";

    final Queue<String> fieldPaths = buildFieldPaths(fieldPath);

    System.out.println(((List<ClassD>) discover(a, fieldPaths)).get(0).s);
}

public static Object discover(final Object o, final Queue<String> fieldPaths) throws Exception
{
    // End of the queue, return the object found most recently
    if (null == fieldPaths.peek())
    {
        return o;
    }

    final String nextFieldPath = fieldPaths.remove();

    final Field f[] = o.getClass().getDeclaredFields();
    for (final Field next : f)
    {
        final String nextName = next.getName();
        System.out.println("Checking " + o.getClass().getName() + ": " + nextName);
        if (nextName.equals(nextFieldPath))
        {
            System.out.println("Found: " + nextName);
            return discover(next.get(o), fieldPaths);
        }
    }

    throw new RuntimeException("Field not found: " + nextFieldPath);
}

public static Queue<String> buildFieldPaths(final String s)
{
    final Queue<String> fieldPaths = new PriorityQueue<>();
    for (final String next : s.split("\\."))
    {
        fieldPaths.add(next);
    }
    return fieldPaths;
}

protected static class ClassA
{
    public ClassB b;
}

protected static class ClassB
{
    public ClassC c;
}

protected static class ClassC
{
    public List<ClassD> d;
}

protected static class ClassD
{
    public String s;

    public ClassD(final String s)
    {
        this.s = s;
    }
}

Running this program should output

Checking ClassA: b
Found: b
Checking ClassB: c
Found: c
Checking ClassC: d
Found: d
Success!

Take note: the final Success! string is being retrieved from inside the List<ClassD> using some extra code, and is not actually part the field path recursion of discovery.

Answer 2

Thank you all for the post.

Thanks Tim, commons-beanutils helps a lot when handling pojo classes, it works pretty fine for List/Map field.

This is almost what I need, except a few edge cases, for example, when giving a List with no index provided.

I think the way to go is to write my own tool with the help of commons-beanutils.