Examples with BeanInfo java.beans.BeanInfo used on opensource projects

Example 21 with BeanInfo

use of java.beans.BeanInfo in project coprhd-controller by CoprHD.

the class DbCli method readXMLAndPersist.

/**
 * Load xml file and save model object into Cassandra.
 *
 * @Param fileName
 */
private <T extends DataObject> void readXMLAndPersist(String fileName, DbCliOperation operation) throws Exception {
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = dbf.newDocumentBuilder();
    Document doc = builder.parse(fileName);
    // Read root node
    Element root = doc.getDocumentElement();
    Element dataObjectNode = (Element) root.getElementsByTagName("data_object_schema").item(0);
    // Get column family's name
    String cfName = dataObjectNode.getAttribute("name");
    System.out.println("Column Family based on XML: " + cfName);
    NodeList recordNodes = dataObjectNode.getElementsByTagName("record");
    Class<T> clazz = _cfMap.get(cfName);
    if (clazz == null) {
        System.out.println("Unknown Column Family: " + cfName);
        return;
    }
    // Get class info
    BeanInfo bInfo;
    try {
        bInfo = Introspector.getBeanInfo(clazz);
    } catch (IntrospectionException ex) {
        throw new RuntimeException("Unexpected exception getting bean info", ex);
    }
    PropertyDescriptor[] pds = bInfo.getPropertyDescriptors();
    // get position of xml node
    InputStream xmlIs = new FileInputStream(new File(fileName));
    Document docForPosition = PositionalXMLReader.readXML(xmlIs);
    xmlIs.close();
    for (int i = 0; i < recordNodes.getLength(); i++) {
        Element record = (Element) recordNodes.item(i);
        T object = null;
        String idStr = null;
        if (operation == DbCliOperation.LOAD) {
            // query record based id
            String recordId = record.getAttribute("id");
            System.out.println(String.format("Object id:\t%s", recordId));
            idStr = recordId;
            object = queryObject(URI.create(recordId), clazz);
        } else if (operation == DbCliOperation.CREATE) {
            // create new id for create record
            URI id = URIUtil.createId(clazz);
            object = clazz.newInstance();
            object.setId(id);
            System.out.println(String.format("Create new data object id:\t%s", object.getId()));
            idStr = object.getId().toString();
        }
        HashMap<String, String> fieldValueMap = new HashMap<String, String>();
        HashMap<String, Class> fieldTypeMap = new HashMap<String, Class>();
        HashMap<String, String> fieldLocationMap = new HashMap<String, String>();
        HashMap<String, Node> fieldNodeMap = new HashMap<String, Node>();
        NodeList fields = record.getElementsByTagName("field");
        // get field info from xml file
        for (int j = 0; j < fields.getLength(); j++) {
            Element field = (Element) fields.item(j);
            if (DEBUG) {
                System.out.println(field.getAttribute("name") + "\t" + field.getAttribute("type") + "\t" + field.getAttribute("value"));
            }
            fieldValueMap.put(field.getAttribute("name"), field.getAttribute("value"));
            fieldTypeMap.put(field.getAttribute("name"), Class.forName(field.getAttribute("type")));
            fieldLocationMap.put(field.getAttribute("name"), ((Element) docForPosition.getElementsByTagName("record").item(i)).getElementsByTagName("field").item(j).getUserData("lineNumber").toString());
            if (field.getElementsByTagName("wrapper").item(0) != null) {
                fieldNodeMap.put(field.getAttribute("name"), field.getElementsByTagName("wrapper").item(0));
            }
        }
        Iterator locationIt = fieldLocationMap.entrySet().iterator();
        while (locationIt.hasNext()) {
            Entry entry = (Entry) locationIt.next();
            String key = (String) entry.getKey();
            String value = (String) entry.getValue();
            if (DEBUG) {
                System.out.println("key:\t" + key + "\tvalue\t" + value);
            }
        }
        // update object's fields
        for (PropertyDescriptor pd : pds) {
            // skip class property, id property
            if (pd.getName().equals("class") || pd.getName().equals("id")) {
                continue;
            }
            Name name = pd.getReadMethod().getAnnotation(Name.class);
            if (name == null) {
                log.info("Ignore data object fields without @Name annotation, fieldName={}.", pd.getName());
                continue;
            }
            String objKey = name.value();
            String fieldValue = fieldValueMap.get(objKey);
            if (fieldValue == null) {
                // To support xml file that the old version dumped, it used method name not @Name value
                objKey = pd.getName();
            }
            fieldValue = fieldValueMap.get(objKey);
            Class fieldClass = fieldTypeMap.get(objKey);
            String fieldLocation = fieldLocationMap.get(objKey);
            Node fieldNode = fieldNodeMap.get(objKey);
            if (fieldValue != null) {
                Class type = pd.getPropertyType();
                if (DEBUG) {
                    System.out.print("\t" + objKey + " = " + type);
                }
                try {
                    if (type == URI.class) {
                        pd.getWriteMethod().invoke(object, URI.create(fieldValue));
                    } else if (type == NamedURI.class) {
                        pd.getWriteMethod().invoke(object, NamedURI.fromString(fieldValue));
                    } else if (type == Date.class) {
                    // Can not find records with value which owns this type. Remains to be verified correct or not.
                    // System.out.println("\ttype: Date ");
                    } else if (type == Calendar.class) {
                        Calendar calendar = FieldType.toCalendar(fieldValue);
                        if (!verifyField(calendar)) {
                            throw new Exception("field format exception");
                        }
                        pd.getWriteMethod().invoke(object, calendar);
                    } else if (type == StringMap.class) {
                        StringMap newStringMap = FieldType.convertType(fieldNode, StringMapWrapper.class);
                        if (!verifyField(newStringMap)) {
                            throw new Exception("field format exception");
                        }
                        StringMap sMap = (StringMap) pd.getReadMethod().invoke(object);
                        if (sMap == null) {
                            sMap = new StringMap();
                        }
                        sMap.clear();
                        Set<String> keys = newStringMap.keySet();
                        for (String key : keys) {
                            sMap.put(key, newStringMap.get(key));
                        }
                        pd.getWriteMethod().invoke(object, sMap);
                    } else if (type == StringSet.class) {
                        StringSet stringSet = FieldType.convertType(fieldNode, StringSetWrapper.class);
                        if (!verifyField(stringSet)) {
                            throw new Exception("field format exception");
                        }
                        StringSet updateSet = (StringSet) pd.getReadMethod().invoke(object);
                        if (updateSet != null) {
                            updateSet.clear();
                            updateSet.addAll(stringSet);
                        } else {
                            pd.getWriteMethod().invoke(object, stringSet);
                        }
                    } else if (type == OpStatusMap.class) {
                        OpStatusMap opStatusMap = FieldType.convertType(fieldNode, OpStatusMapWrapper.class);
                        if (!verifyField(opStatusMap)) {
                            throw new Exception("field format exception");
                        }
                    } else if (type == StringSetMap.class) {
                        StringSetMap newSetMap = FieldType.convertType(fieldNode, StringSetMapWrapper.class);
                        if (!verifyField(newSetMap)) {
                            throw new Exception("field format exception");
                        }
                        StringSetMap sMap = (StringSetMap) pd.getReadMethod().invoke(object);
                        if (sMap == null) {
                            sMap = new StringSetMap();
                        }
                        Set<String> keys = sMap.keySet();
                        for (String key : keys) {
                            sMap.remove(key);
                        }
                        keys = newSetMap.keySet();
                        for (String key : keys) {
                            sMap.put(key, newSetMap.get(key));
                        }
                    } else if (type == FSExportMap.class) {
                        FSExportMap fSExportMap = FieldType.convertType(fieldNode, FSExportMapWrapper.class);
                        if (!verifyField(fSExportMap)) {
                            throw new Exception("field format exception");
                        }
                        pd.getWriteMethod().invoke(object, fSExportMap);
                    } else if (type == SMBShareMap.class) {
                        SMBShareMap sMBShareMap = FieldType.convertType(fieldNode, SMBShareMapWrapper.class);
                        if (!verifyField(sMBShareMap)) {
                            throw new Exception("field format exception");
                        }
                        pd.getWriteMethod().invoke(object, sMBShareMap);
                    } else if (type == ScopedLabelSet.class) {
                        ScopedLabelSet scopedLabelSet = FieldType.convertType(fieldNode, ScopedLabelSetWrapper.class);
                        if (!verifyField(scopedLabelSet)) {
                            throw new Exception("field format exception");
                        }
                        ScopedLabelSet updateSet = (ScopedLabelSet) pd.getReadMethod().invoke(object);
                        if (updateSet != null) {
                            updateSet.clear();
                            updateSet.addAll(scopedLabelSet);
                        } else {
                            pd.getWriteMethod().invoke(object, scopedLabelSet);
                        }
                    } else if (type == String.class) {
                        pd.getWriteMethod().invoke(object, fieldClass.cast(fieldValue));
                    } else if (type.isEnum()) {
                        Object enumTypeObject = null;
                        try {
                            enumTypeObject = Enum.valueOf(type, fieldValue);
                        } catch (Exception e) {
                            throw new Exception("field format exception");
                        }
                        pd.getWriteMethod().invoke(object, enumTypeObject);
                    } else if (type == Integer.class) {
                        Integer intNum = FieldType.toInteger(fieldValue);
                        if (!verifyField(intNum)) {
                            throw new Exception("field format exception");
                        }
                        pd.getWriteMethod().invoke(object, intNum);
                    } else if (type == Boolean.class) {
                        Boolean boolVal = FieldType.toBoolean(fieldValue);
                        if (!verifyField(boolVal)) {
                            throw new Exception("field format exception");
                        }
                        pd.getWriteMethod().invoke(object, boolVal);
                    } else if (type == Long.class) {
                        Long longNum = FieldType.toLong(fieldValue);
                        if (!verifyField(longNum)) {
                            throw new Exception("field format exception");
                        }
                        pd.getWriteMethod().invoke(object, longNum);
                    } else if (type == Short.class) {
                        Short shortNum = FieldType.toShort(fieldValue);
                        if (!verifyField(shortNum)) {
                            throw new Exception("field format exception");
                        }
                        pd.getWriteMethod().invoke(object, shortNum);
                    } else if (type == Double.class) {
                        Double doubleNum = FieldType.toDouble(fieldValue);
                        if (!verifyField(doubleNum)) {
                            throw new Exception("field format exception");
                        }
                        pd.getWriteMethod().invoke(object, doubleNum);
                    } else {
                        pd.getWriteMethod().invoke(object, fieldValue);
                    }
                } catch (Exception e) {
                    System.out.println(String.format("Exception in getting field:%s in xml file line:%s.", pd.getName(), fieldLocation));
                    log.error("Exception in getting field value in xml file line:{}.", fieldLocation, e);
                    throw new Exception(String.format("Exception in getting field value in line:%s.", fieldLocation));
                }
                if (DEBUG) {
                    Object fieldValue1 = pd.getReadMethod().invoke(object);
                    System.out.println("write " + fieldValue1 + "\ttype: " + type + " success");
                }
            }
        }
        if (operation == DbCliOperation.CREATE) {
            // Save model object.
            _dbClient.createObject(object);
        } else if (operation == DbCliOperation.LOAD) {
            _dbClient.persistObject(object);
        }
        log.info(String.format("Successfully update Column family:%s, \tdata object id:%s \tinto Cassandra, based on xml file %s", cfName, idStr, fileName));
    }
}

Example 22 with BeanInfo

use of java.beans.BeanInfo in project coprhd-controller by CoprHD.

the class DbCli method queryAndPrintRecords.

/**
 * Query for records with the given ids and type, and print the contents in human readable format
 *
 * @param ids
 * @param clazz
 * @param <T>
 */
private <T extends DataObject> int queryAndPrintRecords(List<URI> ids, Class<T> clazz) throws Exception {
    Iterator<T> objects;
    BeanInfo bInfo;
    int countLimit = 0;
    int countAll = 0;
    String input;
    BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
    try {
        objects = _dbClient.queryIterativeObjects(clazz, ids);
        bInfo = Introspector.getBeanInfo(clazz);
        while (objects.hasNext()) {
            T object = (T) objects.next();
            printBeanProperties(bInfo.getPropertyDescriptors(), object);
            countLimit++;
            countAll++;
            if (!turnOnLimit || countLimit != listLimit) {
                continue;
            }
            System.out.println(String.format("Read %s rows ", countAll));
            do {
                System.out.println("\nPress 'ENTER' to continue or 'q<ENTER>' to quit...");
                input = buf.readLine();
                if (input.isEmpty()) {
                    countLimit = 0;
                    break;
                }
                if (input.equalsIgnoreCase(QUITCHAR)) {
                    return countAll;
                }
            } while (!input.isEmpty());
        }
    } catch (DatabaseException ex) {
        log.error("Error querying from db: " + ex);
        System.out.println("Error querying from db: " + ex);
        throw ex;
    } catch (IntrospectionException ex) {
        log.error("Unexpected exception getting bean info", ex);
        throw new RuntimeException("Unexpected exception getting bean info", ex);
    } finally {
        buf.close();
    }
    return countAll;
}

Example 23 with BeanInfo

use of java.beans.BeanInfo in project coprhd-controller by CoprHD.

the class DbCli method queryAndPrintRecord.

/**
 * Query for a record with the given id and type, and print the contents in human readable format
 * if query URI list, use queryAndPrintRecords(ids, clazz) method instead.
 *
 * @param id
 * @param clazz
 * @param <T>
 */
private <T extends DataObject> void queryAndPrintRecord(URI id, Class<T> clazz, DbCliOperation operationType) throws Exception {
    T object = queryObject(id, clazz);
    if (object == null) {
        // id object deleted
        System.out.println("id: " + id + " [ Deleted ]");
        return;
    }
    BeanInfo bInfo;
    try {
        bInfo = Introspector.getBeanInfo(clazz);
    } catch (IntrospectionException ex) {
        throw new RuntimeException("Unexpected exception getting bean info", ex);
    }
    if (operationType == DbCliOperation.LIST) {
        printBeanProperties(bInfo.getPropertyDescriptors(), object);
    } else {
        dumpBeanProperties(bInfo.getPropertyDescriptors(), object);
    }
}

Example 24 with BeanInfo

use of java.beans.BeanInfo in project Gargoyle by callakrsos.

the class ObjectUtil method toMap.

/**
	 * @작성자 : KYJ
	 * @작성일 : 2017. 3. 31. 
	 * @param obj
	 * @param filter
	 * @return
	 * @throws IntrospectionException 
	 */
@SuppressWarnings("rawtypes")
public static Map toMap(Object t, Predicate<String> fieldNameFilter) {
    BeanInfo beanInfo = null;
    try {
        beanInfo = Introspector.getBeanInfo(t.getClass());
    } catch (IntrospectionException e1) {
        throw new RuntimeException(e1);
    }
    Map<String, Object> hashMap = new HashMap<String, Object>();
    // Iterate over all the attributes
    for (PropertyDescriptor descriptor : beanInfo.getPropertyDescriptors()) {
        // write메소드와 read메소드가 존재할때만.
        Method writeMethod = descriptor.getWriteMethod();
        Method readMethod = descriptor.getReadMethod();
        if (ValueUtil.isEmpty(writeMethod) || ValueUtil.isEmpty(readMethod)) {
            continue;
        }
        // Class<?> returnType = readMethod.getReturnType();
        String methodName = ValueUtil.getSimpleMethodName(readMethod.getName());
        if (fieldNameFilter != null) {
            if (fieldNameFilter.test(methodName))
                continue;
        }
        Object originalValue = null;
        try {
            originalValue = readMethod.invoke(t);
        } catch (Exception e) {
        }
        if (ValueUtil.isNotEmpty(originalValue)) {
            hashMap.put(methodName, originalValue);
        } else {
            hashMap.put(methodName, null);
        }
    }
    return hashMap;
}

Example 25 with BeanInfo

use of java.beans.BeanInfo in project JMRI by JMRI.

the class DefaultJavaBeanConfigXML method unpack.

Object unpack(Element e) throws Exception {
    String classname = e.getAttributeValue("beanClass");
    Class<?> cl = Class.forName(classname);
    Constructor<?> ctor = cl.getConstructor(new Class<?>[] {});
    Object o = ctor.newInstance(new Object[] {});
    // reflect through and add parameters
    BeanInfo b = Introspector.getBeanInfo(o.getClass());
    PropertyDescriptor[] properties = b.getPropertyDescriptors();
    // add properties
    List<Element> children = e.getChildren("property");
    for (int i = 0; i < children.size(); i++) {
        // unpack XML
        Element property = children.get(i);
        Element eName = property.getChild("name");
        Element eValue = property.getChild("value");
        String name = eName.getText();
        String value = eValue.getText();
        String type = eName.getAttributeValue("type");
        // find matching method
        for (int j = 0; j < properties.length; j++) {
            if (properties[j].getName().equals(name)) {
                // match, set this one by first finding method
                Method m = properties[j].getWriteMethod();
                // sort by type
                if (type.equals("class java.lang.String")) {
                    m.invoke(o, new Object[] { value });
                } else if (type.equals("int")) {
                    m.invoke(o, new Object[] { Integer.valueOf(value) });
                } else {
                    log.error("Can't handle type: " + type);
                }
                break;
            }
        }
    }
    return o;
}