/*
* 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.OMElement;
import org.apache.axiom.om.OMException;
import org.apache.axiom.om.XOPEncoded;
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.context.utils.ContextUtils;
import org.apache.axis2.jaxws.message.OccurrenceArray;
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.axis2.jaxws.utility.XmlEnumUtils;
import org.apache.axis2.description.Parameter;
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.PropertyException;
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.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<String>();
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 {
return getJAXBContext(cl, false);
}
/**
* @param ClassLoader
* @param forceArrays boolean (if true, then JAXBContext will automatically contain arrays)
* @return get the JAXBContext
* @throws JAXBException
*/
public JAXBContext getJAXBContext(ClassLoader cl, boolean forceArrays) throws JAXBException {
if (customerJAXBContext != null) {
return customerJAXBContext;
}
// Get the weakly cached JAXBContext
JAXBContext jc = null;
if (autoJAXBContext != null) {
jc = autoJAXBContext.get();
}
if (forceArrays &&
jc != null &&
constructionType != JAXBUtils.CONSTRUCTION_TYPE.BY_CLASS_ARRAY_PLUS_ARRAYS) {
if (log.isDebugEnabled()) {
log.debug("A JAXBContext exists but it was not constructed with array class. " +
"The JAXBContext will be rebuilt.");
}
jc = null;
}
if (jc == null) {
if (log.isDebugEnabled()) {
log.debug("Creating a JAXBContext 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
* obscure 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, forceArrays,
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;
}
/**
* The procesess type to indicate the class of the target of the unmarshaling.
* This method should only be used in the cases where the element being unmarshaled
* is not known to the JAXBContext (examples include RPC/Literal processing
* and Doc/Literal Wrapped processing with a non-element wrapper class)
*
* @param type
*/
public void setProcessType(Class<?> type) {
if (log.isDebugEnabled()) {
log.debug("Process Type set to: " + type);
}
processType = type;
}
public JAXBUtils.CONSTRUCTION_TYPE getConstructionType() {
return constructionType;
}
public boolean isxmlList() {
return isxmlList;
}
public void setIsxmlList(boolean isxmlList) {
if (log.isDebugEnabled()) {
log.debug("isxmlListSet to " + 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) {
Parameter param = context.getParameter(Constants.CACHE_CLASSLOADER);
if (param != null) {
return (ClassLoader) param.getValue();
}
}
return null;
}
protected AttachmentContext createAttachmentContext() {
return new MessageContextAttachmentContext(getMessageContext());
}
/**
* Unmarshal the xml into a JAXB object
* @param element
* @return
* @throws JAXBException
*/
public Object unmarshal(OMElement element) throws JAXBException {
// See the Javadoc of the CustomBuilder interface for a complete explanation of
// the following two instructions:
XOPEncoded<XMLStreamReader> xopEncodedStream = element.getXOPEncodedStreamReader(false);
// 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 = new JAXBAttachmentUnmarshaller(createAttachmentContext(), xopEncodedStream.getAttachmentAccessor());
if (aum != null) {
if (DEBUG_ENABLED) {
log.debug("Adding JAXBAttachmentUnmarshaller to Unmarshaller");
}
u.setAttachmentUnmarshaller(aum);
}
Object jaxb = null;
// Unmarshal into the business object.
XMLStreamReader reader = xopEncodedStream.getRootPart();
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 {
if (log.isDebugEnabled()) {
log.debug("enter marshal");
}
// 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.
JAXBContext jbc = getJAXBContext(cl);
Marshaller m = JAXBUtils.getJAXBMarshaller(jbc);
if (writer instanceof MTOMXMLStreamWriter && ((MTOMXMLStreamWriter) writer).getOutputFormat() != null) {
String encoding = ((MTOMXMLStreamWriter) writer).getOutputFormat().getCharSetEncoding();
String marshallerEncoding = (String) m.getProperty(Marshaller.JAXB_ENCODING);
// Make sure that the marshaller respects the encoding of the message.
// This is accomplished by setting the encoding on the Marshaller's JAXB_ENCODING property.
if (encoding == null && marshallerEncoding == null) {
if (log.isDebugEnabled()) {
log.debug("The encoding and the marshaller's JAXB_ENCODING are both set to the default (UTF-8)");
}
} else {
// Must set the encoding to an actual String to set it on the Marshaller
if (encoding == null) {
encoding = "UTF-8";
}
if (!encoding.equalsIgnoreCase(marshallerEncoding)) {
if (log.isDebugEnabled()) {
log.debug("The Marshaller.JAXB_ENCODING is " + marshallerEncoding);
log.debug("The Marshaller.JAXB_ENCODING is changed to the message encoding " +
encoding);
}
m.setProperty(Marshaller.JAXB_ENCODING, encoding);
} else {
if (log.isDebugEnabled()) {
log.debug("The encoding and the marshaller's JAXB_ENCODING are both set to:" +
marshallerEncoding);
}
}
}
}
AttachmentMarshaller am = new JAXBAttachmentMarshaller(createAttachmentContext(), writer);
if (am != null) {
if (DEBUG_ENABLED) {
log.debug("Adding JAXBAttachmentMarshaller to Marshaller");
}
m.setAttachmentMarshaller(am);
}
MessageContext mc = getMessageContext();
// If requested install a filter to remove illegal characters
if (writer instanceof MTOMXMLStreamWriter && ContextUtils.isJAXBRemoveIllegalChars(mc)) {
writer = new XMLStreamWriterRemoveIllegalChars((MTOMXMLStreamWriter)writer);
}
// Marshal the object
if (getProcessType() == null) {
marshalByElement(obj,
m,
writer,
true);
//!am.isXOPPackage());
} else {
marshalByType(obj,
m,
writer,
getProcessType(),
isxmlList(),
getConstructionType(),
true); // Attempt to optimize by writing to OutputStream
}
JAXBUtils.releaseJAXBMarshaller(jbc, m);
if (log.isDebugEnabled()) {
log.debug("exit marshal");
}
}
/**
* 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<Void>() {
public Void 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,m) : 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;
}});
}
/**
* Print out the name of the class of the specified object
* @param o Object
* @return text to use for debugging
*/
private static String getDebugName(Object o) {
String name = (o == null) ? "null" : o.getClass().getCanonicalName();
if (o instanceof JAXBElement) {
name += " containing " + getDebugName(((JAXBElement<?>) o).getValue());
}
return name;
}
/**
* If the writer is backed by an OutputStream, then return the OutputStream
* @param writer
* @param Marshaller
* @return OutputStream or null
*/
private static OutputStream getOutputStream(XMLStreamWriter writer,
Marshaller m) throws XMLStreamException {
if (log.isDebugEnabled()) {
log.debug("XMLStreamWriter is " + writer);
}
OutputStream os = null;
if (writer instanceof MTOMXMLStreamWriter) {
os = ((MTOMXMLStreamWriter) writer).getOutputStream();
if (log.isDebugEnabled()) {
log.debug("OutputStream accessible from MTOMXMLStreamWriter is " + os);
}
}
if (writer instanceof XMLStreamWriterWithOS) {
os = ((XMLStreamWriterWithOS) writer).getOutputStream();
if (log.isDebugEnabled()) {
log.debug("OutputStream accessible from XMLStreamWriterWithOS is " + os);
}
}
if (os != null) {
String marshallerEncoding = null;
try {
marshallerEncoding = (String) m.getProperty(Marshaller.JAXB_ENCODING);
} catch (PropertyException e) {
if (DEBUG_ENABLED) {
log.debug("Could not query JAXB_ENCODING..Continuing. " + e);
}
}
if (marshallerEncoding != null && !marshallerEncoding.equalsIgnoreCase("UTF-8")) {
if (DEBUG_ENABLED) {
log.debug("Wrapping output stream to remove BOM");
}
os = new BOMOutputStreamFilter(marshallerEncoding, 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.");
log.debug(" type = " + type);
log.debug(" isList = " + isList);
log.debug(" ctype = "+ ctype);
}
return AccessController.doPrivileged(new PrivilegedAction<Object>() {
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) {
if (DEBUG_ENABLED) {
log.debug("Unmarshal Array via BY_CONTEXT_PATH approach");
}
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
//process primitives first
//first verify if we have a primitive type associated in the array.
//array could be single dimension or multi dimension.
Class<?> cType = type.getComponentType();
while(cType.isArray()){
cType = cType.getComponentType();
}
if(cType.isPrimitive()){
if (DEBUG_ENABLED) {
log.debug("Unmarshal Array of primitive via BY_CLASS_ARRAY approach");
}
jaxb = u.unmarshal(reader, type);
}
// process non primitive
// I will first unmarshall the xmldata to a String[]
// Then use the unmarshalled jaxbElement to create
// proper type Object Array.
else{
if (DEBUG_ENABLED) {
log.debug("Unmarshal Array of non-primitive via BY_CLASS_ARRAY approach");
}
jaxb = unmarshalArray(reader, u, type);
}
} else {
if (DEBUG_ENABLED) {
log.debug("Unmarshal Array");
}
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("Unmarshalling " + type.getName()
+ " as Enum");
}
JAXBElement<String> enumValue = u.unmarshal(reader, XmlEnumUtils.getConversionType(type));
if (enumValue != null) {
jaxb = XmlEnumUtils.fromValue(type, enumValue.getValue());
} else {
jaxb = null;
}
}
//Normal case: We are not unmarshalling a xsd:list or Array
else {
if (DEBUG_ENABLED) {
log.debug("Unmarshalling normal case (not array, not xsd:list, not enum)");
}
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
if (DEBUG_ENABLED) {
log.debug("Unmarshalling xsd:list");
}
jaxb = unmarshalAsListOrArray(reader, u, type);
}
if (log.isDebugEnabled()) {
if (jaxb == null) {
if (DEBUG_ENABLED) {
log.debug("End unmarshalByType returning null object");
}
} else if (jaxb instanceof JAXBElement) {
JAXBElement<?> jbe = (JAXBElement<?>) jaxb;
if (DEBUG_ENABLED) {
log.debug("End unmarshalByType returning JAXBElement");
log.debug(" Class = " + jbe.getDeclaredType());
log.debug(" QName = " + jbe.getName());
}
} else {
if (DEBUG_ENABLED) {
log.debug("End unmarshalByType returning " + jaxb.getClass());
}
}
}
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<Object>() {
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 unmarshalAsListOrArray");
}
// 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<Object>() {
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;
}
private static boolean isOccurrenceArray(Object obj) {
return (obj instanceof JAXBElement) &&
(((JAXBElement<?>)obj).getValue() instanceof OccurrenceArray);
}
/**
* 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 Class
* @param isList true if this is an XmlList
* @param ctype CONSTRUCTION_TYPE
* @param optimize boolean set to true if optimization directly to
* outputstream should be attempted.
*/
private void marshalByType(final Object b, final Marshaller m,
final XMLStreamWriter writer, final Class<?> type,
final boolean isList,
final JAXBUtils.CONSTRUCTION_TYPE ctype,
final boolean optimize)
throws WebServiceException {
if (log.isDebugEnabled()) {
log.debug("Enter marshalByType b=" + getDebugName(b) +
" type=" + type +
" marshaller=" + m +
" writer=" + writer +
" isList=" + isList +
" ctype=" + ctype +
" optimize=" + optimize);
}
if (isOccurrenceArray(b)) {
marshalOccurrenceArray((JAXBElement<?>) b, m, writer);
return;
}
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void 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(DEBUG_ENABLED){
log.debug("check if marshalling list or array object, type = "+ (( b!=null )? b.getClass().getName():"null"));
}
if (isList) {
if (DEBUG_ENABLED) {
log.debug("marshalling type which is a List");
}
// 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<String>(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<String>(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<String>(jbe.getName(), String.class, value);
}
}
// If the output stream is available, marshal directly to it
OutputStream os = (optimize) ? getOutputStream(writer, m) : null;
if (os == null){
if (DEBUG_ENABLED) {
log.debug("Invoking marshalByType. " +
"Marshaling to an XMLStreamWriter. Object is "
+ getDebugName(jbo));
}
m.marshal(jbo, writer);
} else {
if (DEBUG_ENABLED) {
log.debug("Invoking marshalByType. " +
"Marshaling to an OutputStream. Object is "
+ getDebugName(jbo));
}
m.marshal(jbo, os);
}
} catch (OMException e) {
throw e;
} catch (Throwable t) {
throw new OMException(t);
}
return null;
}
});
}
/**
* Marshal array objects by type
*
* Invoke marshalByType for each element in the array
*
* @param jaxb_in JAXBElement containing a value that is a List or array
* @param m_in Marshaller
* @param writer_in XMLStreamWriter
*/
private void marshalOccurrenceArray(
final JAXBElement<?> jbe_in,
final Marshaller m_in,
final XMLStreamWriter writer_in) {
if (log.isDebugEnabled()) {
log.debug("Enter marshalOccurrenceArray");
log.debug(" Marshaller = " + JavaUtils.getObjectIdentity(m_in));
}
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
try {
Marshaller m = m_in;
JAXBContext newJBC = null;
if (getConstructionType() != JAXBUtils.CONSTRUCTION_TYPE.BY_CLASS_ARRAY_PLUS_ARRAYS) {
// Rebuild JAXBContext
// There may be a preferred classloader that should be used
if (log.isDebugEnabled()) {
log.debug("Building a JAXBContext with array capability");
}
ClassLoader cl = getClassLoader();
newJBC = getJAXBContext(cl, true);
m = JAXBUtils.getJAXBMarshaller(newJBC);
if (log.isDebugEnabled()) {
log.debug("The new JAXBContext was constructed with " + getConstructionType());
}
}
OccurrenceArray occurArray = (OccurrenceArray) jbe_in.getValue();
// Create a new JAXBElement.
// The name is the name of the individual occurence elements
// Type type is Object[]
// The value is the array of Object[] representing each element
JAXBElement<Object[]> jbe = new JAXBElement<Object[]>(jbe_in.getName(),
Object[].class,
occurArray.getAsArray());
// The jaxb marshal command cannot write out a list/array
// of occurence elements. So we marshal it as a single
// element containing items...and then put a filter on the
// writer to transform it into a stream of occurence elements
XMLStreamWriterArrayFilter writer = new XMLStreamWriterArrayFilter(writer_in);
m.marshal(jbe, writer);
if (newJBC != null) {
JAXBUtils.releaseJAXBMarshaller(newJBC, m);
}
return null;
} catch (OMException e) {
throw e;
} catch (Throwable t) {
throw new OMException(t);
}
}
});
if (log.isDebugEnabled()) {
log.debug("Exit marshalOccurrenceArray");
}
}
/**
* 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<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);
}
}
}