Question

   BeanInfo componentBeanInfo = null;
   List<String> propNames =new ArrayList<String>();
   Object nestedObject=null;
            try {
            componentBeanInfo = Introspector.getBeanInfo(sourceObject.getClass());  
            final PropertyDescriptor[] props=componentBeanInfo.getPropertyDescriptors();
            String [] parameters = getParameters(); //ObjectA.code="abc",ObjectA.type="single"
            for (String parameter : parameters) {
                boolean isNestedField = isNestedPropertyRead(parameter);
                for(PropertyDescriptor prop : props){
                    if(isNestedField){
                        String[] fullParam = parameter.split("\\.");//ObjectA.code
                        String nestedObj = fullParam[0];//ObjectA
                        String nestObjField = fullParam[1];//code
                        if(nestedObj.equalsIgnoreCase(prop.getName())){
                            Class<?> classType = Class.forName(prop.getPropertyType().getName());                       
                            BeanInfo nestedBeanInfo;
                            nestedBeanInfo = Introspector.getBeanInfo(classType);
                                final PropertyDescriptor[] nestedProps =nestedBeanInfo.getPropertyDescriptors();
                                    for(PropertyDescriptor nestedProp : nestedProps){
                                        if(nestedProp.getName().equalsIgnoreCase(nestObjField)){
                                            Class<?> nestedClassType = Class.forName(nestedProp.getPropertyType().getName());
                                            Object value = convertToObject(nestedClassType,value(parameter));
                                            try {                                       
                                                /*if(isNewProperty(prop.getName(),propNames)){
                                                 nestedObject = classType.newInstance();
                                                }*/
                                                if(nestedObject == null) {
                                                nestedObject  = classType.newInstance();
                                                }
                                                nestedProp.getWriteMethod().invoke(nestedObject, value);
                                                prop.getWriteMethod().invoke(sourceObject,nestedObject );
                                            } catch (IllegalArgumentException | InstantiationException | InvocationTargetException e) {
                                                e.printStackTrace();
                                            }
                                          break;
                                        }
                                    }
                            break;
                        }
                    }
                    else if(prop.getName().equalsIgnoreCase(parameter)){                    
                        try {
                            Class<?> classType = Class.forName(prop.getPropertyType().getName());
                            Object value = convertToObject(classType,value(parameter));
                            prop.getWriteMethod().invoke(sourceObject, value);
                            break;
                        } catch (IllegalArgumentException | InvocationTargetException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }   
      }catch (IntrospectionException | IllegalAccessException e) {
            e.printStackTrace();
      }

在上面的代码片段中，我面临问题w.r.t以下行 -

    nestedObject  = classType.newInstance();

每次都会创建新实例，因此我最终会生成新实例   每次覆盖时，都会将值设置为新的嵌套对象   上一个对象。我怎样才能避免这种情况并将值设置为已经   在循环中创建对象。任何人都可以建议我怎么能得到它   工作

我绝对会将下面的代码更改为通用代码   而不是局限于一个＆＃39; 。＆＃39;作为分隔符。但是   想到首先让循环逻辑正确。

String[] fullParam = parameter.split("\\.");//ObjectA.code
String nestedObj = fullParam[0];//ObjectA
String nestObjField = fullParam[1];//code

UPDATE-1 - @javaguy - 我的对象结构如下所示 -

public class OuterObject {

private String field1;

private ObjectA field2;

private ObjectB field3;

private String  field4;

...// can have lot of nested objects of different types like ObjectA,ObjectB etc

}

public class ObjectA {

private String field1;

private int field2;

private String field3;

...

}

public class ObjectB {

private String field1;

private String field2;

private String field3;

...

}

根据您的逻辑，nestedObject将具有ObjectA的实例首先遇到ObjectA的字段（比如field2）。当我们接下来得到ObjectB的字段时（比如field1）我们检查nestedObject是否为null，因为它不是null，我们不要为ObjectB创建新实例。因此我们最终设置 ObjectB在以下行中的ObjectA中的字段值（field1） - nestedProp.getWriteMethod().invoke(nestedObject, value);这个导致错误 - java.lang.IllegalArgumentException：对象不是声明类
的实例

Answer 1

您需要在循环外声明Object nestedObject=null;，然后通过检查它是null来创建实例，如下所示：

if(nestedObject == null) {
    nestedObject  = classType.newInstance();
}

Answer 2

我可以在添加以下代码行后使其工作 -

Object nestedObject = prop.getReadMethod().invoke(sourceObject);                                            
if(nestedObject == null){
        nestedObject  = classType.newInstance();    
}

Java Reflection：检查对象是否已创建

2 个答案: