Document parseDocument(String filename) throws Exception {
FileReader reader = new FileReader(filename);
String firstLine = new BufferedReader(reader).readLine();
reader.close();
Document document = null;
if (firstLine.startsWith("<?xml")) {
System.err.println("XML detected; using default XML parser.");
} else {
try {
Class nekoParserClass = Class.forName("org.cyberneko.html.parsers.DOMParser");
Object parser = nekoParserClass.newInstance();
Method parse = nekoParserClass.getMethod("parse", new Class[] {String.class});
Method getDocument = nekoParserClass.getMethod("getDocument", new Class[0]);
parse.invoke(parser, filename);
document = (Document) getDocument.invoke(parser);
} catch (Exception e) {
System.err.println("NekoHTML HTML parser not found; HTML4 support disabled.");
}
}
if (document == null) {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
try { // http://www.w3.org/blog/systeam/2008/02/08/w3c_s_excessive_dtd_traffic
factory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
} catch (ParserConfigurationException e) {
System.err.println("Warning: Could not disable external DTD loading");
}
DocumentBuilder builder = factory.newDocumentBuilder();
document = builder.parse(filename);
}
return document;
}
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);
}
}
}
private Object createObject(
Node node, String name, String classPackage, String type, String value, boolean setProperty) {
Bean parentBean = null;
if (beansStack.size() > 0) parentBean = (Bean) beansStack.peek();
Object object = null;
// param is either an XSD type or a bean,
// check if it can be converted to an XSD type
XSDatatype dt = null;
try {
dt = DatatypeFactory.getTypeByName(type);
} catch (DatatypeException dte) {
// the type is not a valid XSD data type
}
// convert null value to default
if ((dt != null) && (value == null)) {
Class objType = dt.getJavaObjectType();
if (objType == String.class) value = "";
else if ((objType == java.math.BigInteger.class)
|| (objType == Long.class)
|| (objType == Integer.class)
|| (objType == Short.class)
|| (objType == Byte.class)) value = "0";
else if ((objType == java.math.BigDecimal.class)
|| (objType == Double.class)
|| (objType == Float.class)) value = "0.0";
else if (objType == Boolean.class) value = "false";
else if (objType == java.util.Date.class) value = DateUtils.getCurrentDate();
else if (objType == java.util.Calendar.class) value = DateUtils.getCurrentDateTime();
}
// check whether the type was converted to an XSD datatype
if ((dt != null) && dt.isValid(value, null)) {
// create and return an XSD Java object (e.g. String, Integer, Boolean, etc)
object = dt.createJavaObject(value, null);
if (object instanceof java.util.Calendar) {
// check that the object is truly a Calendar
// because DatatypeFactory converts xsd:date
// types to GregorianCalendar instead of Date.
if (type.equals("date")) {
java.text.DateFormat df = new java.text.SimpleDateFormat("yyyy-MM-dd");
try {
object = df.parse(value);
} catch (java.text.ParseException pe) {
object = new java.util.Date();
}
}
}
} else {
// Create a bean object
if (topLevelBean == null) topLevelBean = parentBean;
object = pushBeanOnStack(classPackage, type);
// Check fields to see if this property is the 'value' for the object
Field[] fields = object.getClass().getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
if (fields[i].isAnnotationPresent(ObjectXmlAsValue.class)) {
try {
StringBuffer fieldName = new StringBuffer(fields[i].getName());
char c = fieldName.charAt(0);
if (c >= 'a' && c <= 'z') {
c += 'A' - 'a';
}
fieldName.setCharAt(0, c);
fieldName.insert(0, "set");
Method method =
object
.getClass()
.getMethod(fieldName.toString(), new Class[] {fields[i].getType()});
method.invoke(object, value);
break;
} catch (Exception e) {
System.err.println(e.getMessage());
}
}
}
NamedNodeMap nodeAttrs = node.getAttributes();
// iterate attributes and set field values for property attributes
for (int i = 0; i < nodeAttrs.getLength(); i++) {
String nodePrefix = nodeAttrs.item(i).getPrefix();
if (nodePrefix.equals(nsPrefix)) {
String nodeName = nodeAttrs.item(i).getLocalName();
String nodeValue = nodeAttrs.item(i).getNodeValue();
try {
Field field = object.getClass().getDeclaredField(nodeName);
if (field.isAnnotationPresent(ObjectXmlAsAttribute.class)) {
StringBuffer fieldName = new StringBuffer(field.getName());
char c = fieldName.charAt(0);
if (c >= 'a' && c <= 'z') {
c += 'A' - 'a';
}
fieldName.setCharAt(0, c);
fieldName.insert(0, "set");
Method method =
object.getClass().getMethod(fieldName.toString(), new Class[] {field.getType()});
if (field.getType() == String.class) method.invoke(object, nodeValue);
else if (field.getType() == Boolean.TYPE)
method.invoke(object, StringUtils.strToBool(nodeValue, "true"));
else if (field.getType() == Byte.TYPE)
method.invoke(object, Byte.valueOf(nodeValue).byteValue());
else if (field.getType() == Character.TYPE)
method.invoke(object, Character.valueOf(nodeValue.charAt(0)));
else if (field.getType() == Double.TYPE)
method.invoke(object, Double.valueOf(nodeValue).doubleValue());
else if (field.getType() == Float.TYPE)
method.invoke(object, Float.valueOf(nodeValue).floatValue());
else if (field.getType() == Integer.TYPE)
method.invoke(object, Integer.valueOf(nodeValue).intValue());
else if (field.getType() == Long.TYPE)
method.invoke(object, Long.valueOf(nodeValue).longValue());
else if (field.getType() == Short.TYPE)
method.invoke(object, Short.valueOf(nodeValue).shortValue());
}
} catch (Exception e) {
System.err.println(e.getMessage());
}
}
}
}
if ((parentBean != null) && (setProperty)) {
parentBean.setProperty(name, object);
}
return object;
}
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) {
}
}
}
}
}
}
/**
* Reads XML element(s) into an indexed bean property by first locating the XML element(s)
* 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 readIndexedProperty(
Object ob, IndexedPropertyDescriptor desc, NodeList nodes, NamedNodeMap attrs)
throws IOException {
// Create a vector to hold the property values
Vector v = new Vector();
int numAttrs = attrs.getLength();
for (int i = 0; i < numAttrs; i++) {
// See if this attribute matches the property name
if (namesMatch(desc.getName(), attrs.item(i).getNodeName())) {
// Get the property value
Object obValue = getObjectValue(desc, attrs.item(i).getNodeValue());
if (obValue != null) {
// Add the value to the list of values to be set
v.addElement(obValue);
}
}
}
int numNodes = nodes.getLength();
for (int i = 0; i < numNodes; i++) {
Node node = nodes.item(i);
// Skip non-element nodes
if (!(node instanceof Element)) continue;
Element element = (Element) node;
// See if this element tag matches the property name
if (namesMatch(desc.getName(), element.getTagName())) {
// Get the property value
Object obValue = getObjectValue(desc, element);
if (obValue != null) {
// Add the value to the list of values to be set
v.addElement(obValue);
}
}
}
// Get the method used to set the property value
Method setter = desc.getWriteMethod();
// If this property has no setter, don't write it
if (setter == null) return;
// Create a new array of property values
Object propArray = Array.newInstance(desc.getPropertyType().getComponentType(), v.size());
// Copy the vector into the array
v.copyInto((Object[]) propArray);
try {
// Store the array of property values
setter.invoke(ob, new Object[] {propArray});
} 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());
}
}
/**
* 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;
}
}