diff options
Diffstat (limited to 'sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src')
14 files changed, 1708 insertions, 0 deletions
diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/AxiomHelper.java b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/AxiomHelper.java new file mode 100644 index 0000000000..93277e77bf --- /dev/null +++ b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/AxiomHelper.java @@ -0,0 +1,140 @@ +/* + * 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.tuscany.sca.databinding.jaxb.axiom; + +import javax.xml.namespace.QName; + +import org.apache.axiom.om.OMAbstractFactory; +import org.apache.axiom.om.OMDataSource; +import org.apache.axiom.om.OMElement; +import org.apache.axiom.om.OMFactory; +import org.apache.axiom.om.OMNamespace; +import org.apache.axiom.om.OMXMLParserWrapper; +import org.apache.axiom.om.impl.builder.StAXBuilder; +import org.apache.tuscany.sca.databinding.TransformationContext; +import org.apache.tuscany.sca.interfacedef.DataType; +import org.apache.tuscany.sca.interfacedef.util.XMLType; + +/** + * Helper for AXIOM + * + * @version $Rev$ $Date$ + */ +public class AxiomHelper { + private static final String DEFAULT_PREFIX = "_ns_"; + + private AxiomHelper() { + } + + /** + * See http://issues.apache.org/jira/browse/WSCOMMONS-240 + * @param om + */ + public static void completeAndClose(OMElement om) { + // Get the builder associated with the om element + OMXMLParserWrapper builder = om.getBuilder(); + if (builder != null) { + if (builder instanceof StAXBuilder) { + ((StAXBuilder)builder).releaseParserOnClose(true); + } + OMElement document = builder.getDocumentElement(); + if (document != null) { + document.build(); + } + } + if (builder instanceof StAXBuilder) { + ((StAXBuilder)builder).close(); + } + } + + /** + * This method will close the builder immediately. Any subsequent Axiom objects won't + * be built or accessible. + */ + public static void closeImmediately(OMElement om) { + // Get the builder associated with the om element + OMXMLParserWrapper builder = om.getBuilder(); + if (builder != null) { + if (builder instanceof StAXBuilder) { + ((StAXBuilder)builder).releaseParserOnClose(true); + ((StAXBuilder)builder).close(); + } + // builder.close(); + } + } + + /** + * @param context + * @param element + */ + public static void adjustElementName(TransformationContext context, OMElement element) { + if (context != null) { + DataType<?> dataType = context.getTargetDataType(); + Object logical = dataType == null ? null : dataType.getLogical(); + if (!(logical instanceof XMLType)) { + return; + } + XMLType xmlType = (XMLType)logical; + if (xmlType.isElement() && !xmlType.getElementName().equals(element.getQName())) { + // FIXME:: Throw exception or switch to the new Element? + OMFactory factory = OMAbstractFactory.getOMFactory(); + QName name = xmlType.getElementName(); + OMNamespace namespace = factory.createOMNamespace(name.getNamespaceURI(), name.getPrefix()); + element.setNamespace(namespace); + element.setLocalName(name.getLocalPart()); + } + } + } + + public static OMElement createOMElement(OMFactory factory, QName element) { + String localName = element.getLocalPart(); + OMNamespace ns = createOMNamespace(factory, element); + + return factory.createOMElement(localName, ns); + + } + + public static OMElement createOMElement(OMFactory factory, QName element, OMDataSource dataSource) { + String localName = element.getLocalPart(); + OMNamespace ns = createOMNamespace(factory, element); + + return factory.createOMElement(dataSource, localName, ns); + + } + + /** + * @param factory + * @param name + * @return + */ + public static OMNamespace createOMNamespace(OMFactory factory, QName name) { + String namespaceURI = name.getNamespaceURI(); + String prefix = name.getPrefix(); + + OMNamespace ns = null; + // Qualified Element: we need an OMNamespace + if (prefix.length() == 0) { + // The prefix does not appear to be specified, let's create one + prefix = DEFAULT_PREFIX; + } + ns = factory.createOMNamespace(namespaceURI, prefix); + return ns; + } +} diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/JAXB2OMElement.java b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/JAXB2OMElement.java new file mode 100644 index 0000000000..c90a1c6d5a --- /dev/null +++ b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/JAXB2OMElement.java @@ -0,0 +1,84 @@ +/* + * 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.tuscany.sca.databinding.jaxb.axiom; + +import javax.xml.bind.JAXBContext; +import javax.xml.bind.JAXBException; +import javax.xml.namespace.QName; + +import org.apache.axiom.om.OMAbstractFactory; +import org.apache.axiom.om.OMElement; +import org.apache.axiom.om.OMFactory; +import org.apache.tuscany.sca.core.ExtensionPointRegistry; +import org.apache.tuscany.sca.databinding.BaseTransformer; +import org.apache.tuscany.sca.databinding.PullTransformer; +import org.apache.tuscany.sca.databinding.TransformationContext; +import org.apache.tuscany.sca.databinding.TransformationException; +import org.apache.tuscany.sca.databinding.jaxb.JAXBContextHelper; +import org.apache.tuscany.sca.databinding.jaxb.JAXBDataBinding; + +/** + * JAXB Object --> AXIOM OMElement transformer + * + * @version $Rev$ $Date$ + */ +public class JAXB2OMElement extends BaseTransformer<Object, OMElement> implements PullTransformer<Object, OMElement> { + private OMFactory factory = OMAbstractFactory.getOMFactory(); + private JAXBContextHelper contextHelper; + + public JAXB2OMElement(ExtensionPointRegistry registry) { + super(); + contextHelper = JAXBContextHelper.getInstance(registry); + } + + @Override + public String getSourceDataBinding() { + return JAXBDataBinding.NAME; + } + + public OMElement transform(Object source, TransformationContext context) throws TransformationException { + JAXBContext jaxbContext; + try { + jaxbContext = contextHelper.createJAXBContext(context, true); + } catch (JAXBException e) { + throw new TransformationException(e); + } + Object element = JAXBContextHelper.createJAXBElement(jaxbContext, context.getTargetDataType(), source); + QName name = jaxbContext.createJAXBIntrospector().getElementName(element); + JAXBDataSource dataSource = new JAXBDataSource(element, jaxbContext, contextHelper); + OMElement omElement = AxiomHelper.createOMElement(factory, name, dataSource); + return omElement; + } + + @Override + public Class<Object> getSourceType() { + return Object.class; + } + + @Override + public Class<OMElement> getTargetType() { + return OMElement.class; + } + + @Override + public int getWeight() { + return 3000; + } + +} diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/JAXBDataSource.java b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/JAXBDataSource.java new file mode 100644 index 0000000000..0dacce996f --- /dev/null +++ b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/JAXBDataSource.java @@ -0,0 +1,128 @@ +/* + * 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.tuscany.sca.databinding.jaxb.axiom; + +import java.io.OutputStream; +import java.io.StringReader; +import java.io.StringWriter; +import java.io.Writer; +import java.security.AccessController; +import java.security.PrivilegedActionException; +import java.security.PrivilegedExceptionAction; + +import javax.xml.bind.JAXBContext; +import javax.xml.bind.Marshaller; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import javax.xml.stream.XMLStreamWriter; + +import org.apache.axiom.om.OMDataSource; +import org.apache.axiom.om.OMOutputFormat; +import org.apache.axiom.om.util.StAXUtils; +import org.apache.tuscany.sca.databinding.jaxb.JAXBContextHelper; + +/** + * + * @version $Rev$ $Date$ + */ +public class JAXBDataSource implements OMDataSource { + private JAXBContext context; + private Object element; + private JAXBContextHelper contextHelper; + + public JAXBDataSource(Object element, JAXBContext context, JAXBContextHelper contextHelper) { + this.element = element; + this.context = context; + this.contextHelper = contextHelper; + } + + public XMLStreamReader getReader() throws XMLStreamException { + // FIXME: [rfeng] This is a quick and dirty implementation + // We could use the fastinfoset to optimize the roundtrip + StringWriter writer = new StringWriter(); + serialize(writer, new OMOutputFormat()); + StringReader reader = new StringReader(writer.toString()); + // FIXME: We need to use Tuscany extension point to create the reader + return StAXUtils.createXMLStreamReader(reader); + } + + public void serialize(final XMLStreamWriter xmlWriter) throws XMLStreamException { + try { + // marshaller.setProperty(Marshaller.JAXB_ENCODING, format.getCharSetEncoding()); + AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() { + public Object run() throws Exception { + Marshaller marshaller = null; + try { + marshaller = contextHelper.getMarshaller(context); + marshaller.marshal(element, xmlWriter); + } finally { + contextHelper.releaseJAXBMarshaller(context, marshaller); + } + return null; + } + }); + } catch (PrivilegedActionException e) { + throw new XMLStreamException(e.getException()); + } + } + + public void serialize(final OutputStream output, OMOutputFormat format) throws XMLStreamException { + try { + // marshaller.setProperty(Marshaller.JAXB_ENCODING, format.getCharSetEncoding()); + AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() { + public Object run() throws Exception { + Marshaller marshaller = null; + try { + marshaller = contextHelper.getMarshaller(context); + marshaller.marshal(element, output); + } finally { + contextHelper.releaseJAXBMarshaller(context, marshaller); + } + return null; + } + }); + } catch (PrivilegedActionException e) { + throw new XMLStreamException(e.getException()); + } + } + + public void serialize(final Writer writer, OMOutputFormat format) throws XMLStreamException { + try { + AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() { + public Object run() throws Exception { + Marshaller marshaller = null; + try { + marshaller = contextHelper.getMarshaller(context); + marshaller.marshal(element, writer); + } finally { + contextHelper.releaseJAXBMarshaller(context, marshaller); + } + return null; + } + }); + } catch (PrivilegedActionException e) { + throw new XMLStreamException(e.getException()); + } + } + + public Object getObject() { + return element; + } + +} diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/OMElement2JAXB.java b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/OMElement2JAXB.java new file mode 100644 index 0000000000..f7de7f4425 --- /dev/null +++ b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/OMElement2JAXB.java @@ -0,0 +1,106 @@ +/* + * 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.tuscany.sca.databinding.jaxb.axiom; + +import java.security.AccessController; +import java.security.PrivilegedActionException; +import java.security.PrivilegedExceptionAction; + +import javax.xml.bind.JAXBContext; +import javax.xml.bind.JAXBException; +import javax.xml.bind.Unmarshaller; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import javax.xml.stream.util.StreamReaderDelegate; + +import org.apache.axiom.om.OMElement; +import org.apache.tuscany.sca.core.ExtensionPointRegistry; +import org.apache.tuscany.sca.databinding.BaseTransformer; +import org.apache.tuscany.sca.databinding.PullTransformer; +import org.apache.tuscany.sca.databinding.TransformationContext; +import org.apache.tuscany.sca.databinding.TransformationException; +import org.apache.tuscany.sca.databinding.jaxb.JAXBContextHelper; + +/** + * @version $Rev$ $Date$ + */ +public class OMElement2JAXB extends BaseTransformer<OMElement, Object> implements PullTransformer<OMElement, Object> { + private JAXBContextHelper contextHelper; + + public OMElement2JAXB(ExtensionPointRegistry registry) { + super(); + contextHelper = JAXBContextHelper.getInstance(registry); + } + @Override + public String getSourceDataBinding() { + return org.apache.axiom.om.OMElement.class.getName(); + } + + public Object transform(final OMElement source, final TransformationContext context) throws TransformationException { + try { + return AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() { + public Object run() throws JAXBException, XMLStreamException { + Unmarshaller unmarshaller = null; + XMLStreamReader reader = null; + Object result = null; + // Marshalling directly to the output stream is faster than marshalling through the + // XMLStreamWriter. + // Take advantage of this optimization if there is an output stream. + JAXBContext jaxbContext = contextHelper.createJAXBContext(context, false); + try { + unmarshaller = contextHelper.getUnmarshaller(jaxbContext); + reader = source.getXMLStreamReaderWithoutCaching(); + // https://issues.apache.org/jira/browse/WSCOMMONS-395 + reader = new StreamReaderDelegate(reader) { + // Fix the issue in WSCOMMONS-395 + public String getAttributeType(int index) { + String type = super.getAttributeType(index); + return type == null ? "CDATA" : type; + } + }; + result = unmarshaller.unmarshal(reader, JAXBContextHelper.getJavaType(context.getTargetDataType())); + } finally { + if (reader != null) { + reader.close(); + } + contextHelper.releaseJAXBUnmarshaller(jaxbContext, unmarshaller); + } + return JAXBContextHelper.createReturnValue(jaxbContext, context.getTargetDataType(), result); + } + }); + } catch (PrivilegedActionException e) { + throw new TransformationException(e.getException()); + } + } + + @Override + public Class<OMElement> getSourceType() { + return OMElement.class; + } + + @Override + public Class<Object> getTargetType() { + return Object.class; + } + + @Override + public int getWeight() { + return 3000; + } +} diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBCustomBuilder.java b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBCustomBuilder.java new file mode 100644 index 0000000000..f30a6c1cb8 --- /dev/null +++ b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBCustomBuilder.java @@ -0,0 +1,114 @@ +/* + * 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.tuscany.sca.databinding.jaxb.axiom.ext; + +import javax.xml.bind.JAXBException; +import javax.xml.stream.XMLStreamReader; + +import org.apache.axiom.om.OMContainer; +import org.apache.axiom.om.OMDataSource; +import org.apache.axiom.om.OMElement; +import org.apache.axiom.om.OMException; +import org.apache.axiom.om.OMFactory; +import org.apache.axiom.om.OMNamespace; +import org.apache.axiom.om.impl.builder.CustomBuilder; + +/** + * JAXBCustomBuilder creates an OMSourcedElement backed by a JAXBDataSource + * for the specified namespace and localPart. + */ +public class JAXBCustomBuilder implements CustomBuilder { + + private JAXBDSContext jdsContext; + + /** + * Create a JAXBCustomBuilder + * @param context JAXBDSContext + */ + public JAXBCustomBuilder(JAXBDSContext context) { + super(); + this.jdsContext = context; + } + + public OMElement create(String namespace, + String localPart, + OMContainer parent, + XMLStreamReader reader, + OMFactory factory) throws OMException { + + // There are some situations where we want to use normal + // unmarshalling, so return null + if (!shouldUnmarshal(namespace, localPart)) { + // JAXBCustomBuilderMonitor.updateTotalFailedCreates(); + return null; + } + try { + // Create an OMSourcedElement backed by an unmarshalled JAXB object + OMNamespace ns = factory.createOMNamespace(namespace, reader.getPrefix()); + + Object jaxb = jdsContext.unmarshal(reader); + + OMDataSource ds = new JAXBDataSourceExt(jaxb, jdsContext); + OMElement omse = factory.createOMElement(ds, localPart, ns); + + parent.addChild(omse); + // JAXBCustomBuilderMonitor.updateTotalCreates(); + return omse; + } catch (JAXBException e) { + // JAXBCustomBuilderMonitor.updateTotalFailedCreates(); + throw new OMException(e); + } + } + + /** + * The namespace identifier for the SOAP 1.1 envelope. + */ + public static final String URI_NS_SOAP_1_1_ENVELOPE = "http://schemas.xmlsoap.org/soap/envelope/"; + /** + * The namespace identifier for the SOAP 1.2 envelope. + */ + public static final String URI_NS_SOAP_1_2_ENVELOPE = "http://www.w3.org/2003/05/soap-envelope"; + + /** + * @param namespace + * @param localPart + * @return true if this ns and local part is acceptable for unmarshalling + */ + private boolean shouldUnmarshal(String namespace, String localPart) { + + // Don't unmarshall SOAPFaults or anything else in the SOAP + // namespace. + // Don't unmarshall elements that are unqualified + if (localPart == null || namespace == null + || namespace.length() == 0 + || URI_NS_SOAP_1_1_ENVELOPE.equals(namespace) + || URI_NS_SOAP_1_2_ENVELOPE.equals(namespace)) { + return false; + } + + // Don't unmarshal if this looks like encrypted data + if (localPart.equals("EncryptedData")) { + return false; + } + + return true; + + } +} diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBDSContext.java b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBDSContext.java new file mode 100644 index 0000000000..f6bd33864f --- /dev/null +++ b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBDSContext.java @@ -0,0 +1,191 @@ +/* + * 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.tuscany.sca.databinding.jaxb.axiom.ext; + +import java.io.OutputStream; +import java.security.AccessController; +import java.security.PrivilegedAction; +import java.util.logging.Level; +import java.util.logging.Logger; + +import javax.xml.bind.JAXBContext; +import javax.xml.bind.JAXBException; +import javax.xml.bind.Marshaller; +import javax.xml.bind.Unmarshaller; +import javax.xml.bind.attachment.AttachmentMarshaller; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import javax.xml.stream.XMLStreamWriter; + +import org.apache.axiom.om.OMException; +import org.apache.axiom.om.impl.MTOMXMLStreamWriter; +import org.apache.tuscany.sca.databinding.jaxb.JAXBContextHelper; + +/* + * To marshal or unmarshal a JAXB object, the JAXBContext is necessary. + * In addition, access to the MessageContext and other context objects may be necessary + * to get classloader information, store attachments etc. + * + * The JAXBDSContext bundles all of this information together. + */ +public class JAXBDSContext { + + private static final Logger log = Logger.getLogger(JAXBDSContext.class.getName()); + private static final boolean DEBUG_ENABLED = log.isLoggable(Level.FINER); + + private JAXBContext jaxbContext = null; // JAXBContext + private JAXBContextHelper contextHelper; + + /** + * "Dispatch" Constructor Use this full constructor when the JAXBContent is provided by the + * customer. + * + * @param jaxbContext + */ + public JAXBDSContext(JAXBContext jaxbContext, JAXBContextHelper contextHelper) { + this.jaxbContext = jaxbContext; + this.contextHelper = contextHelper; + } + + public JAXBContext getJAXBContext() { + return jaxbContext; + } + + /** + * Unmarshal the xml into a JAXB object + * @param reader + * @return + * @throws JAXBException + */ + public Object unmarshal(XMLStreamReader reader) throws JAXBException { + + Unmarshaller u = contextHelper.getUnmarshaller(getJAXBContext()); + + Object jaxb = null; + + // Unmarshal into the business object. + jaxb = unmarshalElement(u, reader); // preferred and always used for + // style=document + + // Successfully unmarshalled the object + // JAXBUtils.releaseJAXBUnmarshaller(getJAXBContext(cl), u); + + // Don't close the reader. The reader is owned by the caller, and it + // may contain other xml instance data (other than this JAXB object) + // reader.close(); + return jaxb; + } + + /** + * Marshal the jaxb object + * @param obj + * @param writer + * @param am AttachmentMarshaller, optional Attachment + */ + public void marshal(Object obj, XMLStreamWriter writer) throws JAXBException { + + // Very easy, use the Context to get the Marshaller. + // Use the marshaller to write the object. + Marshaller m = contextHelper.getMarshaller(getJAXBContext()); + AttachmentMarshaller am = m.getAttachmentMarshaller(); + boolean xop = am != null ? am.isXOPPackage() : false; + // Marshal the object + marshalElement(obj, m, writer, !xop); + } + + /** + * Preferred way to marshal objects. + * + * @param b Object that can be rendered as an element and the element name is known by the + * Marshaller + * @param m Marshaller + * @param writer XMLStreamWriter + */ + private static void marshalElement(final Object b, + final Marshaller m, + final XMLStreamWriter writer, + final boolean optimize) { + AccessController.doPrivileged(new PrivilegedAction<Object>() { + public Object run() { + // Marshalling directly to the output stream is faster than marshalling through the + // XMLStreamWriter. + // Take advantage of this optimization if there is an output stream. + try { + OutputStream os = (optimize) ? getOutputStream(writer) : null; + if (os != null) { + writer.flush(); + m.marshal(b, os); + } else { + m.marshal(b, writer); + } + } catch (OMException e) { + throw e; + } catch (Throwable t) { + throw new OMException(t); + } + return null; + } + }); + } + + /** + * If the writer is backed by an OutputStream, then return the OutputStream + * @param writer + * @return OutputStream or null + */ + private static OutputStream getOutputStream(XMLStreamWriter writer) throws XMLStreamException { + if (writer.getClass() == MTOMXMLStreamWriter.class) { + return ((MTOMXMLStreamWriter)writer).getOutputStream(); + } + if (writer.getClass() == XMLStreamWriterWithOS.class) { + return ((XMLStreamWriterWithOS)writer).getOutputStream(); + } + return null; + } + + /** + * Preferred way to unmarshal objects + * + * @param u Unmarshaller + * @param reader XMLStreamReader + * @return Object that represents an element + */ + private static Object unmarshalElement(final Unmarshaller u, final XMLStreamReader reader) { + try { + return AccessController.doPrivileged(new PrivilegedAction<Object>() { + public Object run() { + try { + return u.unmarshal(reader); + } catch (OMException e) { + throw e; + } catch (Throwable t) { + throw new OMException(t); + } + } + }); + + } catch (OMException e) { + throw e; + } catch (Throwable t) { + throw new OMException(t); + } + } + +} diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBDataSourceExt.java b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBDataSourceExt.java new file mode 100644 index 0000000000..5a5afc13cb --- /dev/null +++ b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/JAXBDataSourceExt.java @@ -0,0 +1,144 @@ +/* + * 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.tuscany.sca.databinding.jaxb.axiom.ext; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.InputStream; +import java.io.OutputStream; +import java.io.UnsupportedEncodingException; +import java.io.Writer; +import java.util.logging.Level; +import java.util.logging.Logger; + +import javax.xml.bind.JAXBException; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import javax.xml.stream.XMLStreamWriter; + +import org.apache.axiom.om.OMDataSourceExt; +import org.apache.axiom.om.OMException; +import org.apache.axiom.om.OMOutputFormat; +import org.apache.axiom.om.ds.OMDataSourceExtBase; +import org.apache.axiom.om.impl.MTOMXMLStreamWriter; +import org.apache.axiom.om.util.StAXUtils; + +/** + * OMDataSource backed by a jaxb object + */ +public class JAXBDataSourceExt extends OMDataSourceExtBase { + + private static final Logger log = Logger.getLogger(JAXBDataSourceExt.class.getName()); + + private Object jaxb; + private JAXBDSContext context; + + public JAXBDataSourceExt(Object jaxb, JAXBDSContext context) { + super(); + this.jaxb = jaxb; + this.context = context; + } + + public void close() { + } + + public OMDataSourceExt copy() { + return new JAXBDataSourceExt(jaxb, context); + } + + public Object getObject() { + return jaxb; + } + + public JAXBDSContext getContext() { + return context; + } + + public XMLStreamReader getReader() throws XMLStreamException { + + try { + String encoding = "utf-8"; + InputStream is = new ByteArrayInputStream(getXMLBytes(encoding)); + return StAXUtils.createXMLStreamReader(is, encoding); + } catch (UnsupportedEncodingException e) { + throw new XMLStreamException(e); + } + } + + public void serialize(OutputStream output, OMOutputFormat format) throws XMLStreamException { + MTOMXMLStreamWriter writer = new MTOMXMLStreamWriter(output, format); + serialize(writer); + writer.flush(); + try { + writer.close(); + } catch (XMLStreamException e) { + // An exception can occur if nothing is written to the + // writer. This is possible if the underlying data source + // writers to the output stream directly. + if (log.isLoggable(Level.FINER)) { + log.finer("Catching and swallowing exception " + e); + } + } + } + + public void serialize(Writer writerTarget, OMOutputFormat format) throws XMLStreamException { + MTOMXMLStreamWriter writer = new MTOMXMLStreamWriter(StAXUtils.createXMLStreamWriter(writerTarget)); + writer.setOutputFormat(format); + serialize(writer); + writer.flush(); + writer.close(); + } + + public void serialize(XMLStreamWriter xmlWriter) throws XMLStreamException { + try { + context.marshal(jaxb, xmlWriter); + } catch (JAXBException je) { + throw new XMLStreamException(je); + } + } + + public byte[] getXMLBytes(String encoding) throws UnsupportedEncodingException { + try { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Exposes getOutputStream, which allows faster writes. + XMLStreamWriterWithOS writer = new XMLStreamWriterWithOS(baos, encoding); + + // Write the business object to the writer + serialize(writer); + + // Flush the writer + writer.flush(); + writer.close(); + return baos.toByteArray(); + } catch (XMLStreamException e) { + throw new OMException(e); + } + } + + public boolean isDestructiveRead() { + return false; + } + + public boolean isDestructiveWrite() { + return false; + } + +} diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/SourceDataSource.java b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/SourceDataSource.java new file mode 100644 index 0000000000..0a12654524 --- /dev/null +++ b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/SourceDataSource.java @@ -0,0 +1,123 @@ +/* + * 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.tuscany.sca.databinding.jaxb.axiom.ext; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.UnsupportedEncodingException; + +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import javax.xml.transform.Result; +import javax.xml.transform.Source; +import javax.xml.transform.Transformer; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.stream.StreamResult; +import javax.xml.transform.stream.StreamSource; + +import org.apache.axiom.om.OMDataSourceExt; +import org.apache.axiom.om.OMException; +import org.apache.axiom.om.ds.OMDataSourceExtBase; +import org.apache.axiom.om.util.StAXUtils; + +/** + * OMDataSource backed by a source + */ +public class SourceDataSource extends OMDataSourceExtBase { + private Source data; + + public SourceDataSource(Source data) { + super(); + this.data = data; + } + + public void close() { + } + + public OMDataSourceExt copy() { + return new SourceDataSource(data); + } + + public Object getObject() { + return data; + } + + public XMLStreamReader getReader() throws XMLStreamException { + + try { + String encoding = "UTF-8"; + InputStream is = new ByteArrayInputStream(getXMLBytes(encoding)); + return StAXUtils.createXMLStreamReader(is, encoding); + } catch (UnsupportedEncodingException e) { + throw new XMLStreamException(e); + } + } + + public byte[] getXMLBytes(String encoding) throws UnsupportedEncodingException { + byte[] bytes = null; + try { + bytes = (byte[])null; + + if (data instanceof StreamSource) { + InputStream is = ((StreamSource)data).getInputStream(); + if (is != null) { + bytes = getBytesFromStream(is); + } + } else { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + Result result = new StreamResult(out); + Transformer transformer = TransformerFactory.newInstance().newTransformer(); + transformer.transform(data, result); + bytes = out.toByteArray(); + } + } catch (OMException e) { + throw e; + } catch (UnsupportedEncodingException e) { + throw e; + } catch (Throwable e) { + throw new OMException(e); + } + + return bytes; + } + + public boolean isDestructiveRead() { + return false; + } + + public boolean isDestructiveWrite() { + return false; + } + + private static byte[] getBytesFromStream(InputStream is) throws IOException { + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + byte[] buf = new byte[4096]; + while (true) { + int size = is.read(buf); + if (size < 0) { + break; + } + bos.write(buf, 0, size); + } + return bos.toByteArray(); + } +} diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/XMLStreamWriterWithOS.java b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/XMLStreamWriterWithOS.java new file mode 100644 index 0000000000..44e34c3647 --- /dev/null +++ b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/XMLStreamWriterWithOS.java @@ -0,0 +1,246 @@ +/* + * 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.tuscany.sca.databinding.jaxb.axiom.ext; + +import java.io.OutputStream; + +import javax.xml.namespace.NamespaceContext; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamWriter; + +import org.apache.axiom.om.util.StAXUtils; + +/** + * XMLStreamReader that exposes direct access to the OutputStream. + * Writing to the output stream is faster in some cases. + */ +public class XMLStreamWriterWithOS implements XMLStreamWriter { + private XMLStreamWriter writer; + private String charSetEncoding; + private OutputStream os; + + public XMLStreamWriterWithOS(OutputStream os, String charSetEncoding) throws XMLStreamException { + super(); + writer = null; // Writer is created when needed + this.os = os; + this.charSetEncoding = charSetEncoding; + } + + /** + * The writer is created lazily. + * If only the output stream is used, then the writer is never created. + */ + private void createWriter() throws XMLStreamException { + if (writer == null) { + writer = StAXUtils.createXMLStreamWriter(os, charSetEncoding); + } + } + + public void close() throws XMLStreamException { + if (writer != null) { + writer.close(); + } + } + + public void flush() throws XMLStreamException { + if (writer != null) { + writer.flush(); + } + } + + public NamespaceContext getNamespaceContext() { + try { + createWriter(); + } catch (Exception e) { + throw new RuntimeException(e); + } + return writer.getNamespaceContext(); + } + + public String getPrefix(String arg0) throws XMLStreamException { + createWriter(); + return writer.getPrefix(arg0); + } + + public Object getProperty(String arg0) throws IllegalArgumentException { + try { + createWriter(); + } catch (XMLStreamException e) { + throw new IllegalArgumentException(e); + } + return writer.getProperty(arg0); + } + + public void setDefaultNamespace(String arg0) throws XMLStreamException { + createWriter(); + writer.setDefaultNamespace(arg0); + } + + public void setNamespaceContext(NamespaceContext arg0) throws XMLStreamException { + createWriter(); + writer.setNamespaceContext(arg0); + } + + public void setPrefix(String arg0, String arg1) throws XMLStreamException { + createWriter(); + writer.setPrefix(arg0, arg1); + } + + public void writeAttribute(String arg0, String arg1, String arg2, String arg3) throws XMLStreamException { + createWriter(); + writer.writeAttribute(arg0, arg1, arg2, arg3); + } + + public void writeAttribute(String arg0, String arg1, String arg2) throws XMLStreamException { + createWriter(); + writer.writeAttribute(arg0, arg1, arg2); + } + + public void writeAttribute(String arg0, String arg1) throws XMLStreamException { + createWriter(); + writer.writeAttribute(arg0, arg1); + } + + public void writeCData(String arg0) throws XMLStreamException { + createWriter(); + writer.writeCData(arg0); + } + + public void writeCharacters(char[] arg0, int arg1, int arg2) throws XMLStreamException { + createWriter(); + writer.writeCharacters(arg0, arg1, arg2); + } + + public void writeCharacters(String arg0) throws XMLStreamException { + createWriter(); + writer.writeCharacters(arg0); + } + + public void writeComment(String arg0) throws XMLStreamException { + createWriter(); + writer.writeComment(arg0); + } + + public void writeDefaultNamespace(String arg0) throws XMLStreamException { + createWriter(); + writer.writeDefaultNamespace(arg0); + } + + public void writeDTD(String arg0) throws XMLStreamException { + createWriter(); + writer.writeDTD(arg0); + } + + public void writeEmptyElement(String arg0, String arg1, String arg2) throws XMLStreamException { + createWriter(); + writer.writeEmptyElement(arg0, arg1, arg2); + } + + public void writeEmptyElement(String arg0, String arg1) throws XMLStreamException { + createWriter(); + writer.writeEmptyElement(arg0, arg1); + } + + public void writeEmptyElement(String arg0) throws XMLStreamException { + createWriter(); + writer.writeEmptyElement(arg0); + } + + public void writeEndDocument() throws XMLStreamException { + createWriter(); + writer.writeEndDocument(); + } + + public void writeEndElement() throws XMLStreamException { + createWriter(); + writer.writeEndElement(); + } + + public void writeEntityRef(String arg0) throws XMLStreamException { + createWriter(); + writer.writeEntityRef(arg0); + } + + public void writeNamespace(String arg0, String arg1) throws XMLStreamException { + createWriter(); + writer.writeNamespace(arg0, arg1); + } + + public void writeProcessingInstruction(String arg0, String arg1) throws XMLStreamException { + createWriter(); + writer.writeProcessingInstruction(arg0, arg1); + } + + public void writeProcessingInstruction(String arg0) throws XMLStreamException { + createWriter(); + writer.writeProcessingInstruction(arg0); + } + + public void writeStartDocument() throws XMLStreamException { + createWriter(); + writer.writeStartDocument(); + } + + public void writeStartDocument(String arg0, String arg1) throws XMLStreamException { + createWriter(); + writer.writeStartDocument(arg0, arg1); + } + + public void writeStartDocument(String arg0) throws XMLStreamException { + createWriter(); + writer.writeStartDocument(arg0); + } + + public void writeStartElement(String arg0, String arg1, String arg2) throws XMLStreamException { + createWriter(); + writer.writeStartElement(arg0, arg1, arg2); + } + + public void writeStartElement(String arg0, String arg1) throws XMLStreamException { + createWriter(); + writer.writeStartElement(arg0, arg1); + } + + public void writeStartElement(String arg0) throws XMLStreamException { + createWriter(); + writer.writeStartElement(arg0); + } + + /** + * If this XMLStreamWriter is connected to an OutputStream + * then the OutputStream is returned. This allows a node + * (perhaps an OMSourcedElement) to write its content + * directly to the OutputStream. + * @return OutputStream or null + */ + public OutputStream getOutputStream() throws XMLStreamException { + + if (os != null) { + // Flush the state of the writer..Many times the + // write defers the writing of tag characters (>) + // until the next write. Flush out this character + if (writer != null) { + this.writeCharacters(""); + this.flush(); + } + } + return os; + } +} diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/XMLStringDataSource.java b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/XMLStringDataSource.java new file mode 100644 index 0000000000..e8e3193e24 --- /dev/null +++ b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/java/org/apache/tuscany/sca/databinding/jaxb/axiom/ext/XMLStringDataSource.java @@ -0,0 +1,84 @@ +/* + * 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.tuscany.sca.databinding.jaxb.axiom.ext; + +import java.io.IOException; +import java.io.StringReader; +import java.io.UnsupportedEncodingException; +import java.io.Writer; + +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; + +import org.apache.axiom.om.OMDataSourceExt; +import org.apache.axiom.om.OMOutputFormat; +import org.apache.axiom.om.ds.OMDataSourceExtBase; +import org.apache.axiom.om.util.StAXUtils; + +/** + * OMDataSource backed by a string containing xml data + */ +public class XMLStringDataSource extends OMDataSourceExtBase { + private String data; + + public XMLStringDataSource(String data) { + super(); + this.data = data; + } + + public void close() { + } + + public OMDataSourceExt copy() { + return new XMLStringDataSource(data); + } + + public Object getObject() { + return data; + } + + public XMLStreamReader getReader() throws XMLStreamException { + StringReader reader = new StringReader(data); + return StAXUtils.createXMLStreamReader(reader); + } + + public void serialize(Writer writer, OMOutputFormat format) throws XMLStreamException { + try { + writer.write(data); + } catch (UnsupportedEncodingException e) { + throw new XMLStreamException(e); + } catch (IOException e) { + throw new XMLStreamException(e); + } + } + + public byte[] getXMLBytes(String encoding) throws UnsupportedEncodingException { + return data.getBytes(encoding); + } + + public boolean isDestructiveRead() { + return false; + } + + public boolean isDestructiveWrite() { + return false; + } + +} diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/resources/META-INF/services/org.apache.tuscany.sca.databinding.PullTransformer b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/resources/META-INF/services/org.apache.tuscany.sca.databinding.PullTransformer new file mode 100644 index 0000000000..d1799abaff --- /dev/null +++ b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/main/resources/META-INF/services/org.apache.tuscany.sca.databinding.PullTransformer @@ -0,0 +1,27 @@ +# 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. + +# Implementation classes for the transformers +org.apache.tuscany.sca.databinding.jaxb.axiom.JAXB2OMElement;source=javax.xml.bind.JAXBElement,target=org.apache.axiom.om.OMElement,weight=3000 +org.apache.tuscany.sca.databinding.jaxb.axiom.JAXB2OMElement;source=java:simpleType,target=org.apache.axiom.om.OMElement,weight=3000 +org.apache.tuscany.sca.databinding.jaxb.axiom.JAXB2OMElement;source=java:complexType,target=org.apache.axiom.om.OMElement,weight=3000 + +org.apache.tuscany.sca.databinding.jaxb.axiom.OMElement2JAXB;source=org.apache.axiom.om.OMElement,target=javax.xml.bind.JAXBElement,weight=3000,public=false +org.apache.tuscany.sca.databinding.jaxb.axiom.OMElement2JAXB;source=org.apache.axiom.om.OMElement,target=java:complexType,weight=90000,public=false +org.apache.tuscany.sca.databinding.jaxb.axiom.OMElement2JAXB;source=org.apache.axiom.om.OMElement,target=java:simpleType,weight=90000,public=false + +
diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/test/java/org/apache/tuscany/databinding/jaxb/axiom/JAXB2OMTestCase.java b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/test/java/org/apache/tuscany/databinding/jaxb/axiom/JAXB2OMTestCase.java new file mode 100644 index 0000000000..df2b6dc4e3 --- /dev/null +++ b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/test/java/org/apache/tuscany/databinding/jaxb/axiom/JAXB2OMTestCase.java @@ -0,0 +1,113 @@ +/* + * 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.tuscany.databinding.jaxb.axiom; + +import java.io.StringWriter; + +import javax.xml.bind.JAXBElement; +import javax.xml.stream.XMLStreamReader; + +import org.apache.axiom.om.OMElement; +import org.apache.axiom.om.impl.builder.StAXOMBuilder; +import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry; +import org.apache.tuscany.sca.core.ExtensionPointRegistry; +import org.apache.tuscany.sca.databinding.TransformationContext; +import org.apache.tuscany.sca.databinding.impl.TransformationContextImpl; +import org.apache.tuscany.sca.databinding.jaxb.JAXB2Node; +import org.apache.tuscany.sca.databinding.jaxb.JAXBContextHelper; +import org.apache.tuscany.sca.databinding.jaxb.axiom.JAXB2OMElement; +import org.apache.tuscany.sca.databinding.xml.Node2XMLStreamReader; +import org.apache.tuscany.sca.interfacedef.DataType; +import org.apache.tuscany.sca.interfacedef.impl.DataTypeImpl; +import org.apache.tuscany.sca.interfacedef.util.XMLType; +import org.junit.Test; +import org.w3c.dom.Node; + +import com.example.ipo.jaxb.ObjectFactory; +import com.example.ipo.jaxb.PurchaseOrderType; +import com.example.ipo.jaxb.USAddress; +import com.example.ipo.jaxb.USState; + +/** + * @version $Rev$ $Date$ + */ +public class JAXB2OMTestCase { + @Test + public void testTransformElement() throws Exception { + JAXBElement<PurchaseOrderType> po = createPO(); + DataType<?> sourceDataType = new DataTypeImpl<XMLType>(PurchaseOrderType.class, XMLType.UNKNOWN); + DataType<?> targetDataType = new DataTypeImpl<XMLType>(PurchaseOrderType.class, new XMLType(po.getName(), null)); + TransformationContext tContext = new TransformationContextImpl(); + tContext.setSourceDataType(sourceDataType); + tContext.setTargetDataType(targetDataType); + + ExtensionPointRegistry registry = new DefaultExtensionPointRegistry(); + JAXBContextHelper contextHelper = JAXBContextHelper.getInstance(registry); + // Force the JAXBContext to be cached + contextHelper.createJAXBContext(tContext, true); + + long start = System.currentTimeMillis(); + JAXB2OMElement t1 = new JAXB2OMElement(registry); + OMElement om = t1.transform(po, tContext); + long duration1 = System.currentTimeMillis() - start; + StringWriter sw = new StringWriter(); + // serializeAndConsume() will trigger the JAXBDataSource.serialize(Writer, OMOutputFormat) + om.serializeAndConsume(sw); + System.out.println(sw.toString()); + + start = System.currentTimeMillis(); + Node node = new JAXB2Node(new DefaultExtensionPointRegistry()).transform(po, tContext); + XMLStreamReader reader = new Node2XMLStreamReader().transform(node, null); + om = new StAXOMBuilder(reader).getDocumentElement(); + sw = new StringWriter(); + om.serializeAndConsume(sw); + long duration2 = System.currentTimeMillis() - start; + System.out.println(sw.toString()); + System.out.println(duration1 + " vs. " + duration2); + } + + @Test + public void testTransformType() throws Exception { + JAXBElement<PurchaseOrderType> po = createPO(); + DataType<?> sourceDataType = new DataTypeImpl<XMLType>(PurchaseOrderType.class, XMLType.UNKNOWN); + DataType<?> targetDataType = new DataTypeImpl<XMLType>(PurchaseOrderType.class, new XMLType(po.getName(), null)); + TransformationContext tContext = new TransformationContextImpl(); + tContext.setSourceDataType(sourceDataType); + tContext.setTargetDataType(targetDataType); + OMElement om = new JAXB2OMElement(new DefaultExtensionPointRegistry()).transform(po.getValue(), tContext); + StringWriter sw = new StringWriter(); + om.serializeAndConsume(sw); + System.out.println(sw.toString()); + } + + private JAXBElement<PurchaseOrderType> createPO() { + ObjectFactory factory = new ObjectFactory(); + PurchaseOrderType type = factory.createPurchaseOrderType(); + JAXBElement<PurchaseOrderType> po = factory.createPurchaseOrder(type); + type.setItems(factory.createItems()); + type.setComment("123"); + USAddress address = factory.createUSAddress(); + address.setCity("San Jose"); + address.setStreet("ABC St."); + address.setState(USState.CA); + type.setShipTo(address); + return po; + } +} diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/test/java/org/apache/tuscany/databinding/jaxb/axiom/OMElement2JAXBTestCase.java b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/test/java/org/apache/tuscany/databinding/jaxb/axiom/OMElement2JAXBTestCase.java new file mode 100644 index 0000000000..abfcf358d2 --- /dev/null +++ b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/test/java/org/apache/tuscany/databinding/jaxb/axiom/OMElement2JAXBTestCase.java @@ -0,0 +1,72 @@ +/* + * 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.tuscany.databinding.jaxb.axiom; + +import java.io.ByteArrayInputStream; + +import javax.xml.namespace.QName; + +import junit.framework.Assert; + +import org.apache.axiom.om.OMElement; +import org.apache.axiom.om.impl.builder.StAXOMBuilder; +import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry; +import org.apache.tuscany.sca.databinding.TransformationContext; +import org.apache.tuscany.sca.databinding.impl.TransformationContextImpl; +import org.apache.tuscany.sca.databinding.jaxb.axiom.OMElement2JAXB; +import org.apache.tuscany.sca.interfacedef.DataType; +import org.apache.tuscany.sca.interfacedef.impl.DataTypeImpl; +import org.apache.tuscany.sca.interfacedef.util.XMLType; +import org.junit.Test; + +import com.example.ipo.jaxb.PurchaseOrderType; + +/** + * @version $Rev$ $Date$ + */ +public class OMElement2JAXBTestCase { + private static final String XML = + "<ns0:root xmlns:ns0=\"http://ns0\" xmlns:ns2=\"http://www.example.com/IPO\">" + "<ns1:next xmlns:ns1=\"http://ns1\">" + + "<ns2:purchaseOrder>" + + "<shipTo xsi:type=\"ns2:USAddress\" " + + "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">" + + "<street>ABC St.</street><city>San Jose</city><state>CA</state></shipTo>" + + "<ns2:comment>123</ns2:comment><items/>" + + "</ns2:purchaseOrder>" + + "</ns1:next>" + + "</ns0:root>"; + + @Test + public void testTransform() throws Exception { + DataType<?> sourceDataType = new DataTypeImpl<XMLType>(PurchaseOrderType.class, XMLType.UNKNOWN); + QName qname = new QName("http://www.example.com/IPO", "purchaseOrder"); + DataType<?> targetDataType = new DataTypeImpl<XMLType>(PurchaseOrderType.class, new XMLType(qname, null)); + TransformationContext tContext = new TransformationContextImpl(); + tContext.setSourceDataType(sourceDataType); + tContext.setTargetDataType(targetDataType); + + StAXOMBuilder builder = new StAXOMBuilder(new ByteArrayInputStream(XML.getBytes("UTF-8"))); + OMElement root = builder.getDocumentElement(); + OMElement next = (OMElement)root.getChildElements().next(); + OMElement po = (OMElement)next.getChildElements().next(); + Object jaxb = new OMElement2JAXB(new DefaultExtensionPointRegistry()).transform(po, tContext); + Assert.assertTrue(jaxb instanceof PurchaseOrderType); + } +} diff --git a/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/test/resources/ipo.xsd b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/test/resources/ipo.xsd new file mode 100644 index 0000000000..241ec15d36 --- /dev/null +++ b/sca-java-2.x/branches/2.0-Beta2/modules/databinding-jaxb-axiom/src/test/resources/ipo.xsd @@ -0,0 +1,136 @@ +<!-- + * 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. +--> +<schema targetNamespace="http://www.example.com/IPO" + xmlns="http://www.w3.org/2001/XMLSchema" + xmlns:ipo="http://www.example.com/IPO"> + + <annotation> + <documentation xml:lang="en"> + International Purchase order schema for Example.com + Copyright 2000 Example.com. All rights reserved. + </documentation> + </annotation> + + + <element name="purchaseOrder" type="ipo:PurchaseOrderType" /> + + <element name="comment" type="string" /> + + <complexType name="PurchaseOrderType"> + <sequence> + <element name="shipTo" type="ipo:Address" /> + <element name="billTo" type="ipo:Address" /> + <element ref="ipo:comment" minOccurs="0" /> + <element name="items" type="ipo:Items" /> + </sequence> + <attribute name="orderDate" type="date" /> + </complexType> + + <complexType name="Items"> + <sequence> + <element name="item" minOccurs="0" maxOccurs="unbounded"> + <complexType> + <sequence> + <element name="productName" type="string" /> + <element name="quantity"> + <simpleType> + <restriction base="positiveInteger"> + <maxExclusive value="100" /> + </restriction> + </simpleType> + </element> + <element name="USPrice" type="decimal" /> + <element ref="ipo:comment" minOccurs="0" /> + <element name="shipDate" type="date" + minOccurs="0" /> + </sequence> + <attribute name="partNum" type="ipo:SKU" + use="required" /> + </complexType> + </element> + </sequence> + </complexType> + + <simpleType name="SKU"> + <restriction base="string"> + <pattern value="\d{3}-[A-Z]{2}" /> + </restriction> + </simpleType> + + <complexType name="Address"> + <sequence> + <element name="name" type="string" /> + <element name="street" type="string" /> + <element name="city" type="string" /> + </sequence> + </complexType> + + <complexType name="USAddress"> + <complexContent> + <extension base="ipo:Address"> + <sequence> + <element name="state" type="ipo:USState" /> + <element name="zip" type="positiveInteger" /> + </sequence> + </extension> + </complexContent> + </complexType> + + <complexType name="UKAddress"> + <complexContent> + <extension base="ipo:Address"> + <sequence> + <element name="postcode" type="ipo:UKPostcode" /> + </sequence> + <attribute name="exportCode" type="positiveInteger" + fixed="1" /> + </extension> + </complexContent> + </complexType> + + <!-- other Address derivations for more countries --> + + <simpleType name="USState"> + <restriction base="string"> + <enumeration value="AK" /> + <enumeration value="AL" /> + <enumeration value="AR" /> + <enumeration value="CA" /> + <enumeration value="PA" /> + <!-- and so on ... --> + </restriction> + </simpleType> + + <simpleType name="Postcode"> + <restriction base="string"> + <length value="7" fixed="true" /> + </restriction> + </simpleType> + + + <simpleType name="UKPostcode"> + <restriction base="ipo:Postcode"> + <pattern value="[A-Z]{2}\d\s\d[A-Z]{2}" /> + </restriction> + </simpleType> + + + +</schema> + |