40

比如说，我有一个方法可以返回List带有一些对象的自定义。他们归还Object给我。我需要从这些对象中获取某个字段的值，但我不知道对象的类。

有没有办法通过反射或其他方式做到这一点？

4

5 回答 5

61

假设一个简单的案例，您的字段是public：

List list; // from your method
for(Object x : list) {
    Class<?> clazz = x.getClass();
    Field field = clazz.getField("fieldName"); //Note, this can throw an exception if the field doesn't exist.
    Object fieldValue = field.get(x);
}

但这很丑陋，我忽略了所有的 try-catch，并做了一些假设（公共领域、可用的反射、好的安全管理器）。

如果您可以更改您的方法以返回 a List<Foo>，这将变得非常容易，因为迭代器可以为您提供类型信息：

List<Foo> list; //From your method
for(Foo foo:list) {
    Object fieldValue = foo.fieldName;
}

或者，如果您正在使用泛型不可用的 Java 1.4 接口，但您知道应该在列表中的对象的类型......

List list;
for(Object x: list) {
   if( x instanceof Foo) {
      Object fieldValue = ((Foo)x).fieldName;
   }
}

不需要反思:)

于 2013-04-23T14:38:28.967 回答
6

我强烈建议使用 Java 泛型来指定该列表中的对象类型，即。List<Car>. 如果你有汽车和卡车，你可以使用像这样的通用超类/接口List<Vehicle>。

但是，您可以使用 Spring 的 ReflectionUtils 使字段可访问，即使它们是私有的，如下面的可运行示例：

List<Object> list = new ArrayList<Object>();

list.add("some value");
list.add(3);

for(Object obj : list)
{
    Class<?> clazz = obj.getClass();

    Field field = org.springframework.util.ReflectionUtils.findField(clazz, "value");
    org.springframework.util.ReflectionUtils.makeAccessible(field);

    System.out.println("value=" + field.get(obj));
}

运行它有一个输出：

值=[C@1b67f74
值=3

于 2013-04-23T15:12:11.930 回答
3

如果您知道该字段所在的类，则可以使用反射访问它。这个例子（它在 Groovy 中，但方法调用是相同的）为类 Foo 获取一个 Field 对象，并为 object 获取它的值b。它表明您不必关心对象的确切具体类，重要的是您知道该字段所在的类，并且该类是对象的具体类或超类。

groovy:000> class Foo { def stuff = "asdf"}
===> true
groovy:000> class Bar extends Foo {}
===> true
groovy:000> b = new Bar()
===> Bar@1f2be27
groovy:000> f = Foo.class.getDeclaredField('stuff')
===> private java.lang.Object Foo.stuff
groovy:000> f.getClass()
===> class java.lang.reflect.Field
groovy:000> f.setAccessible(true)
===> null
groovy:000> f.get(b)
===> asdf
于 2013-04-23T14:33:00.017 回答
1 
public abstract class Refl {
    /** Use: Refl.<TargetClass>get(myObject,"x.y[0].z"); */
    public static<T> T get(Object obj, String fieldPath) {
        return (T) getValue(obj, fieldPath);
    }
    public static Object getValue(Object obj, String fieldPath) {
        String[] fieldNames = fieldPath.split("[\\.\\[\\]]");
        String success = "";
        Object res = obj;
        for (String fieldName : fieldNames) {
            if (fieldName.isEmpty()) continue;
            int index = toIndex(fieldName);
            if (index >= 0) {
                try {
                    res = ((Object[])res)[index];
                } catch (ClassCastException cce) {
                    throw new RuntimeException("cannot cast "+res.getClass()+" object "+res+" to array, path:"+success, cce);
                } catch (IndexOutOfBoundsException iobe) {
                    throw new RuntimeException("bad index "+index+", array size "+((Object[])res).length +" object "+res +", path:"+success, iobe);
                }
            } else {
                Field field = getField(res.getClass(), fieldName);
                field.setAccessible(true);
                try {
                    res = field.get(res);
                } catch (Exception ee) {
                    throw new RuntimeException("cannot get value of ["+fieldName+"] from "+res.getClass()+" object "+res +", path:"+success, ee);
                }
            }
            success += fieldName + ".";
        }
        return res;
    }

    public static Field getField(Class<?> clazz, String fieldName) {
        Class<?> tmpClass = clazz;
        do {
            try {
                Field f = tmpClass.getDeclaredField(fieldName);
                return f;
            } catch (NoSuchFieldException e) {
                tmpClass = tmpClass.getSuperclass();
            }
        } while (tmpClass != null);

        throw new RuntimeException("Field '" + fieldName + "' not found in class " + clazz);
    }

    private static int toIndex(String s) {
        int res = -1;
        if (s != null && s.length() > 0 && Character.isDigit(s.charAt(0))) {
            try {
                res = Integer.parseInt(s);
                if (res < 0) {
                    res = -1;
                }
            } catch (Throwable t) {
                res = -1;
            }
        }
        return res;
    }
}

它支持获取字段和数组项，例如：

System.out.println(""+Refl.getValue(b,"x.q[0].z.y"));

点和大括号没有区别，它们只是分隔符，空字段名被忽略：

System.out.println(""+Refl.getValue(b,"x.q[0].z.y[value]"));
System.out.println(""+Refl.getValue(b,"x.q.1.y.z.value"));
System.out.println(""+Refl.getValue(b,"x[q.1]y]z[value"));
于 2017-02-03T17:45:40.363 回答
-1

还有另一种方法，我在我的项目中遇到了同样的情况。我这样解决了

List<Object[]> list = HQL.list();

在上面的休眠查询语言中，我知道我的对象在哪个地方，所以我所做的是：

for(Object[] obj : list){
String val = String.valueOf(obj[1]);
int code =Integer.parseint(String.valueof(obj[0]));
}

通过这种方式，您可以轻松获得混合对象，但您应该提前知道您在哪个位置获得了什么值，或者您可以通过打印要知道的值来检查。抱歉英语不好我希望这有帮助

于 2014-05-13T08:37:29.093 回答