| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.axis2.rmi.databind; |
| |
| import org.apache.axis2.rmi.Configurator; |
| import org.apache.axis2.rmi.exception.MetaDataPopulateException; |
| import org.apache.axis2.rmi.exception.SchemaGenerationException; |
| import org.apache.axis2.rmi.exception.XmlSerializingException; |
| import org.apache.axis2.rmi.metadata.AttributeField; |
| import org.apache.axis2.rmi.metadata.ElementField; |
| import org.apache.axis2.rmi.metadata.Parameter; |
| import org.apache.axis2.rmi.metadata.Type; |
| import org.apache.axis2.rmi.metadata.impl.TypeImpl; |
| import org.apache.axis2.rmi.metadata.xml.XmlElement; |
| import org.apache.axis2.rmi.types.MapType; |
| import org.apache.axis2.rmi.util.Constants; |
| import org.apache.axis2.rmi.util.NamespacePrefix; |
| |
| import javax.xml.namespace.QName; |
| import javax.xml.stream.XMLStreamException; |
| import javax.xml.stream.XMLStreamWriter; |
| import java.lang.reflect.Array; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * this class serializes a given java object with its corresponding |
| * type object |
| */ |
| public class JavaObjectSerializer { |
| |
| private Map processedTypeMap; |
| private Configurator configurator; |
| private Map schemaMap; |
| private SimpleTypeHandler simpleTypeHandler; |
| private Class simpleTypeHandlerClass; |
| |
| public JavaObjectSerializer(Map processedTypeMap, |
| Configurator configurator, |
| Map schemaMap) { |
| this.processedTypeMap = processedTypeMap; |
| this.configurator = configurator; |
| this.schemaMap = schemaMap; |
| this.simpleTypeHandler = this.configurator.getSimpleTypeHandler(); |
| this.simpleTypeHandlerClass = this.simpleTypeHandler.getClass(); |
| } |
| |
| /** |
| * serialize all the input parameters |
| * @param objects |
| * @param inputXmlElement |
| * @param inputParameters |
| * @param writer |
| * @throws XMLStreamException |
| * @throws XmlSerializingException |
| */ |
| |
| public void serializeInputElement(Object[] objects, |
| XmlElement inputXmlElement, |
| List inputParameters, |
| XMLStreamWriter writer) throws XMLStreamException, |
| XmlSerializingException { |
| NamespacePrefix namespacePrefix = new NamespacePrefix(); |
| writeStartElement(writer, |
| inputXmlElement.getNamespace(), |
| inputXmlElement.getName(), |
| namespacePrefix); |
| // input objects null means no parameters |
| if (objects != null) { |
| for (int i = 0; i < objects.length; i++) { |
| serializeParameter(objects[i], |
| (Parameter) inputParameters.get(i), |
| writer, |
| namespacePrefix); |
| } |
| } |
| |
| writer.writeEndElement(); |
| } |
| |
| /** |
| * serialize the out put parameter |
| * @param object |
| * @param outputXmlElement |
| * @param outputParameter |
| * @param writer |
| * @throws XMLStreamException |
| * @throws XmlSerializingException |
| */ |
| |
| public void serializeOutputElement(Object object, |
| XmlElement outputXmlElement, |
| Parameter outputParameter, |
| XMLStreamWriter writer) |
| throws XMLStreamException, XmlSerializingException { |
| NamespacePrefix namespacePrefix = new NamespacePrefix(); |
| //write output start element |
| writeStartElement(writer, |
| outputXmlElement.getNamespace(), |
| outputXmlElement.getName(), |
| namespacePrefix); |
| if (outputParameter != null) { |
| // null means this is the void type |
| serializeParameter(object, outputParameter, writer, namespacePrefix); |
| } |
| writer.writeEndElement(); |
| } |
| |
| /** |
| * serailize the parameter object. parameter represents an xml element. |
| * so it basically calls to the serialize element method. |
| * @param parameterValue |
| * @param parameter |
| * @param writer |
| * @param namespacePrefix |
| * @throws XMLStreamException |
| * @throws XmlSerializingException |
| */ |
| public void serializeParameter(Object parameterValue, |
| Parameter parameter, |
| XMLStreamWriter writer, |
| NamespacePrefix namespacePrefix) |
| throws XMLStreamException, |
| XmlSerializingException { |
| QName parameterQName = new QName(parameter.getNamespace(), parameter.getName()); |
| serializeElement(parameterValue, |
| parameterQName, |
| parameter.getType(), |
| writer, |
| namespacePrefix, |
| parameter.isArray(), |
| parameter.getClassType()); |
| } |
| |
| /** |
| * serailizes an element. elements can either be parameter or an attribute. |
| * @param elementValue |
| * @param elementQName |
| * @param elementType |
| * @param writer |
| * @param namespacePrefix |
| * @param isArray |
| * @param classType |
| * @throws XmlSerializingException |
| * @throws XMLStreamException |
| */ |
| |
| private void serializeElement(Object elementValue, |
| QName elementQName, |
| Type elementType, |
| XMLStreamWriter writer, |
| NamespacePrefix namespacePrefix, |
| boolean isArray, |
| int classType) |
| throws XmlSerializingException, XMLStreamException { |
| if ((elementValue == null) || !isArray) { |
| // then we can serializeInputElement it directly either it is array or not |
| serialize(elementValue, |
| elementQName, |
| elementType, |
| writer, |
| namespacePrefix); |
| } else { |
| |
| if ((classType & Constants.MAP_TYPE) == Constants.MAP_TYPE) { |
| Map elementMap = (Map) elementValue; |
| Object key = null; |
| for (Iterator iter = elementMap.keySet().iterator(); iter.hasNext();) { |
| key = iter.next(); |
| serialize(new MapType(key, elementMap.get(key)), |
| elementQName, |
| elementType, |
| writer, |
| namespacePrefix); |
| } |
| } else if ((classType & Constants.COLLECTION_TYPE) == Constants.COLLECTION_TYPE) { |
| // if this is a List we convert this to an Object array |
| Collection elementCollection = (Collection) elementValue; |
| for (Iterator iter = elementCollection.iterator(); iter.hasNext();) { |
| serialize(iter.next(), |
| elementQName, |
| elementType, |
| writer, |
| namespacePrefix); |
| } |
| } else { |
| int length = Array.getLength(elementValue); |
| Object object; |
| for (int i = 0; i < length; i++) { |
| object = Array.get(elementValue, i); |
| serialize(object, |
| elementQName, |
| elementType, |
| writer, |
| namespacePrefix); |
| } |
| } |
| |
| } |
| } |
| |
| /** |
| * this method serailizes the given object according to the type information |
| * given. |
| * |
| * @param object |
| * @param type |
| * @param writer |
| */ |
| |
| public void serialize(Object object, |
| QName parentQName, |
| Type type, |
| XMLStreamWriter writer, |
| NamespacePrefix namespacePrefix) |
| throws XMLStreamException, |
| XmlSerializingException { |
| |
| if (object instanceof RMIBean) { |
| RMIBean rmiBean = (RMIBean) object; |
| rmiBean.serialize(writer, this, parentQName, namespacePrefix); |
| } else { |
| // first write the start element |
| writeStartElement(writer, |
| parentQName.getNamespaceURI(), |
| parentQName.getLocalPart(), |
| namespacePrefix); |
| if (object == null) { |
| writeNullAttribute(writer, namespacePrefix); |
| } else { |
| // handle extensions here. |
| // primitive can not have excented types |
| if (!object.getClass().equals(type.getJavaClass()) && !type.getJavaClass().isPrimitive()) { |
| // i.e this is an extension |
| if (!processedTypeMap.containsKey(object.getClass())) { |
| Type newType = new TypeImpl(object.getClass()); |
| processedTypeMap.put(object.getClass(), newType); |
| try { |
| newType.populateMetaData(this.configurator, this.processedTypeMap); |
| newType.generateSchema(this.configurator, this.schemaMap); |
| } catch (MetaDataPopulateException e) { |
| new XmlSerializingException("Problem in processing new type", e); |
| } catch (SchemaGenerationException e) { |
| new XmlSerializingException("Problem in processing new type", e); |
| } |
| } |
| type = (Type) processedTypeMap.get(object.getClass()); |
| writeTypeAttribute(writer, type.getXmlType().getQname(), namespacePrefix); |
| } |
| |
| if (type.getXmlType().isSimpleType()) { |
| // this is a know type for us |
| // get the string represenation of this object using converter util class. |
| if (!type.getJavaClass().equals(Object.class)) { |
| writer.writeCharacters(getSimpleTypeStringValue(type, object)); |
| } |
| |
| } else { |
| // this is a complex type |
| try { |
| |
| AttributeField attributeField; |
| Method getterMethod; |
| Object attributeFieldValue; |
| QName attributeQName; |
| for (Iterator iter = type.getAllAttributeFields().iterator(); iter.hasNext();) { |
| attributeField = (AttributeField) iter.next(); |
| getterMethod = attributeField.getGetterMethod(); |
| attributeFieldValue = getterMethod.invoke(object, new Object[]{}); |
| attributeQName = new QName(attributeField.getNamespace(), attributeField.getName()); |
| // calls to write attribute. for attributes we can have only simple types |
| if (attributeFieldValue != null) { |
| writeAttribute(writer, |
| getSimpleTypeStringValue(attributeField.getType(), attributeFieldValue), |
| attributeQName, |
| namespacePrefix); |
| } else if (attributeField.isRequried()) { |
| throw new XmlSerializingException("Attribute value for attribute " |
| + attributeField.getName() + " is required"); |
| } |
| |
| } |
| |
| // write the element fields |
| ElementField elementField; |
| Object elementFieldValue; |
| for (Iterator iter = type.getAllElementFields().iterator(); iter.hasNext();) { |
| elementField = (ElementField) iter.next(); |
| getterMethod = elementField.getGetterMethod(); |
| elementFieldValue = getterMethod.invoke(object, new Object[]{}); |
| serializeElementField(elementFieldValue, |
| elementField, |
| writer, |
| namespacePrefix); |
| |
| } |
| } catch (IllegalAccessException e) { |
| throw new XmlSerializingException("problem with method inovocation " + type.getName()); |
| } catch (InvocationTargetException e) { |
| throw new XmlSerializingException("problem with method inovocation " + type.getName()); |
| } |
| |
| } |
| } |
| writer.writeEndElement(); |
| } |
| } |
| |
| private String getSimpleTypeStringValue(Type type, Object object) throws XmlSerializingException { |
| try { |
| Method methodToInvoke = this.simpleTypeHandlerClass.getMethod("convertToString", new Class[]{type.getJavaClass()}); |
| // these methods are static so use null as the object argument |
| return (String) methodToInvoke.invoke(this.simpleTypeHandler, new Object[]{object}); |
| } catch (NoSuchMethodException e) { |
| throw new XmlSerializingException("Can not invoke converter util method convertToString for class " |
| + type.getJavaClass().getName(), e); |
| } catch (IllegalAccessException e) { |
| throw new XmlSerializingException("Can not invoke converter util method convertToString for class " |
| + type.getJavaClass().getName(), e); |
| } catch (InvocationTargetException e) { |
| throw new XmlSerializingException("Can not invoke converter util method convertToString for class " |
| + type.getJavaClass().getName(), e); |
| } |
| } |
| |
| /** |
| * this method serializes the attributes by calling to serialize element method. |
| * |
| * @param elementFieldValue |
| * @param elementField |
| * @param writer |
| * @param namespacePrefix |
| */ |
| private void serializeElementField(Object elementFieldValue, |
| ElementField elementField, |
| XMLStreamWriter writer, |
| NamespacePrefix namespacePrefix) |
| throws XmlSerializingException, XMLStreamException { |
| |
| QName elementFieldQName = new QName(elementField.getElement().getNamespace(), |
| elementField.getElement().getName()); |
| serializeElement(elementFieldValue, |
| elementFieldQName, |
| elementField.getType(), |
| writer, |
| namespacePrefix, |
| elementField.isArray(), |
| elementField.getClassType()); |
| |
| } |
| |
| private void writeStartElement(XMLStreamWriter writer, |
| String namespace, |
| String localPart, |
| NamespacePrefix namespacePrefix) |
| throws XMLStreamException { |
| if (!namespace.equals("")) { |
| String prefix = writer.getPrefix(namespace); |
| if (prefix == null) { |
| prefix = "ns" + namespacePrefix.getNamesapcePrefix(); |
| writer.writeStartElement(prefix, localPart, namespace); |
| writer.writeNamespace(prefix, namespace); |
| writer.setPrefix(prefix, namespace); |
| } else { |
| writer.writeStartElement(namespace, localPart); |
| } |
| } else { |
| writer.writeStartElement(localPart); |
| } |
| |
| } |
| |
| private void writeTypeAttribute(XMLStreamWriter writer, |
| QName typeQname, |
| NamespacePrefix namespacePrefix) |
| throws XMLStreamException { |
| String xsiPrefix = writer.getPrefix(Constants.URI_DEFAULT_SCHEMA_XSI); |
| if (xsiPrefix == null) { |
| xsiPrefix = "ns" + namespacePrefix.getNamesapcePrefix(); |
| writer.writeNamespace(xsiPrefix, Constants.URI_DEFAULT_SCHEMA_XSI); |
| writer.setPrefix(xsiPrefix, Constants.URI_DEFAULT_SCHEMA_XSI); |
| } |
| |
| String typePrefix = writer.getPrefix(typeQname.getNamespaceURI()); |
| if (typePrefix == null) { |
| typePrefix = "ns" + namespacePrefix.getNamesapcePrefix(); |
| writer.writeNamespace(typePrefix, typeQname.getNamespaceURI()); |
| writer.setPrefix(typePrefix, typeQname.getNamespaceURI()); |
| } |
| |
| String attributeValue = typeQname.getLocalPart(); |
| if (!typePrefix.equals("")) { |
| attributeValue = typePrefix + ":" + attributeValue; |
| } |
| writer.writeAttribute(Constants.URI_DEFAULT_SCHEMA_XSI, "type", attributeValue); |
| } |
| |
| private void writeNullAttribute(XMLStreamWriter writer, |
| NamespacePrefix namespacePrefix) |
| throws XMLStreamException { |
| QName attributeQName = new QName(Constants.URI_DEFAULT_SCHEMA_XSI,"nil"); |
| writeAttribute(writer,"1",attributeQName,namespacePrefix); |
| } |
| |
| /** |
| * this method wrtes the simple attribute to the writer. |
| * @param writer |
| * @param attributeValue |
| * @param attributeQName |
| * @param namespacePrefix |
| * @throws XMLStreamException |
| */ |
| private void writeAttribute(XMLStreamWriter writer, |
| String attributeValue, |
| QName attributeQName, |
| NamespacePrefix namespacePrefix) throws XMLStreamException { |
| if ((attributeQName.getNamespaceURI() != null) && !attributeQName.getNamespaceURI().trim().equals("")){ |
| String prefix = writer.getPrefix(attributeQName.getNamespaceURI()); |
| if (prefix == null){ |
| prefix = "ns" + namespacePrefix.getNamesapcePrefix(); |
| writer.writeNamespace(prefix, attributeQName.getNamespaceURI()); |
| writer.setPrefix(prefix, attributeQName.getNamespaceURI()); |
| } |
| writer.writeAttribute(attributeQName.getNamespaceURI(), |
| attributeQName.getLocalPart(), |
| attributeValue); |
| |
| } else { |
| writer.writeAttribute(attributeQName.getLocalPart(),attributeValue); |
| } |
| |
| } |
| } |
