/*
* 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.datasource.jaxb;
import org.apache.axiom.om.OMException;
import org.apache.axiom.om.impl.MTOMXMLStreamWriter;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.java.security.AccessController;
import org.apache.axis2.jaxws.message.databinding.JAXBUtils;
import org.apache.axis2.jaxws.message.util.XMLStreamWriterWithOS;
import org.apache.axis2.jaxws.spi.Constants;
import org.apache.axis2.jaxws.utility.JavaUtils;
import org.apache.axis2.jaxws.utility.XMLRootElementUtil;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.bind.attachment.AttachmentMarshaller;
import javax.xml.bind.attachment.AttachmentUnmarshaller;
import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.ws.Holder;
import javax.xml.ws.WebServiceException;
import java.io.OutputStream;
import java.lang.ref.WeakReference;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.PrivilegedAction;
import java.text.ParseException;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeSet;
/*
* 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 Log log = LogFactory.getLog(JAXBDSContext.class);
public static final boolean DEBUG_ENABLED = log.isDebugEnabled();
private TreeSet<String> contextPackages; // List of packages needed by the context
private String contextPackagesKey; // Unique key that represents the set of packages
private JAXBContext customerJAXBContext; // JAXBContext provided by the customer api
// JAXBContext loaded by the engine. It is weakref'd to allow GC
private WeakReference<JAXBContext> autoJAXBContext = null;
private JAXBUtils.CONSTRUCTION_TYPE // How the JAXBContext is constructed
constructionType = JAXBUtils.CONSTRUCTION_TYPE.UNKNOWN;
private MessageContext msgContext;
// There are two modes of marshalling and unmarshalling:
// "by java type" and "by schema element".
// The prefered mode is "by schema element" because it is safe and xml-centric.
// However there are some circumstances when "by schema element" is not available.
// Examples: RPC Lit processing (the wire element is defined by a wsdl:part...not schema)
// Doc/Lit Bare "Minimal" Processing (JAXB ObjectFactories are missing...
// and thus we must use "by type" for primitives/String)
// Please don't use "by java type" processing to get around errors.
private Class processType = null;
private boolean isxmlList =false;
private String webServiceNamespace;
/**
* Full Constructor JAXBDSContext (most performant)
*
* @param packages Set of packages needed by the JAXBContext.
*/
public JAXBDSContext(TreeSet<String> packages, String packagesKey) {
this.contextPackages = packages;
this.contextPackagesKey = packagesKey;
}
/**
* Slightly slower constructor
*
* @param packages
*/
public JAXBDSContext(TreeSet<String> packages) {
this(packages, packages.toString());
}
/**
* Normal Constructor JAXBBlockContext
*
* @param contextPackage
* @deprecated
*/
public JAXBDSContext(String contextPackage) {
this.contextPackages = new TreeSet();
this.contextPackages.add(contextPackage);
this.contextPackagesKey = this.contextPackages.toString();
}
/**
* "Dispatch" Constructor
* Use this full constructor when the JAXBContent is provided by the
* customer.
*
* @param jaxbContext
*/
public JAXBDSContext(JAXBContext jaxbContext) {
this.customerJAXBContext = jaxbContext;
}
/** @return Class representing type of the element */
public TreeSet<String> getContextPackages() {
return contextPackages;
}
public JAXBContext getJAXBContext() throws JAXBException {
return getJAXBContext(null);
}
/**
* @return get the JAXBContext
* @throws JAXBException
*/
public JAXBContext getJAXBContext(ClassLoader cl) throws JAXBException {
if (customerJAXBContext != null) {
return customerJAXBContext;
}
// Get the weakly cached JAXBContext
JAXBContext jc = null;
if (autoJAXBContext != null) {
jc = autoJAXBContext.get();
}
if (jc == null) {
if (log.isDebugEnabled()) {
log.debug(
"A JAXBContext did not exist, creating a new one with the context packages.");
}
Holder<JAXBUtils.CONSTRUCTION_TYPE> constructType =
new Holder<JAXBUtils.CONSTRUCTION_TYPE>();
Map<String, Object> properties = null;
/*
* We set the default namespace to the web service namespace to fix an
* obscur bug.
*
* If the class representing a JAXB data object does not define a namespace
* (via an annotation like @XmlType or via ObjectFactory or schema gen information)
* then the namespace information is defaulted.
*
* The xjc tool defaults the namespace information to unqualified.
* However the wsimport tool defaults the namespace to the namespace of the
* webservice.
*
* To "workaround" this issue, a default namespace equal to the webservice
* namespace is set on the JAXB marshaller. This has the effect of changing the
* "unqualified namespaces" into the namespace used by the webservice.
*
*/
if (this.webServiceNamespace != null) {
properties = new HashMap<String, Object>();
properties.put(JAXBUtils.DEFAULT_NAMESPACE_REMAP, this.webServiceNamespace);
}
jc = JAXBUtils.getJAXBContext(contextPackages, constructType,
contextPackagesKey, cl, properties);
constructionType = constructType.value;
autoJAXBContext = new WeakReference<JAXBContext>(jc);
} else {
if (log.isDebugEnabled()) {
log.debug("Using an existing JAXBContext");
}
}
return jc;
}
public void setWebServiceNamespace(String namespace) {
this.webServiceNamespace = namespace;
}
/** @return RPC Declared Type */
public Class getProcessType() {
return processType;
}
/**
* Set RPC Declared Type. The use of use this property if the message is style=document is
* discouraged.
*
* @param type
*/
public void setProcessType(Class type) {
processType = type;
}
public JAXBUtils.CONSTRUCTION_TYPE getConstructionType() {
return constructionType;
}
public boolean isxmlList() {
return isxmlList;
}
public void setIsxmlList(boolean isxmlList) {
this.isxmlList = isxmlList;
}
public MessageContext getMessageContext() {
return msgContext;
}
public void setMessageContext(MessageContext messageContext) {
this.msgContext = messageContext;
}
public ClassLoader getClassLoader() {
MessageContext context = getMessageContext();
if (context != null) {
return (ClassLoader) context.getProperty(Constants.CACHE_CLASSLOADER);
}
return null;
}
/**
* Create an AttachmentMarshaller to marshal MTOM/SWA Attachments
* @param writer
* @return
*/
protected AttachmentMarshaller createAttachmentMarshaller(XMLStreamWriter writer) {
return new JAXBAttachmentMarshaller(getMessageContext(), writer);
}
/**
* Create an Attachment unmarshaller for unmarshalling MTOM/SWA Attachments
* @return AttachmentUnmarshaller
*/
protected AttachmentUnmarshaller createAttachmentUnmarshaller(XMLStreamReader reader) {
return new JAXBAttachmentUnmarshaller(getMessageContext(), reader);
}
/**
* Unmarshal the xml into a JAXB object
* @param reader
* @return
* @throws JAXBException
*/
public Object unmarshal(XMLStreamReader reader) throws JAXBException {
// There may be a preferred classloader that should be used
ClassLoader cl = getClassLoader();
Unmarshaller u = JAXBUtils.getJAXBUnmarshaller(getJAXBContext(cl));
// Create an attachment unmarshaller
AttachmentUnmarshaller aum = createAttachmentUnmarshaller(reader);
if (aum != null) {
if (DEBUG_ENABLED) {
log.debug("Adding JAXBAttachmentUnmarshaller to Unmarshaller");
}
u.setAttachmentUnmarshaller(aum);
}
Object jaxb = null;
// Unmarshal into the business object.
if (getProcessType() == null) {
jaxb = unmarshalByElement(u, reader); // preferred and always used for
// style=document
} else {
jaxb = unmarshalByType(u,
reader,
getProcessType(),
isxmlList(),
getConstructionType());
}
// 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 {
// There may be a preferred classloader that should be used
ClassLoader cl = getClassLoader();
// Very easy, use the Context to get the Marshaller.
// Use the marshaller to write the object.
Marshaller m = JAXBUtils.getJAXBMarshaller(getJAXBContext(cl));
AttachmentMarshaller am = createAttachmentMarshaller(writer);
if (am != null) {
if (DEBUG_ENABLED) {
log.debug("Adding JAXBAttachmentMarshaller to Marshaller");
}
m.setAttachmentMarshaller(am);
}
// Marshal the object
if (getProcessType() == null) {
marshalByElement(obj,
m,
writer,
true);
//!am.isXOPPackage());
} else {
marshalByType(obj,
m,
writer,
getProcessType(),
isxmlList(),
getConstructionType());
}
// Successfully marshalled the data
JAXBUtils.releaseJAXBMarshaller(getJAXBContext(cl), m);
}
/**
* 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 marshalByElement(final Object b, final Marshaller m,
final XMLStreamWriter writer,
final boolean optimize) {
AccessController.doPrivileged(new PrivilegedAction() {
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 {
if (!optimize) {
log.trace(JavaUtils.stackToString());
getOutputStream(writer);
}
OutputStream os = (optimize) ? getOutputStream(writer) : null;
if (os != null) {
if (DEBUG_ENABLED) {
log.debug("Invoking marshalByElement. " +
"Marshaling to an OutputStream. " +
"Object is "
+ getDebugName(b));
}
writer.flush();
m.marshal(b, os);
} else {
if (DEBUG_ENABLED) {
log.debug("Invoking marshalByElement. " +
"Marshaling to an XMLStreamWriter. " +
"Object is "
+ getDebugName(b));
}
m.marshal(b, writer);
}
} catch (OMException e) {
throw e;
}
catch (Throwable t) {
throw new OMException(t);
}
return null;
}});
}
private static String getDebugName(Object o) {
return (o == null) ? "null" : o.getClass().getCanonicalName();
}
/**
* 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 (log.isDebugEnabled()) {
log.debug("XMLStreamWriter is " + writer);
}
OutputStream os = null;
if (writer.getClass() == MTOMXMLStreamWriter.class) {
os = ((MTOMXMLStreamWriter) writer).getOutputStream();
if (log.isDebugEnabled()) {
log.debug("OutputStream accessible from MTOMXMLStreamWriter is " + os);
}
}
if (writer.getClass() == XMLStreamWriterWithOS.class) {
os = ((XMLStreamWriterWithOS) writer).getOutputStream();
if (log.isDebugEnabled()) {
log.debug("OutputStream accessible from XMLStreamWriterWithOS is " + os);
}
}
return os;
}
/**
* The root element being read is defined by schema/JAXB; however its contents are known by
* schema/JAXB. Therefore we use unmarshal by the declared type (This method is used to
* unmarshal rpc elements)
*
* @param u Unmarshaller
* @param reader XMLStreamReader
* @param type Class
* @return Object
* @throws WebServiceException
*/
public static Object unmarshalByType(final Unmarshaller u, final XMLStreamReader reader,
final Class type, final boolean isList,
final JAXBUtils.CONSTRUCTION_TYPE ctype)
throws WebServiceException {
if (DEBUG_ENABLED) {
log.debug("Invoking unmarshalByType.");
}
return AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
try {
// Unfortunately RPC is type based. Thus a
// declared type must be used to unmarshal the xml.
Object jaxb;
if (!isList) {
// case: We are not unmarshalling an xsd:list but an Array.
if (type.isArray()) {
// If the context is created using package
// we will not have common arrays or type array in the context
// but there is not much we can do about it so seralize it as
// usual
if (ctype == JAXBUtils.CONSTRUCTION_TYPE.BY_CONTEXT_PATH) {
jaxb = u.unmarshal(reader, type);
}
// list on client array on server, Can happen only in start from java
// case.
else if ((ctype == JAXBUtils.CONSTRUCTION_TYPE.BY_CLASS_ARRAY)) {
// The type could be any Object or primitive
// I will first unmarshall the xmldata to a String[]
// Then use the unmarshalled jaxbElement to create
// proper type Object Array.
jaxb = unmarshalArray(reader, u, type);
} else {
jaxb = u.unmarshal(reader, type);
}
} else if (type.isEnum()) {
// When JAXBContext is created using a context path, it will not
// include Enum classes.
// These classes have @XmlEnum annotation but not @XmlType/@XmlElement,
// so the user will see MarshallingEx, class not known to ctxt.
//
// This is a jax-b defect, for now this fix is in place to pass CTS.
// This only fixes the
// situation where the enum is the top-level object (e.g., message-part
// in rpc-lit scenario)
//
// Sample of what enum looks like:
// @XmlEnum public enum EnumString {
// @XmlEnumValue("String1") STRING_1("String1"),
// @XmlEnumValue("String2") STRING_2("String2");
//
// public static getValue(String){} <-- resolves a "value" to an emum
// object
// ... }
if (DEBUG_ENABLED) {
log.debug("unmarshalByType. Unmarshalling " + type.getName()
+ " as Enum");
}
JAXBElement<String> enumValue = u.unmarshal(reader, String.class);
if (enumValue != null) {
Method m =
type.getMethod("fromValue", new Class[] { String.class });
jaxb = m.invoke(null, new Object[] { enumValue.getValue() });
} else {
jaxb = null;
}
}
//Normal case: We are not unmarshalling a xsd:list or Array
else {
jaxb = u.unmarshal(reader, type);
}
} else {
// If this is an xsd:list, we need to return the appropriate
// list or array (see NOTE above)
// First unmarshal as a String
//Second convert the String into a list or array
jaxb = unmarshalAsListOrArray(reader, u, type);
}
return jaxb;
} catch (OMException e) {
throw e;
} catch (Throwable t) {
throw new OMException(t);
}
}
});
}
private static Object unmarshalArray(final XMLStreamReader reader,
final Unmarshaller u,
Class type)
throws Exception {
try {
if (DEBUG_ENABLED) {
log.debug("Invoking unmarshalArray");
}
Object jaxb = AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
try {
return u.unmarshal(reader, String[].class);
} catch (OMException e) {
throw e;
} catch (Throwable t) {
throw new OMException(t);
}
}
});
Object typeObj = getTypeEnabledObject(jaxb);
// Now convert String Array in to the required Type Array.
if (typeObj instanceof String[]) {
String[] strArray = (String[]) typeObj;
Object obj = XSDListUtils.fromStringArray(strArray, type);
QName qName =
XMLRootElementUtil.getXmlRootElementQNameFromObject(jaxb);
jaxb = new JAXBElement(qName, type, obj);
}
return jaxb;
} catch (OMException e) {
throw e;
} catch (Throwable t) {
throw new OMException(t);
}
}
/**
* convert the String into a list or array
* @param <T>
* @param jaxb
* @param type
* @return
* @throws IllegalAccessException
* @throws ParseException
* @throws NoSuchMethodException
* @throws InstantiationException
* @throws DatatypeConfigurationException
* @throws InvocationTargetException
*/
public static Object unmarshalAsListOrArray(final XMLStreamReader reader,
final Unmarshaller u,
Class type)
throws IllegalAccessException, ParseException,NoSuchMethodException,
InstantiationException,
DatatypeConfigurationException,InvocationTargetException,JAXBException {
if (DEBUG_ENABLED) {
log.debug("Invoking unmarshaArray");
}
// If this is an xsd:list, we need to return the appropriate
// list or array (see NOTE above)
// First unmarshal as a String
Object jaxb = null;
try {
jaxb = AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
try {
return u.unmarshal(reader, String.class);
} catch (OMException e) {
throw e;
} catch (Throwable t) {
throw new OMException(t);
}
}
});
} catch (OMException e) {
throw e;
} catch (Throwable t) {
throw new OMException(t);
}
//Second convert the String into a list or array
if (getTypeEnabledObject(jaxb) instanceof String) {
QName qName = XMLRootElementUtil.getXmlRootElementQNameFromObject(jaxb);
Object obj = XSDListUtils.fromXSDListString((String) getTypeEnabledObject(jaxb), type);
return new JAXBElement(qName, type, obj);
} else {
return jaxb;
}
}
/**
* Return type enabled object
*
* @param obj type or element enabled object
* @return type enabled object
*/
static Object getTypeEnabledObject(Object obj) {
if (obj == null) {
return null;
}
if (obj instanceof JAXBElement) {
return ((JAXBElement) obj).getValue();
}
return obj;
}
/**
* Marshal objects by type
*
* @param b Object that can be rendered as an element, but the element name is not known to the
* schema (i.e. rpc)
* @param m Marshaller
* @param writer XMLStreamWriter
* @param type
*/
private static void marshalByType(final Object b, final Marshaller m,
final XMLStreamWriter writer, final Class type,
final boolean isList, final JAXBUtils.CONSTRUCTION_TYPE ctype)
throws WebServiceException {
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
try {
// NOTE
// Example:
// <xsd:simpleType name="LongList">
// <xsd:list>
// <xsd:simpleType>
// <xsd:restriction base="xsd:unsignedInt"/>
// </xsd:simpleType>
// </xsd:list>
// </xsd:simpleType>
// <element name="myLong" nillable="true" type="impl:LongList"/>
//
// LongList will be represented as an int[]
// On the wire myLong will be represented as a list of integers
// with intervening whitespace
// <myLong>1 2 3</myLong>
//
// Unfortunately, we are trying to marshal by type. Therefore
// we want to marshal an element (foo) that is unknown to schema.
// If we use the normal marshal code, the wire will look like
// this (which is incorrect):
// <foo><item>1</item><item>2</item><item>3</item></foo>
//
// The solution is to detect this situation and marshal the
// String instead. Then we get the correct wire format:
// <foo>1 2 3</foo>
Object jbo = b;
if (isList) {
if (DEBUG_ENABLED) {
log.debug("marshalling type which is a List or Array");
}
// This code assumes that the JAXBContext does not understand
// the array or list. In such cases, the contents are converted
// to a String and passed directly.
if (ctype == JAXBUtils.CONSTRUCTION_TYPE.BY_CONTEXT_PATH) {
QName qName = XMLRootElementUtil.getXmlRootElementQNameFromObject(b);
String text = XSDListUtils.toXSDListString(getTypeEnabledObject(b));
if (DEBUG_ENABLED) {
log.debug("marshalling [context path approach] " +
"with xmllist text = " + text);
}
jbo = new JAXBElement(qName, String.class, text);
} else if (ctype == JAXBUtils.CONSTRUCTION_TYPE.BY_CLASS_ARRAY) {
// Some versions of JAXB have array/list processing built in.
// This code is a safeguard because apparently some versions
// of JAXB don't.
QName qName = XMLRootElementUtil.getXmlRootElementQNameFromObject(b);
String text = XSDListUtils.toXSDListString(getTypeEnabledObject(b));
if (DEBUG_ENABLED) {
log.debug("marshalling [class array approach] " +
"with xmllist text = " + text);
}
jbo = new JAXBElement(qName, String.class, text);
}
}
// When JAXBContext is created using a context path, it will not include Enum
// classes.
// These classes have @XmlEnum annotation but not @XmlType/@XmlElement, so the
// user will see MarshallingEx, class not known to ctxt.
//
// This is a jax-b defect, for now this fix is in place to pass CTS. This only
// fixes the
// situation where the enum is the top-level object (e.g., message-part in
// rpc-lit scenario)
//
// Sample of what enum looks like:
// @XmlEnum public enum EnumString {
// @XmlEnumValue("String1") STRING_1("String1"),
// @XmlEnumValue("String2") STRING_2("String2");
// ... }
if (type.isEnum()) {
if (b != null) {
if (DEBUG_ENABLED) {
log.debug("marshalByType. Marshaling " + type.getName()
+ " as Enum");
}
JAXBElement jbe = (JAXBElement) b;
String value = XMLRootElementUtil.getEnumValue((Enum) jbe.getValue());
jbo = new JAXBElement(jbe.getName(), String.class, value);
}
}
if (DEBUG_ENABLED) {
log.debug("Invoking marshalByType. " +
"Marshaling to an XMLStreamWriter. Object is "
+ getDebugName(b));
}
/// TODO
// For the cases like enum and list, should we
// intercept exceptions and try a different approach ?
m.marshal(jbo, writer);
} catch (OMException e) {
throw e;
} catch (Throwable t) {
throw new OMException(t);
}
return null;
}
});
}
/**
* Preferred way to unmarshal objects
*
* @param u Unmarshaller
* @param reader XMLStreamReader
* @return Object that represents an element
* @throws WebServiceException
*/
public static Object unmarshalByElement(final Unmarshaller u, final XMLStreamReader reader)
throws WebServiceException {
try {
if (DEBUG_ENABLED) {
log.debug("Invoking unMarshalByElement");
}
return AccessController.doPrivileged(new PrivilegedAction() {
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);
}
}
}