Java tutorial
/* * 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.jaxws.marshaller.impl.alt; import org.apache.axis2.AxisFault; import org.apache.axis2.description.AxisOperation; import org.apache.axis2.description.AxisService; import org.apache.axis2.description.Parameter; import org.apache.axis2.java.security.AccessController; import org.apache.axis2.jaxws.Constants; import org.apache.axis2.jaxws.ExceptionFactory; import org.apache.axis2.jaxws.core.MessageContext; import org.apache.axis2.jaxws.description.AttachmentDescription; import org.apache.axis2.jaxws.description.AttachmentType; import org.apache.axis2.jaxws.description.EndpointDescription; import org.apache.axis2.jaxws.description.FaultDescription; import org.apache.axis2.jaxws.description.OperationDescription; import org.apache.axis2.jaxws.description.ParameterDescription; import org.apache.axis2.jaxws.description.ServiceDescription; import org.apache.axis2.jaxws.i18n.Messages; import org.apache.axis2.jaxws.marshaller.impl.alt.Element; import org.apache.axis2.jaxws.message.Block; import org.apache.axis2.jaxws.message.Message; import org.apache.axis2.jaxws.message.Protocol; import org.apache.axis2.jaxws.message.XMLFault; import org.apache.axis2.jaxws.message.XMLFaultReason; import org.apache.axis2.jaxws.message.databinding.JAXBBlockContext; import org.apache.axis2.jaxws.message.databinding.JAXBUtils; import org.apache.axis2.jaxws.message.factory.JAXBBlockFactory; import org.apache.axis2.jaxws.message.util.XMLFaultUtils; import org.apache.axis2.jaxws.registry.FactoryRegistry; import org.apache.axis2.jaxws.runtime.description.marshal.AnnotationDesc; import org.apache.axis2.jaxws.runtime.description.marshal.FaultBeanDesc; import org.apache.axis2.jaxws.runtime.description.marshal.MarshalServiceRuntimeDescription; import org.apache.axis2.jaxws.runtime.description.marshal.MarshalServiceRuntimeDescriptionFactory; import org.apache.axis2.jaxws.utility.ClassUtils; import org.apache.axis2.jaxws.utility.ConvertUtils; import org.apache.axis2.jaxws.utility.SAAJFactory; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import javax.activation.DataHandler; import javax.jws.WebParam.Mode; import javax.jws.WebService; import javax.xml.bind.JAXBElement; import javax.xml.namespace.QName; import javax.xml.soap.SOAPBody; import javax.xml.soap.SOAPConstants; import javax.xml.soap.SOAPFault; import javax.xml.stream.XMLStreamException; import javax.xml.ws.AsyncHandler; import javax.xml.ws.Holder; import javax.xml.ws.ProtocolException; import javax.xml.ws.WebServiceException; import javax.xml.ws.soap.SOAPFaultException; import java.io.IOException; import java.lang.reflect.Array; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.math.BigDecimal; import java.math.BigInteger; import java.security.PrivilegedActionException; import java.security.PrivilegedExceptionAction; import java.util.ArrayList; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; import java.util.List; import java.util.Map; import java.util.TreeSet; /** Static Utilty Classes used by the MethodMarshaller implementations in the alt package. */ public class MethodMarshallerUtils { private static Log log = LogFactory.getLog(MethodMarshallerUtils.class); private static JAXBBlockFactory factory = (JAXBBlockFactory) FactoryRegistry.getFactory(JAXBBlockFactory.class); /** Intentionally Private. This is a static utility class */ private MethodMarshallerUtils() { } /** * Returns the list of PDElements that need to be marshalled onto the wire * * @param marshalDesc * @param params ParameterDescription for this operation * @param sigArguments arguments * @param isInput indicates if input or output params(input args on client, * output args on server) * @param isDocLitWrapped * @param isRPC * @return PDElements */ static List<PDElement> getPDElements(MarshalServiceRuntimeDescription marshalDesc, ParameterDescription[] params, Object[] sigArguments, boolean isInput, boolean isDocLitWrapped, boolean isRPC) { List<PDElement> pdeList = new ArrayList<PDElement>(); int index = 0; for (int i = 0; i < params.length; i++) { ParameterDescription pd = params[i]; if (pd.getMode() == Mode.IN && isInput || pd.getMode() == Mode.INOUT || pd.getMode() == Mode.OUT && !isInput) { // Get the matching signature argument Object value = sigArguments[i]; // Don't consider async handlers, they are are not represented on the wire, // thus they don't have a PDElement if (isAsyncHandler(value)) { continue; } // Convert from Holder into value if (isHolder(value)) { value = ((Holder) value).value; } // Get the formal type representing the value Class formalType = pd.getParameterActualType(); // The namespace and local name are obtained differently depending on // the style/use and header QName qName = null; if (pd.isHeader()) { // Headers (even rpc) are marshalled with the name defined by the // element= attribute on the wsd:part qName = new QName(pd.getTargetNamespace(), pd.getParameterName()); } else if (isDocLitWrapped) { // For doc/lit wrapped, the localName comes from the PartName qName = new QName(pd.getTargetNamespace(), pd.getPartName()); } else if (isRPC) { // Per WSI-BP, the namespace uri is unqualified qName = new QName(pd.getPartName()); } else { qName = new QName(pd.getTargetNamespace(), pd.getParameterName()); } // Create an Element rendering Element element = null; AttachmentDescription attachmentDesc = pd.getAttachmentDescription(); if (attachmentDesc != null) { PDElement pde = createPDElementForAttachment(pd, qName, value, formalType); pdeList.add(pde); } else { if (!marshalDesc.getAnnotationDesc(formalType).hasXmlRootElement()) { /* when a schema defines a SimpleType with xsd list jaxws tooling * generates artifacts with array rather than a java.util.List * However the ObjectFactory definition uses a List and thus * marshalling fails. Lets convert the Arrays to List and recreate * the JAXBElements for the same. */ if (pd.isListType()) { List<Object> list = new ArrayList<Object>(); if (formalType.isArray()) { for (int count = 0; count < Array.getLength(value); count++) { Object obj = Array.get(value, count); list.add(obj); } } element = new Element(list, qName, List.class); } else { element = new Element(value, qName, formalType); } } else { element = new Element(value, qName); } // The object is now ready for marshalling PDElement pde = new PDElement(pd, element, null); pdeList.add(pde); } } } return pdeList; } /** * @param pd * @param qName * @param value * @param formalType * @return */ private static PDElement createPDElementForAttachment(ParameterDescription pd, QName qName, Object value, Class formalType) { PDElement pde; if (log.isDebugEnabled()) { log.debug("Creating a PDElement for an attachment value: " + ((value == null) ? "null" : value.getClass().getName())); log.debug("ParameterDescription = " + pd.toString()); } AttachmentDescription attachmentDesc = pd.getAttachmentDescription(); AttachmentType attachmentType = attachmentDesc.getAttachmentType(); if (attachmentType == AttachmentType.SWA) { // Create an Attachment object with the signature value Attachment attachment = new Attachment(value, formalType, attachmentDesc, pd.getPartName()); pde = new PDElement(pd, null, // For SWA Attachments, there is no element reference to the attachment null, attachment); } else { throw ExceptionFactory.makeWebServiceException(Messages.getMessage("pdElementErr")); } return pde; } /** * Return the list of PDElements that is unmarshalled from the wire * * @param params ParameterDescription for this operation * @param message Message * @param packages set of packages needed to unmarshal objects for this operation * @param isInput indicates if input or output params (input on server, output on client) * @param hasReturnInBody if isInput=false, then this parameter indicates whether a * return value is expected in the body. * @param unmarshalByJavaType in most scenarios this is null. * Only use this in the scenarios that require unmarshalling by java type * @see getPDElementsWithMissingElements * @return ParamValues */ static List<PDElement> getPDElements(ParameterDescription[] params, Message message, TreeSet<String> packages, boolean isInput, boolean hasReturnInBody, Class[] unmarshalByJavaType) throws XMLStreamException { List<PDElement> pdeList = new ArrayList<PDElement>(); // Count int totalBodyBlocks = 0; for (int i = 0; i < params.length; i++) { ParameterDescription pd = params[i]; if (pd.getMode() == Mode.IN && isInput || pd.getMode() == Mode.INOUT || pd.getMode() == Mode.OUT && !isInput) { if (!pd.isHeader() && !isSWAAttachment(pd)) { totalBodyBlocks++; } } } if (!isInput && hasReturnInBody) { totalBodyBlocks++; } int index = (!isInput && hasReturnInBody) ? 1 : 0; // TODO What if return is an swa attachment, then this should start // at 1 not 0. int swaIndex = 0; for (int i = 0; i < params.length; i++) { ParameterDescription pd = params[i]; if (pd.getMode() == Mode.IN && isInput || pd.getMode() == Mode.INOUT || pd.getMode() == Mode.OUT && !isInput) { // Don't consider async handlers, they are are not represented on the wire, // thus they don't have a PDElement // TODO //if (isAsyncHandler(param)) { // continue; //} Block block = null; JAXBBlockContext context = new JAXBBlockContext(packages); AttachmentDescription attachmentDesc = pd.getAttachmentDescription(); if (attachmentDesc == null) { // Normal Processing: Not an Attachment // Trigger unmarshal by java type if necessary if (unmarshalByJavaType != null && unmarshalByJavaType[i] != null) { context.setProcessType(unmarshalByJavaType[i]); context.setIsxmlList(pd.isListType()); } boolean consume = true; // Unmarshal the object into a JAXB object or JAXBElement if (pd.isHeader()) { // Get the Block from the header // NOTE The parameter name is always used to get the header // element...even if the style is RPC. String localName = pd.getParameterName(); block = message.getHeaderBlock(pd.getTargetNamespace(), localName, context, factory); consume = false; } else { if (totalBodyBlocks > 1) { // You must use this method if there are more than one body block // This method may cause OM expansion block = message.getBodyBlock(index, context, factory); } else { // Use this method if you know there is only one body block. // This method prevents OM expansion. block = message.getBodyBlock(context, factory); } index++; } Element element; if (block != null) { element = new Element(block.getBusinessObject(true), block.getQName()); } else { // The block could be null if the header is missing (which is allowed) QName qName = new QName(pd.getTargetNamespace(), pd.getParameterName()); if (log.isDebugEnabled()) { log.debug("There is no value in the incoming message for " + qName); } element = new Element(null, qName, pd.getParameterActualType()); } PDElement pde = new PDElement(pd, element, unmarshalByJavaType == null ? null : unmarshalByJavaType[i]); pdeList.add(pde); } else { // Attachment Processing if (attachmentDesc.getAttachmentType() == AttachmentType.SWA) { String partName = pd.getPartName(); String cid = null; if (log.isDebugEnabled()) { log.debug("Getting the attachment dataHandler for partName=" + partName); } if (partName != null && partName.length() > 0) { // Compliant WS-I behavior cid = message.getAttachmentID(partName); } if (cid == null) { if (log.isDebugEnabled()) { log.debug("Attachment dataHandler was not found. Fallback to use attachment " + swaIndex); } // Toleration mode for non-compliant attachment names cid = message.getAttachmentID(swaIndex); } DataHandler dh = message.getDataHandler(cid); Attachment attachment = new Attachment(dh, cid); PDElement pde = new PDElement(pd, null, null, attachment); pdeList.add(pde); swaIndex++; } else { throw ExceptionFactory.makeWebServiceException(Messages.getMessage("pdElementErr")); } } } } return pdeList; } /** * Creates the request signature arguments (server) from a list * of element enabled object (PDEements) * @param pds ParameterDescriptions for this Operation * @param pvList Element enabled object * @return Signature Args * @throws InstantiationException * @throws IllegalAccessException * @throws ClassNotFoundException */ static Object[] createRequestSignatureArgs(ParameterDescription[] pds, List<PDElement> pdeList) throws InstantiationException, IOException, IllegalAccessException, ClassNotFoundException { Object[] args = new Object[pds.length]; int pdeIndex = 0; for (int i = 0; i < args.length; i++) { // Get the paramValue PDElement pde = (pdeIndex < pdeList.size()) ? pdeList.get(pdeIndex) : null; ParameterDescription pd = pds[i]; if (pde == null || pde.getParam() != pd) { // We have a ParameterDesc but there is not an equivalent PDElement. // Provide the default if (pd.isHolderType()) { args[i] = createHolder(pd.getParameterType(), null); } else { args[i] = null; } } else { // We have a matching paramValue. Get the type object that represents the type Object value = null; if (pde.getAttachment() != null) { value = pde.getAttachment().getDataHandler(); } else { value = pde.getElement().getTypeValue(); } pdeIndex++; // Now that we have the type, there may be a mismatch // between the type (as defined by JAXB) and the formal // parameter (as defined by JAXWS). Frequently this occurs // with respect to T[] versus List<T>. // Use the convert utility to silently do any conversions if (ConvertUtils.isConvertable(value, pd.getParameterActualType())) { value = ConvertUtils.convert(value, pd.getParameterActualType()); } else { String objectClass = (value == null) ? "null" : value.getClass().getName(); throw ExceptionFactory.makeWebServiceException(Messages.getMessage("convertProblem", objectClass, pd.getParameterActualType().getName())); } // The signature may want a holder representation if (pd.isHolderType()) { args[i] = createHolder(pd.getParameterType(), value); } else { args[i] = value; } } } return args; } /** * Update the signature arguments on the client with the unmarshalled element enabled objects * (pvList) * * @param pds ParameterDescriptions * @param pdeList Element Enabled objects * @param signatureArgs Signature Arguments (the out/inout holders are updated) * @throws InstantiationException * @throws IllegalAccessException * @throws ClassNotFoundException */ static void updateResponseSignatureArgs(ParameterDescription[] pds, List<PDElement> pdeList, Object[] signatureArgs) throws InstantiationException, IllegalAccessException, ClassNotFoundException { int pdeIndex = 0; // Each ParameterDescriptor has a correspondinging signatureArg from the // the initial client call. The pvList contains the response values from the message. // Walk the ParameterDescriptor/SignatureArg list and populate the holders with // the match PDElement for (int i = 0; i < pds.length; i++) { // Get the param value PDElement pde = (pdeIndex < pdeList.size()) ? pdeList.get(pdeIndex) : null; ParameterDescription pd = pds[i]; if (pde != null && pde.getParam() == pd) { // We have a matching paramValue. Get the value that represents the type Object value = null; if (pde.getAttachment() == null) { value = pde.getElement().getTypeValue(); } else { value = pde.getAttachment().getDataHandler(); } pdeIndex++; // Now that we have the type, there may be a mismatch // between the type (as defined by JAXB) and the formal // parameter (as defined by JAXWS). Frequently this occurs // with respect to T[] versus List<T>. // Use the convert utility to silently do any conversions if (ConvertUtils.isConvertable(value, pd.getParameterActualType())) { value = ConvertUtils.convert(value, pd.getParameterActualType()); } else { String objectClass = (value == null) ? "null" : value.getClass().getName(); throw ExceptionFactory.makeWebServiceException(Messages.getMessage("convertProblem", objectClass, pd.getParameterActualType().getName())); } // TODO Assert that this ParameterDescriptor must represent // an OUT or INOUT and must have a non-null holder object to // store the value if (isHolder(signatureArgs[i])) { ((Holder) signatureArgs[i]).value = value; } } } } /** * Marshal the element enabled objects (pvList) to the Message * * @param pdeList element enabled objects * @param message Message * @param packages Packages needed to do a JAXB Marshal * @param contextProperties RequestContext or ResponseContext or null * @throws MessageException */ static void toMessage(List<PDElement> pdeList, Message message, TreeSet<String> packages, Map<String, Object> contextProperties) throws WebServiceException { int totalBodyBlocks = 0; for (int i = 0; i < pdeList.size(); i++) { PDElement pde = pdeList.get(i); if (!pde.getParam().isHeader() && pde.getElement() != null) { // Element is null for SWARef attachment totalBodyBlocks++; } } int index = message.getNumBodyBlocks(); for (int i = 0; i < pdeList.size(); i++) { PDElement pde = pdeList.get(i); // Create JAXBContext JAXBBlockContext context = new JAXBBlockContext(packages); Attachment attachment = pde.getAttachment(); if (attachment == null) { // Normal Flow: Not an attachment // Marshal by type only if necessary if (pde.getByJavaTypeClass() != null) { context.setProcessType(pde.getByJavaTypeClass()); if (pde.getParam() != null) { context.setIsxmlList(pde.getParam().isListType()); } } // Create a JAXBBlock out of the value. // (Note that the PDElement.getValue always returns an object // that has an element rendering...ie. it is either a JAXBElement or // has @XmlRootElement defined Block block = factory.createFrom(pde.getElement().getElementValue(), context, pde.getElement().getQName()); if (pde.getParam().isHeader()) { // Header block if (pde.getElement().getTypeValue() != null) { // The value is non-null, add a header. QName qname = block.getQName(); message.setHeaderBlock(qname.getNamespaceURI(), qname.getLocalPart(), block); } else { // The value is null, it is still best to add a nil header. // But query to see if an override is desired. if (isWriteWithNilHeader(contextProperties)) { QName qname = block.getQName(); message.setHeaderBlock(qname.getNamespaceURI(), qname.getLocalPart(), block); } } } else { // Body block if (totalBodyBlocks < 1) { // If there is only one block, use the following "more performant" method message.setBodyBlock(block); } else { message.setBodyBlock(index, block); } index++; } } else { // The parameter is an attachment AttachmentType type = pde.getParam().getAttachmentDescription().getAttachmentType(); if (type == AttachmentType.SWA) { // All we need to do is set the data handler on the message. // For SWA attachments, the message does not reference the attachment. message.addDataHandler(attachment.getDataHandler(), attachment.getContentID()); message.setDoingSWA(true); } else { throw ExceptionFactory.makeWebServiceException(Messages.getMessage("pdElementErr")); } } } } /** * @return Determine if a null header parameter should be written with a header * element containing nill (true) or whether the header element should * not be written at all (false) */ private static boolean isWriteWithNilHeader(Map<String, Object> map) { if (map == null) { if (log.isDebugEnabled()) { log.debug("Context Properties are not available. Return true "); } return true; } Object value = map.get(Constants.WRITE_HEADER_ELEMENT_IF_NULL); if (value == null) { if (log.isDebugEnabled()) { log.debug("Write header element with xsi:nil because the following property is not set " + Constants.WRITE_HEADER_ELEMENT_IF_NULL); } return true; } else { if (log.isDebugEnabled()) { log.debug("Key=" + Constants.WRITE_HEADER_ELEMENT_IF_NULL + " Value=" + value); } return ((Boolean) value).booleanValue(); } } /** * Marshals the return object to the message (used on server to marshal return object) * * @param returnElement element * @param returnType * @param marshalDesc * @param message * @param marshalByJavaTypeClass..we must do this for RPC...discouraged otherwise * @param isHeader * @throws MessageException */ static void toMessage(Element returnElement, Class returnType, boolean isList, MarshalServiceRuntimeDescription marshalDesc, Message message, Class marshalByJavaTypeClass, boolean isHeader) throws WebServiceException { // Create the JAXBBlockContext // RPC uses type marshalling, so recored the rpcType JAXBBlockContext context = new JAXBBlockContext(marshalDesc.getPackages()); if (marshalByJavaTypeClass != null) { context.setProcessType(marshalByJavaTypeClass); context.setIsxmlList(isList); } // Create a JAXBBlock out of the value. Block block = factory.createFrom(returnElement.getElementValue(), context, returnElement.getQName()); if (isHeader) { message.setHeaderBlock(returnElement.getQName().getNamespaceURI(), returnElement.getQName().getLocalPart(), block); } else { message.setBodyBlock(block); } } /** * Unmarshal the return object from the message * * @param packages * @param message * @param unmarshalByJavaTypeClass Used only to indicate unmarshaling by type...only necessary * in some scenarios * @param isHeader * @param headerNS (only needed if isHeader) * @param headerLocalPart (only needed if isHeader) * @param hasOutputBodyParams (true if the method has out or inout params other * than the return value) * @return Element * @throws WebService * @throws XMLStreamException */ static Element getReturnElement(TreeSet<String> packages, Message message, Class unmarshalByJavaTypeClass, // normally null boolean isList, boolean isHeader, String headerNS, String headerLocalPart, boolean hasOutputBodyParams) throws WebServiceException, XMLStreamException { // The return object is the first block in the body JAXBBlockContext context = new JAXBBlockContext(packages); if (unmarshalByJavaTypeClass != null && !isHeader) { context.setProcessType(unmarshalByJavaTypeClass); context.setIsxmlList(isList); } Block block = null; boolean isBody = false; if (isHeader) { block = message.getHeaderBlock(headerNS, headerLocalPart, context, factory); } else { if (hasOutputBodyParams) { block = message.getBodyBlock(0, context, factory); isBody = true; } else { // If there is only 1 block, we can use the get body block method // that streams the whole block content. block = message.getBodyBlock(context, factory); //We look for body block only when the return type associated with operation is not void. //If a null body block is returned in response on a operation that is not void, its a user error. isBody = true; } } //We look for body block only when the return type associated with operation is not void. //If a null body block is returned in response on a operation that has non void return type, its a user error. if (isBody && block == null) { if (log.isDebugEnabled()) { log.debug( "Empty Body Block Found in response Message for wsdl Operation defintion that expects an Output"); log.debug("Return type associated with SEI operation is not void, Body Block cannot be null"); } throw ExceptionFactory.makeWebServiceException(Messages.getMessage("MethodMarshallerUtilErr1")); } // Get the business object. We want to return the object that represents the type. Element returnElement = new Element(block.getBusinessObject(true), block.getQName()); return returnElement; } /** * Marshaling a fault is essentially the same for rpc/lit and doc/lit. This method is used by * all of the MethodMarshallers * * @param throwable Throwable to marshal * @param operationDesc OperationDescription * @param packages Packages needed to marshal the object * @param message Message */ static void marshalFaultResponse(Throwable throwable, MarshalServiceRuntimeDescription marshalDesc, OperationDescription operationDesc, Message message) { // Get the root cause of the throwable object Throwable t = ClassUtils.getRootCause(throwable); if (log.isDebugEnabled()) { log.debug("Marshal Throwable =" + throwable.getClass().getName()); log.debug(" rootCause =" + t.getClass().getName()); log.debug(" exception=" + t.toString()); log.debug(" stack=" + stackToString(t)); } XMLFault xmlfault = null; try { // There are 5 different categories of exceptions. // Each category has a little different marshaling code. // A) Service Exception that matches the JAX-WS // specification (chapter 2.5 of the spec) // B) Service Exception that matches the JAX-WS "legacy" // exception (chapter 3.7 of the spec) // C) SOAPFaultException // D) WebServiceException // E) Other runtime exceptions (i.e. NullPointerException) // Get the FaultDescriptor matching this Exception. // If FaultDescriptor is found, this is a JAX-B Service Exception. // If not found, this is a System Exception FaultDescription fd = operationDesc.resolveFaultByExceptionName(t.getClass().getCanonicalName()); if (fd != null) { if (log.isErrorEnabled()) { log.debug("Marshal as a Service Exception"); } // Create the JAXB Context JAXBBlockContext context = new JAXBBlockContext(marshalDesc.getPackages()); // The exception is a Service Exception. // It may be (A) JAX-WS compliant exception or // (B) JAX-WS legacy exception // The faultBeanObject is a JAXB object that represents the data of the exception. // It is marshalled in the detail section of the soap fault. // The faultBeanObject is obtained direction from the exception (A) or via // the legacy exception rules (B). Object faultBeanObject = null; FaultBeanDesc faultBeanDesc = marshalDesc.getFaultBeanDesc(fd); String faultInfo = fd.getFaultInfo(); if (faultInfo == null || faultInfo.length() == 0) { // Legacy Exception case faultBeanObject = LegacyExceptionUtil.createFaultBean(t, fd, marshalDesc); } else { // Normal case // Get the fault bean object. Method getFaultInfo = t.getClass().getMethod("getFaultInfo", null); faultBeanObject = getFaultInfo.invoke(t, null); } if (log.isErrorEnabled()) { log.debug("The faultBean type is" + faultBeanObject.getClass().getName()); } // Use "by java type" marshalling if necessary if (faultBeanObject == t || (context.getConstructionType() != JAXBUtils.CONSTRUCTION_TYPE.BY_CONTEXT_PATH && isNotJAXBRootElement(faultBeanObject.getClass(), marshalDesc))) { context.setProcessType(faultBeanObject.getClass()); } QName faultBeanQName = new QName(faultBeanDesc.getFaultBeanNamespace(), faultBeanDesc.getFaultBeanLocalName()); // Make sure the faultBeanObject can be marshalled as an element if (!marshalDesc.getAnnotationDesc(faultBeanObject.getClass()).hasXmlRootElement()) { faultBeanObject = new JAXBElement(faultBeanQName, faultBeanObject.getClass(), faultBeanObject); } // Create a detailblock representing the faultBeanObject Block[] detailBlocks = new Block[1]; detailBlocks[0] = factory.createFrom(faultBeanObject, context, faultBeanQName); if (log.isDebugEnabled()) { log.debug("Create the xmlFault for the Service Exception"); } // Get the fault text using algorithm defined in JAX-WS 10.2.2.3 String text = t.getMessage(); if (text == null || text.length() == 0) { text = t.toString(); } // Now make a XMLFault containing the detailblock xmlfault = new XMLFault(null, new XMLFaultReason(text), detailBlocks); } else { xmlfault = createXMLFaultFromSystemException(t); } } catch (Throwable e) { // If an exception occurs while demarshalling an exception, // then rinse and repeat with a system exception if (log.isDebugEnabled()) { log.debug("An exception (" + e + ") occurred while marshalling exception (" + t + ")"); } WebServiceException wse = ExceptionFactory.makeWebServiceException(e); xmlfault = createXMLFaultFromSystemException(wse); } // Add the fault to the message message.setXMLFault(xmlfault); } /** * This method is used by WebService Impl and Provider to create an XMLFault (for marshalling) * from an exception that is a non-service exception * * @param t Throwable that represents a Service Exception * @return XMLFault */ public static XMLFault createXMLFaultFromSystemException(Throwable t) { try { XMLFault xmlfault = null; if (t instanceof SOAPFaultException) { if (log.isErrorEnabled()) { log.debug("Marshal SOAPFaultException"); } // Category C: SOAPFaultException // Construct the xmlFault from the SOAPFaultException's Fault SOAPFaultException sfe = (SOAPFaultException) t; SOAPFault soapFault = sfe.getFault(); if (soapFault == null) { // No fault ? I will treat this like category E xmlfault = new XMLFault(null, // Use the default XMLFaultCode new XMLFaultReason(t.toString())); // Assumes text lang of current Locale } else { xmlfault = XMLFaultUtils.createXMLFault(soapFault); } } else if (t instanceof WebServiceException) { if (log.isErrorEnabled()) { log.debug("Marshal as a WebServiceException"); } // Category D: WebServiceException // The reason is constructed with the getMessage of the exception. // There is no detail WebServiceException wse = (WebServiceException) t; // Get the fault text using algorithm defined in JAX-WS 10.2.2.3 String text = wse.getMessage(); if (text == null || text.length() == 0) { text = wse.toString(); } xmlfault = new XMLFault(null, // Use the default XMLFaultCode new XMLFaultReason(text)); // Assumes text lang of current Locale } else { if (log.isErrorEnabled()) { log.debug("Marshal as a unchecked System Exception"); } // Category E: Other System Exception // The reason is constructed with the toString of the exception. // This places the class name of the exception in the reason // There is no detail. // Get the fault text using algorithm defined in JAX-WS 10.2.2.3 String text = t.getMessage(); if (text == null || text.length() == 0) { text = t.toString(); } xmlfault = new XMLFault(null, // Use the default XMLFaultCode new XMLFaultReason(text)); // Assumes text lang of current Locale } return xmlfault; } catch (Throwable e) { try { // If an exception occurs while demarshalling an exception, // then rinse and repeat with a webservice exception if (log.isDebugEnabled()) { log.debug("An exception (" + e + ") occurred while marshalling exception (" + t + ")"); } // Get the fault text using algorithm defined in JAX-WS 10.2.2.3 String text = e.getMessage(); if (text == null || text.length() == 0) { text = e.toString(); } WebServiceException wse = ExceptionFactory.makeWebServiceException(e); return new XMLFault(null, // Use the default XMLFaultCode new XMLFaultReason(text)); // Assumes text lang of current Locale } catch (Exception e2) { // Exception while creating Exception for Exception throw ExceptionFactory.makeWebServiceException(e2); } } } /** * Unmarshal the service/system exception from a Message. This is used by all of the * marshallers * * @param operationDesc * @param marshalDesc * @param message * @return Throwable * @throws WebServiceException * @throws ClassNotFoundException * @throws IllegalAccessException * @throws InstantiationException * @throws XMLStreamException * @throws InvocationTargetException * @throws NoSuchMethodException */ static Throwable demarshalFaultResponse(OperationDescription operationDesc, MarshalServiceRuntimeDescription marshalDesc, Message message) throws WebServiceException, ClassNotFoundException, IllegalAccessException, InstantiationException, XMLStreamException, InvocationTargetException, NoSuchMethodException { Throwable exception = null; // Get the fault from the message and get the detail blocks (probably one) XMLFault xmlfault = message.getXMLFault(); Block[] detailBlocks = xmlfault.getDetailBlocks(); // If there is only one block, get the element name of that block. QName elementQName = null; if (detailBlocks != null && detailBlocks.length >= 1) { elementQName = detailBlocks[0].getQName(); if (log.isDebugEnabled()) { if (detailBlocks.length > 1) { log.debug("The detail element has multiple child elements. " + "Only the first child is examined to determine if this is a service exception. " + "If this first detail child is mapped to a service exception, " + "the information in other detail children may be ignored. " + "The most common scenario is that the second child is a " + "{http://jax-ws.dev.java.net/}exception element, which is used " + "by some vendors for debugging. "); } } } if (log.isDebugEnabled()) { log.debug("element QName which will be used to find a service exception = " + elementQName); log.debug("XMLFault Dump = " + xmlfault.dump("")); log.debug("OperationDesc Dump =" + operationDesc); } // Use the element name to find the matching FaultDescriptor FaultDescription faultDesc = null; if (elementQName != null) { for (int i = 0; i < operationDesc.getFaultDescriptions().length && faultDesc == null; i++) { FaultDescription fd = operationDesc.getFaultDescriptions()[i]; FaultBeanDesc faultBeanDesc = marshalDesc.getFaultBeanDesc(fd); if (faultBeanDesc != null) { QName tryQName = new QName(faultBeanDesc.getFaultBeanNamespace(), faultBeanDesc.getFaultBeanLocalName()); if (log.isErrorEnabled()) { log.debug(" FaultDescription qname is (" + tryQName + ") and detail element qname is (" + elementQName + ")"); } if (elementQName.equals(tryQName)) { faultDesc = fd; } } } } if (faultDesc == null && elementQName != null) { // If not found, retry the search using just the local name for (int i = 0; i < operationDesc.getFaultDescriptions().length && faultDesc == null; i++) { FaultDescription fd = operationDesc.getFaultDescriptions()[i]; FaultBeanDesc faultBeanDesc = marshalDesc.getFaultBeanDesc(fd); if (faultBeanDesc != null) { String tryName = faultBeanDesc.getFaultBeanLocalName(); if (elementQName.getLocalPart().equals(tryName)) { faultDesc = fd; } } } } if (faultDesc == null) { // This is a system exception if the method does not throw a checked exception or if // the detail block is missing or contains multiple items. exception = createSystemException(xmlfault, message); } else { if (log.isErrorEnabled()) { log.debug("Ready to demarshal service exception. The detail entry name is " + elementQName); } FaultBeanDesc faultBeanDesc = marshalDesc.getFaultBeanDesc(faultDesc); boolean isLegacy = (faultDesc.getFaultInfo() == null || faultDesc.getFaultInfo().length() == 0); // Get the JAXB object from the block JAXBBlockContext blockContext = new JAXBBlockContext(marshalDesc.getPackages()); // Note that faultBean may not be a bean, it could be a primitive Class faultBeanFormalClass; try { faultBeanFormalClass = loadClass(faultBeanDesc.getFaultBeanClassName()); } catch (ClassNotFoundException e) { faultBeanFormalClass = loadClass(faultBeanDesc.getFaultBeanClassName(), operationDesc.getEndpointInterfaceDescription().getEndpointDescription().getAxisService() .getClassLoader()); } // Use "by java type" marshalling if necessary if (blockContext.getConstructionType() != JAXBUtils.CONSTRUCTION_TYPE.BY_CONTEXT_PATH && isNotJAXBRootElement(faultBeanFormalClass, marshalDesc)) { blockContext.setProcessType(faultBeanFormalClass); } // Get the jaxb block and business object Block jaxbBlock = factory.createFrom(detailBlocks[0], blockContext); Object faultBeanObject = jaxbBlock.getBusinessObject(true); // At this point, faultBeanObject is an object that can be rendered as an // element. We want the object that represents the type. if (faultBeanObject instanceof JAXBElement) { faultBeanObject = ((JAXBElement) faultBeanObject).getValue(); } if (log.isErrorEnabled()) { log.debug("Unmarshalled the detail element into a JAXB object"); } // Construct the JAX-WS generated exception that holds the faultBeanObject Class exceptionClass; try { exceptionClass = loadClass(faultDesc.getExceptionClassName()); } catch (ClassNotFoundException e) { exceptionClass = loadClass(faultDesc.getExceptionClassName(), operationDesc.getEndpointInterfaceDescription().getEndpointDescription().getAxisService() .getClassLoader()); } if (log.isErrorEnabled()) { log.debug("Found FaultDescription. The exception name is " + exceptionClass.getName()); } exception = createServiceException(xmlfault.getReason().getText(), exceptionClass, faultBeanObject, faultBeanFormalClass, marshalDesc, isLegacy); } return exception; } /** * @param pds * @return Number of inout or out parameters */ static int numOutputBodyParams(ParameterDescription[] pds) { int count = 0; for (int i = 0; i < pds.length; i++) { // TODO Need to change this to also detect not attachment if (!pds[i].isHeader()) { if (pds[i].getMode() == Mode.INOUT || pds[i].getMode() == Mode.OUT) { count++; } } } return count; } /** * @param value * @return if async handler */ static boolean isAsyncHandler(Object value) { return (value instanceof AsyncHandler); } /** * @param value * @return true if value is holder */ static boolean isHolder(Object value) { return value != null && Holder.class.isAssignableFrom(value.getClass()); } /** * Crate a Holder * * @param <T> * @param paramType * @param value * @return * @throws IllegalAccessException * @throws InstantiationException * @throws ClassNotFoundException */ static <T> Holder<T> createHolder(Class paramType, T value) throws IllegalAccessException, InstantiationException, ClassNotFoundException { if (Holder.class.isAssignableFrom(paramType)) { Holder holder = (Holder) paramType.newInstance(); holder.value = value; return holder; } return null; } /** * Load the class * * @param className * @return loaded class * @throws ClassNotFoundException */ static Class loadClass(String className) throws ClassNotFoundException { // Don't make this public, its a security exposure Class cls = ClassUtils.getPrimitiveClass(className); if (cls == null) { cls = forName(className, true, getContextClassLoader()); } return cls; } /** * Load the class * * @param className * @return loaded class * @throws ClassNotFoundException */ static Class loadClass(String className, ClassLoader cl) throws ClassNotFoundException { // Don't make this public, its a security exposure Class cls = ClassUtils.getPrimitiveClass(className); if (cls == null) { cls = forName(className, true, cl); } return cls; } /** * Return the class for this name * * @return Class */ private static Class forName(final String className, final boolean initialize, final ClassLoader classLoader) throws ClassNotFoundException { // NOTE: This method must remain private because it uses AccessController Class cl = null; try { cl = (Class) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws ClassNotFoundException { // Class.forName does not support primitives Class cls = ClassUtils.getPrimitiveClass(className); if (cls == null) { cls = Class.forName(className, initialize, classLoader); } return cls; } }); } catch (PrivilegedActionException e) { if (log.isDebugEnabled()) { log.debug("Exception thrown from AccessController: " + e); } throw (ClassNotFoundException) e.getException(); } return cl; } /** @return ClassLoader */ private static ClassLoader getContextClassLoader() { // NOTE: This method must remain private because it uses AccessController ClassLoader cl = null; try { cl = (ClassLoader) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws ClassNotFoundException { return Thread.currentThread().getContextClassLoader(); } }); } catch (PrivilegedActionException e) { if (log.isDebugEnabled()) { log.debug("Exception thrown from AccessController: " + e); } throw ExceptionFactory.makeWebServiceException(e.getException()); } return cl; } /** * Create a JAX-WS Service Exception (Generated Exception) * * @param message * @param exceptionclass * @param bean * @param beanFormalType * @return * @throws InvocationTargetException * @throws IllegalAccessException * @throws InstantiationException * @throws NoSuchMethodException * @parma marshalDesc is used to get cached information about the exception class and bean */ private static Exception createServiceException(String message, Class exceptionclass, Object bean, Class beanFormalType, MarshalServiceRuntimeDescription marshalDesc, boolean isLegacyException) throws InvocationTargetException, IllegalAccessException, InstantiationException, NoSuchMethodException { if (log.isDebugEnabled()) { log.debug("Constructing JAX-WS Exception:" + exceptionclass); } Exception exception = null; if (isLegacyException) { // Legacy Exception exception = LegacyExceptionUtil.createFaultException(exceptionclass, bean, marshalDesc); } else { // Normal case, use the contstructor to create the exception Constructor constructor = exceptionclass.getConstructor(new Class[] { String.class, beanFormalType }); exception = (Exception) constructor.newInstance(new Object[] { message, bean }); } return exception; } /** * Create a system exception * * @param message * @return */ public static ProtocolException createSystemException(XMLFault xmlFault, Message message) { ProtocolException e = null; Protocol protocol = message.getProtocol(); String text = xmlFault.getReason().getText(); if (protocol == Protocol.soap11 || protocol == Protocol.soap12) { // Throw a SOAPFaultException if (log.isDebugEnabled()) { log.debug("Constructing SOAPFaultException for " + text); } String protocolNS = (protocol == Protocol.soap11) ? SOAPConstants.URI_NS_SOAP_1_1_ENVELOPE : SOAPConstants.URI_NS_SOAP_1_2_ENVELOPE; try { // The following set of instructions is used to avoid // some unimplemented methods in the Axis2 SAAJ implementation javax.xml.soap.MessageFactory mf = SAAJFactory.createMessageFactory(protocolNS); SOAPBody body = mf.createMessage().getSOAPBody(); SOAPFault soapFault = XMLFaultUtils.createSAAJFault(xmlFault, body); e = new SOAPFaultException(soapFault); } catch (Exception ex) { // Exception occurred during exception processing. // TODO Probably should do something better here if (log.isDebugEnabled()) { log.debug("Exception occurred during fault processing:", ex); } e = ExceptionFactory.makeProtocolException(text, null); } } else if (protocol == Protocol.rest) { if (log.isDebugEnabled()) { log.debug("Constructing ProtocolException for " + text); } // TODO Is there an explicit exception for REST e = ExceptionFactory.makeProtocolException(text, null); } else if (protocol == Protocol.unknown) { // REVIEW What should happen if there is no protocol if (log.isDebugEnabled()) { log.debug("Constructing ProtocolException for " + text); } e = ExceptionFactory.makeProtocolException(text, null); } return e; } /** * @param ed * @return */ static MarshalServiceRuntimeDescription getMarshalDesc(EndpointDescription ed) { ServiceDescription sd = ed.getServiceDescription(); return MarshalServiceRuntimeDescriptionFactory.get(sd); } /** * This probably should be available from the ParameterDescription * * @param cls * @param marshalDesc * @return true if primitive, wrapper, java.lang.String. Calendar (or GregorianCalendar), * BigInteger etc or anything other java type that is mapped by the basic schema types */ static boolean isNotJAXBRootElement(Class cls, MarshalServiceRuntimeDescription marshalDesc) { if (cls == String.class || cls.isPrimitive() || cls == Calendar.class || cls == byte[].class || cls == GregorianCalendar.class || cls == Date.class || cls == BigInteger.class || cls == BigDecimal.class) { return true; } AnnotationDesc aDesc = marshalDesc.getAnnotationDesc(cls); if (aDesc != null) { // XmlRootElementName returns null if @XmlRootElement is not specified return (aDesc.getXmlRootElementName() == null); } return true; } /** * Get a string containing the stack of the specified exception * @param e * @return */ public static String stackToString(Throwable e) { java.io.StringWriter sw = new java.io.StringWriter(); java.io.BufferedWriter bw = new java.io.BufferedWriter(sw); java.io.PrintWriter pw = new java.io.PrintWriter(bw); e.printStackTrace(pw); pw.close(); return sw.getBuffer().toString(); } static boolean isSWAAttachment(ParameterDescription pd) { return pd.getAttachmentDescription() != null && pd.getAttachmentDescription().getAttachmentType() == AttachmentType.SWA; } /** * Register the unmarshalling information so that it can * be used to speed up subsequent marshalling events. * @param mc * @param packages * @param packagesKey */ static Parameter getUnmarshalInfoParameter(MessageContext mc) throws AxisFault { // The information is registered on the AxisOperation. if (mc == null || mc.getAxisMessageContext() == null || mc.getAxisMessageContext().getAxisService() == null || mc.getAxisMessageContext().getAxisOperation() == null) { return null; } // This needs to be stored on the AxisOperation as unmarshalling // info will be specific to a method and its parameters AxisOperation axisOp = mc.getAxisMessageContext().getAxisOperation(); Parameter param = axisOp.getParameter(UnmarshalInfo.KEY); return param; } /** * Register the unmarshalling information so that it can * be used to speed up subsequent marshalling events. * @param mc * @param packages * @param packagesKey */ static void registerUnmarshalInfo(MessageContext mc, TreeSet<String> packages, String packagesKey) throws AxisFault { // The information is registered on the AxisOperation. if (mc == null || mc.getAxisMessageContext() == null || mc.getAxisMessageContext().getAxisService() == null || mc.getAxisMessageContext().getAxisOperation() == null) { return; } // This needs to be stored on the AxisOperation as unmarshalling // info will be specific to a method and its parameters AxisOperation axisOp = mc.getAxisMessageContext().getAxisOperation(); // There are two things that need to be saved. // 1) The UnmarshalInfo object containing the packages // (which will be used by the CustomBuilder) // 2) A MessageContextListener which (when triggered) registers // the JAXBCustomBuilder Parameter param = axisOp.getParameter(UnmarshalInfo.KEY); if (param == null) { UnmarshalInfo info = new UnmarshalInfo(packages, packagesKey); axisOp.addParameter(UnmarshalInfo.KEY, info); param = axisOp.getParameter(UnmarshalInfo.KEY); param.setTransient(true); // Add a listener that will set the JAXBCustomBuilder UnmarshalMessageContextListener.create(mc.getAxisMessageContext().getServiceContext()); } } }