Java反射：檢查對象是否已創建

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

在上面的代碼片段中，我面臨以下問題：

    nestedObject  = classType.newInstance();

這每次都會創建一個新的實例，因此，每次覆蓋先前的對象時，我最終都會為新的嵌套對象設置值。 我如何才能避免這種情況，並在循環中將值設置為已創建的對象。 有人可以建議我如何使其工作嗎？

我一定會將下面的代碼也更改為通用代碼，而不是限制為'的一個實例。 '作為定界符。但是請考慮首先正確地執行循環邏輯。

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

}

公共類ObjectA {

private String field1;

private int field2;

private String field3;

...

}

公共類ObjectB {

private String field1;

private String field2;

private String field3;

...

}

根據您的邏輯，當首先遇到ObjectA的字段（例如field2）時，nestedObject將具有ObjectA的實例。當我們接下來獲取ObjectB的字段（例如field1）時，我們檢查nestedObject是否為null且由於不為null我們不會創建新的例如對於這一點，我們最終會設立在下列線-在對象A對象B的字段值（字段1） 對象B。因為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();    
}