/** * Examines a property's type to see which method should be used to parse the property's value. * * @param desc The description of the property * @param element The XML element containing the property value * @return The value stored in the element * @throws IOException If there is an error reading the document */ public Object getObjectValue(PropertyDescriptor desc, Element element) throws IOException { // Find out what kind of property it is Class type = desc.getPropertyType(); // If it's an array, get the base type if (type.isArray()) { type = type.getComponentType(); } // For native types, object wrappers for natives, and strings, use the // basic parse routine if (type.equals(Integer.TYPE) || type.equals(Long.TYPE) || type.equals(Short.TYPE) || type.equals(Byte.TYPE) || type.equals(Boolean.TYPE) || type.equals(Float.TYPE) || type.equals(Double.TYPE) || Integer.class.isAssignableFrom(type) || Long.class.isAssignableFrom(type) || Short.class.isAssignableFrom(type) || Byte.class.isAssignableFrom(type) || Boolean.class.isAssignableFrom(type) || Float.class.isAssignableFrom(type) || Double.class.isAssignableFrom(type) || String.class.isAssignableFrom(type)) { return readBasicType(type, element); } else if (java.util.Date.class.isAssignableFrom(type)) { // If it's a date, use the date parser return readDate(element); } else { try { // If it's an object, create a new instance of the object (it should // be a bean, or there will be trouble) Object newOb = type.newInstance(); // Copy the XML element into the bean readObject(newOb, element); return newOb; } catch (InstantiationException exc) { throw new IOException( "Error creating object for " + desc.getName() + ": " + exc.toString()); } catch (IllegalAccessException exc) { throw new IOException( "Error creating object for " + desc.getName() + ": " + exc.toString()); } } }
/** * Examines a property's type to see which method should be used to parse the property's value. * * @param desc The description of the property * @param value The value of the XML attribute containing the prop value * @return The value stored in the element * @throws IOException If there is an error reading the document */ public Object getObjectValue(PropertyDescriptor desc, String value) throws IOException { // Find out what kind of property it is Class type = desc.getPropertyType(); // If it's an array, get the base type if (type.isArray()) { type = type.getComponentType(); } // For native types, object wrappers for natives, and strings, use the // basic parse routine if (type.equals(Integer.TYPE) || type.equals(Long.TYPE) || type.equals(Short.TYPE) || type.equals(Byte.TYPE) || type.equals(Boolean.TYPE) || type.equals(Float.TYPE) || type.equals(Double.TYPE) || Integer.class.isAssignableFrom(type) || Long.class.isAssignableFrom(type) || Short.class.isAssignableFrom(type) || Byte.class.isAssignableFrom(type) || Boolean.class.isAssignableFrom(type) || Float.class.isAssignableFrom(type) || Double.class.isAssignableFrom(type)) { return parseBasicType(type, value); } else if (String.class.isAssignableFrom(type)) { return value; } else if (java.util.Date.class.isAssignableFrom(type)) { // If it's a date, use the date parser return parseDate(value, JOXDateHandler.determineDateFormat()); } else { return null; } }
public void setProperty(String name, Object object) { PropertyDescriptor pd = getPropertyDescriptor(name); if (pd != null) { Object[] args = {object}; Object propertyValue = null; try { Method setter = pd.getWriteMethod(); if (setter != null) { propertyValue = setter.invoke(beanObject, args); } } catch (Exception e) { System.err.println("Exception setting bean property: " + e.getMessage()); System.err.println("Property name: " + name); System.err.println("Property value: " + propertyValue); } } }
protected void getBeanElementProperties(Element element, Object bean, PropertyDescriptor pd) throws IntrospectionException, IllegalAccessException { Element propertyElement = null; Class classOfProperty = pd.getPropertyType(); Object[] argsNone = {}; // If the property is "class" and the type is java.lang.Class.class then // this is the class of the bean, which we've already encoded. // In this special case, return null. if (!((pd.getName().charAt(0) == 'c') && pd.getName().equals("class")) && !classOfProperty.equals(java.lang.Class.class)) { // Don't process property if it is in the list of fields to be ignored boolean omittedField = false; try { Field field = bean.getClass().getDeclaredField(pd.getName()); omittedField = field.isAnnotationPresent(ObjectXmlOmitField.class); } catch (NoSuchFieldException nsfe) { } if (!omittedField) { String propertyName = formatName(pd.getName()); // Hereafter, we're trying to create a representation of the property // based on the property's value. // The very first thing we need to do is get the value of the // property as an object. If we can't do that, we can't get any // representation of the property at all. Object propertyValue = null; try { Method getter = pd.getReadMethod(); if (getter != null) { propertyValue = getter.invoke(bean, argsNone); } } catch (Exception ex) { // couldn't get value System.err.println(ex.getMessage()); } // See if this property's value is something we can represent as a // standard data type that can be converted to an xsd type, // or if it's something that must be represented as a JavaBean. if (propertyElement == null) { PropertyEditor propEditor = PropertyEditorManager.findEditor(classOfProperty); // If the property editor is not null, pass the property's // value to the PropertyEditor, and then ask the PropertyEditor // for the object and then attempt to convert it to a standard type. if ((propEditor != null) || (classOfProperty == java.util.Calendar.class) || (classOfProperty == java.util.Date.class)) { // The object is a standard type // (e.g. a wrapper around a primitive type, a String, or a Date or Calendar object) try { Object object; if ((classOfProperty == java.util.Calendar.class) || (classOfProperty == java.util.Date.class)) object = propertyValue; else { propEditor.setValue(propertyValue); object = propEditor.getValue(); } Element childElement = getStandardObjectElement(document, object, propertyName); if (includeNullValues || !childElement .getAttribute( NamespaceConstants.NSPREFIX_SCHEMA_XSI + ":" + org.apache.axis.Constants.ATTR_TYPE) .equals("anyType")) { if (!includeTypeInfo) { childElement.removeAttribute( NamespaceConstants.NSPREFIX_SCHEMA_XSI + ":" + org.apache.axis.Constants.ATTR_TYPE); childElement.removeAttribute(NamespaceConstants.NSPREFIX_SCHEMA_XSI + ":null"); } try { Field field = bean.getClass().getDeclaredField(propertyName); if (field.isAnnotationPresent(ObjectXmlAsAttribute.class)) { String attrName = null; if (includeTypeInfo) attrName = nsPrefix + ":" + propertyName; else attrName = propertyName; element.setAttribute(attrName, childElement.getFirstChild().getNodeValue()); } else if (field.isAnnotationPresent(ObjectXmlAsValue.class)) element.setTextContent(childElement.getFirstChild().getNodeValue()); else element.appendChild(childElement); } catch (NoSuchFieldException nfse) { element.appendChild(childElement); } } } catch (Exception e) { } } else { // The object is not an XSD-encoded datatype, it must be a JavaBean try { String propertyTypeName = null; if (propertyValue != null) { // get object type Class propertyType = pd.getPropertyType(); propertyTypeName = propertyType.getName(); } getBeanElements(element, propertyName, propertyTypeName, propertyValue); } catch (Exception e) { } } } } } }
public Class getPropertyType(String name) { PropertyDescriptor pd = getPropertyDescriptor(name); return pd.getPropertyType(); }
/** * Reads an XML element into a bean property by first locating the XML element corresponding to * this property. * * @param ob The bean whose property is being set * @param desc The property that will be set * @param nodes The list of XML items that may contain the property * @throws IOException If there is an error reading the document */ public void readProperty(Object ob, PropertyDescriptor desc, NodeList nodes, NamedNodeMap attrs) throws IOException { int numAttrs = attrs.getLength(); for (int i = 0; i < numAttrs; i++) { // See if the attribute name matches the property name if (namesMatch(desc.getName(), attrs.item(i).getNodeName())) { // Get the method used to set this property Method setter = desc.getWriteMethod(); // If this object has no setter, don't bother writing it if (setter == null) continue; // Get the value of the property Object obValue = getObjectValue(desc, attrs.item(i).getNodeValue()); if (obValue != null) { try { // Set the property value setter.invoke(ob, new Object[] {obValue}); } catch (InvocationTargetException exc) { throw new IOException( "Error setting property " + desc.getName() + ": " + exc.toString()); } catch (IllegalAccessException exc) { throw new IOException( "Error setting property " + desc.getName() + ": " + exc.toString()); } } return; } } int numNodes = nodes.getLength(); Vector arrayBuild = null; for (int i = 0; i < numNodes; i++) { Node node = nodes.item(i); // If this node isn't an element, skip it if (!(node instanceof Element)) continue; Element element = (Element) node; // See if the tag name matches the property name if (namesMatch(desc.getName(), element.getTagName())) { // Get the method used to set this property Method setter = desc.getWriteMethod(); // If this object has no setter, don't bother writing it if (setter == null) continue; // Get the value of the property Object obValue = getObjectValue(desc, element); // 070201 MAW: Modified from change submitted by Steve Poulson if (setter.getParameterTypes()[0].isArray()) { if (arrayBuild == null) { arrayBuild = new Vector(); } arrayBuild.addElement(obValue); // 070201 MAW: Go ahead and read through the rest of the nodes in case // another one matches the array. This has the effect of skipping // over the "return" statement down below continue; } if (obValue != null) { try { // Set the property value setter.invoke(ob, new Object[] {obValue}); } catch (InvocationTargetException exc) { throw new IOException( "Error setting property " + desc.getName() + ": " + exc.toString()); } catch (IllegalAccessException exc) { throw new IOException( "Error setting property " + desc.getName() + ": " + exc.toString()); } } return; } } // If we build a vector of array members, convert the vector into // an array and save it in the property if (arrayBuild != null) { // Get the method used to set this property Method setter = desc.getWriteMethod(); if (setter == null) return; Object[] obValues = (Object[]) Array.newInstance(desc.getPropertyType(), arrayBuild.size()); arrayBuild.copyInto(obValues); try { setter.invoke(ob, new Object[] {obValues}); } catch (InvocationTargetException exc) { throw new IOException("Error setting property " + desc.getName() + ": " + exc.toString()); } catch (IllegalAccessException exc) { throw new IOException("Error setting property " + desc.getName() + ": " + exc.toString()); } return; } }