MessageFactoryImpl.java

/*
 * 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.saaj;

import org.apache.axiom.om.OMAbstractFactory;
import org.apache.axiom.om.OMMetaFactory;
import org.apache.axiom.soap.SOAPEnvelope;
import org.w3c.dom.Element;

import javax.xml.soap.MessageFactory;
import javax.xml.soap.MimeHeaders;
import javax.xml.soap.SOAPConstants;
import javax.xml.soap.SOAPException;
import javax.xml.soap.SOAPMessage;
import java.io.IOException;
import java.io.InputStream;

/**
 * <P>A factory for creating <CODE>SOAPMessage</CODE> objects.</P>
 * <p/>
 * <P>A JAXM client performs the following steps to create a message.</P>
 * <p/>
 * <UL> <LI> Creates a <CODE>MessageFactory</CODE> object from a <CODE> ProviderConnection</CODE>
 * object (<CODE>con</CODE> in the following line of code). The <CODE>String</CODE> passed to the
 * <CODE>createMessageFactory</CODE> method is the name of of a messaging profile, which must be the
 * URL for the schema. <PRE> MessageFactory mf = con.createMessageFactory(schemaURL); </PRE> </LI>
 * <p/>
 * <LI> Calls the method <CODE>createMessage</CODE> on the <CODE> MessageFactory</CODE> object. All
 * messages produced by this <CODE>MessageFactory</CODE> object will have the header information
 * appropriate for the messaging profile that was specified when the <CODE>MessageFactory</CODE>
 * object was created. <PRE> SOAPMessage m = mf.createMessage(); </PRE> </LI> </UL> It is also
 * possible to create a <CODE>MessageFactory</CODE> object using the method
 * <CODE>newInstance</CODE>, as shown in the following line of code. <PRE> MessageFactory mf =
 * MessageFactory.newInstance(); </PRE> A standalone client (a client that is not running in a
 * container) can use the <CODE>newInstance</CODE> method to create a <CODE>MessageFactory</CODE>
 * object.
 * <p/>
 * <P>All <CODE>MessageFactory</CODE> objects, regardless of how they are created, will produce
 * <CODE>SOAPMessage</CODE> objects that have the following elements by default:</P>
 * <p/>
 * <UL> <LI>A <CODE>SOAPPart</CODE> object</LI>
 * <p/>
 * <LI>A <CODE>SOAPEnvelope</CODE> object</LI>
 * <p/>
 * <LI>A <CODE>SOAPBody</CODE> object</LI>
 * <p/>
 * <LI>A <CODE>SOAPHeader</CODE> object</LI> </UL> If a <CODE>MessageFactory</CODE> object was
 * created using a <CODE>ProviderConnection</CODE> object, which means that it was initialized with
 * a specified profile, it will produce messages that also come prepopulated with additional entries
 * in the <CODE>SOAPHeader</CODE> object and the <CODE>SOAPBody</CODE> object. The content of a new
 * <CODE>SOAPMessage</CODE> object depends on which of the two <CODE>MessageFactory</CODE> methods
 * is used to create it.
 * <p/>
 * <UL> <LI><CODE>createMessage()</CODE> -- message has no content<BR> This is the method clients
 * would normally use to create a request message.</LI>
 * <p/>
 * <LI><CODE>createMessage(MimeHeaders, java.io.InputStream)</CODE> -- message has content from the
 * <CODE>InputStream</CODE> object and headers from the <CODE> MimeHeaders</CODE> object<BR> This
 * method can be used internally by a service implementation to create a message that is a response
 * to a request.</LI> </UL>
 */
public class MessageFactoryImpl extends MessageFactory {

    protected String soapVersion = SOAPConstants.SOAP_1_1_PROTOCOL;
    private boolean processMTOM;

    /**
     * Creates a new <CODE>SOAPMessage</CODE> object with the default <CODE>SOAPPart</CODE>,
     * <CODE>SOAPEnvelope</CODE>, <CODE>SOAPBody</CODE>, and <CODE>SOAPHeader</CODE> objects.
     * Profile-specific message factories can choose to prepopulate the <CODE>SOAPMessage</CODE>
     * object with profile-specific headers.
     * <p/>
     * <P>Content can be added to this message's <CODE> SOAPPart</CODE> object, and the message can
     * be sent "as is" when a message containing only a SOAP part is sufficient. Otherwise, the
     * <CODE>SOAPMessage</CODE> object needs to create one or more <CODE>AttachmentPart</CODE>
     * objects and add them to itself. Any content that is not in XML format must be in an
     * <CODE>AttachmentPart</CODE> object.</P>
     *
     * @return a new <CODE>SOAPMessage</CODE> object
     * @throws SOAPException if a SOAP error occurs java.lang.UnsupportedOperationException - if the
     *                       protocol of this MessageFactory instance is DYNAMIC_SOAP_PROTOCOL
     */
    public SOAPMessage createMessage() throws SOAPException {
        OMMetaFactory metaFactory = OMAbstractFactory.getMetaFactory(OMAbstractFactory.FEATURE_DOM);
        SOAPEnvelope soapEnvelope;
        if (soapVersion.equals(SOAPConstants.SOAP_1_2_PROTOCOL)) {
            soapEnvelope = metaFactory.getSOAP12Factory().getDefaultEnvelope();
        } else if (soapVersion.equals(SOAPConstants.DYNAMIC_SOAP_PROTOCOL)) {
            throw new UnsupportedOperationException("createMessage() is not supported for " +
                    "DYNAMIC_SOAP_PROTOCOL");
        } else {
            //SOAP 1.1
            soapEnvelope = metaFactory.getSOAP11Factory().getDefaultEnvelope();
        }
        Element domSoapEnvelope = (Element)soapEnvelope;
        domSoapEnvelope.getOwnerDocument().appendChild(domSoapEnvelope);
        SOAPMessageImpl soapMessage = new SOAPMessageImpl(new SOAPEnvelopeImpl(soapEnvelope));
        soapMessage.setSaveRequired();
        return soapMessage;
    }

    /**
     * Internalizes the contents of the given <CODE> InputStream</CODE> object into a new
     * <CODE>SOAPMessage</CODE> object and returns the <CODE>SOAPMessage</CODE> object.
     *
     * @param mimeheaders the transport-specific headers passed to the message in a
     *                    transport-independent fashion for creation of the message
     * @param inputstream the <CODE>InputStream</CODE> object that contains the data for a message
     * @return a new <CODE>SOAPMessage</CODE> object containing the data from the given
     *         <CODE>InputStream</CODE> object
     * @throws IOException   if there is a problem in reading data from the input stream
     * @throws SOAPException if the message is invalid
     */
    public SOAPMessage createMessage(MimeHeaders mimeheaders,
                                     InputStream inputstream) throws IOException, SOAPException {
        SOAPMessageImpl soapMessage = new SOAPMessageImpl(inputstream, mimeheaders, processMTOM);
        soapMessage.setSaveRequired();
        return soapMessage;
    }

    public void setSOAPVersion(String soapVersion) {
        this.soapVersion = soapVersion;
    }

    /**
     * Specify whether MTOM messages should be processed or parsed literally.
     * <p>
     * The way MTOM messages are handled fundamentally differs between Axiom and SAAJ.
     * While Axiom replaces xop:Include elements by {@link javax.activation.DataHandler} backed
     * {@link org.apache.axiom.om.OMText} nodes, there is no such requirement in SAAJ. The only
     * requirement there is that {@link SOAPMessage#getAttachment(javax.xml.soap.SOAPElement)}
     * returns the relevant {@link javax.xml.soap.AttachmentPart} when applied to an
     * xop:Include element.
     * <p>
     * This method allows to make this SAAJ implementation behave as Axiom, i.e. to substitute
     * xop:Include elements.
     * 
     * @param processMTOM whether xop:Include elements should be substituted
     */
    public void setProcessMTOM(boolean processMTOM) {
        this.processMTOM = processMTOM;
    }
}