Axis 2 example source code file (MessageFactory.java)

This example Axis 2 source code file (MessageFactory.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Axis 2 tags/keywords

default_message_factory, exception, inputstream, io, ioexception, message_factory_property, message_factory_property, messagefactory, messagefactory, soap, soapexception, soapexception, soapmessage, string, string

The Axis 2 MessageFactory.java source code

/*
 * 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 javax.xml.soap;

import java.io.IOException;
import java.io.InputStream;

/**
 * <P>A factory for creating SOAPMessage objects.

 * <p/>
 * <P>A JAXM client performs the following steps to create a message.

 * <p/>
 * <UL> 
 Creates a MessageFactory object from a  ProviderConnection
 * object (<CODE>con in the following line of code). The String passed to the
 * <CODE>createMessageFactory method is the name of of a messaging profile, which must be the
 * URL for the schema. <PRE> MessageFactory mf = con.createMessageFactory(schemaURL); 

* <p/> * <LI> Calls the method createMessage on the MessageFactory object. All * messages produced by this <CODE>MessageFactory object will have the header information * appropriate for the messaging profile that was specified when the <CODE>MessageFactory * object was created. <PRE> SOAPMessage m = mf.createMessage(); It is also * possible to create a <CODE>MessageFactory object using the method * <CODE>newInstance, as shown in the following line of code.

 MessageFactory mf =
 * MessageFactory.newInstance(); </PRE> A standalone client (a client that is not running in a
 * container) can use the <CODE>newInstance method to create a MessageFactory
 * object.
 * <p/>
 * <P>All MessageFactory objects, regardless of how they are created, will produce
 * <CODE>SOAPMessage objects that have the following elements by default:

 * <p/>
 * <UL> 
A SOAPPart object
 * <p/>
 * <LI>A SOAPEnvelope object
 * <p/>
 * <LI>A SOAPBody object
 * <p/>
 * <LI>A SOAPHeader object  If a MessageFactory object was
 * created using a <CODE>ProviderConnection 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 object and the SOAPBody object. The content of a new
 * <CODE>SOAPMessage object depends on which of the two MessageFactory methods
 * is used to create it.
 * <p/>
 * <UL> 
createMessage() -- message has no content
 This is the method clients
 * would normally use to create a request message.</LI>
 * <p/>
 * <LI>createMessage(MimeHeaders, java.io.InputStream) -- message has content from the
 * <CODE>InputStream object and headers from the  MimeHeaders object
 This
 * method can be used internally by a service implementation to create a message that is a response
 * to a request.</LI> 
 */
public abstract class MessageFactory {

    /** Create a new MessageFactory. */
    public MessageFactory() {
    }

    /**
     * Creates a new <CODE>MessageFactory object that is an instance of the default
     * implementation.
     *
     * @return a new <CODE>MessageFactory object
     * @throws SOAPException if there was an error in creating the default implementation of the
     *                       <CODE> MessageFactory
     */
    public static MessageFactory newInstance() throws SOAPException {

        try {
            return (MessageFactory)FactoryFinder.find(
                    MESSAGE_FACTORY_PROPERTY,
                    DEFAULT_MESSAGE_FACTORY);
        } catch (Exception exception) {
            throw new SOAPException("Unable to create message factory for SOAP: "
                    + exception.getMessage());
        }
    }

    /**
     * Creates a new <CODE>SOAPMessage object with the default SOAPPart,
     * <CODE>SOAPEnvelope, SOAPBody, and SOAPHeader objects.
     * Profile-specific message factories can choose to prepopulate the <CODE>SOAPMessage
     * object with profile-specific headers.
     * <p/>
     * <P>Content can be added to this message's  SOAPPart object, and the message can
     * be sent "as is" when a message containing only a SOAP part is sufficient. Otherwise, the
     * <CODE>SOAPMessage object needs to create one or more AttachmentPart
     * objects and add them to itself. Any content that is not in XML format must be in an
     * <CODE>AttachmentPart object.

     *
     * @return a new <CODE>SOAPMessage object
     * @throws SOAPException if a SOAP error occurs java.lang.UnsupportedOperationException - if the
     *                       protocol of this MessageFactory instance is DYNAMIC_SOAP_PROTOCOL
     */
    public abstract SOAPMessage createMessage() throws SOAPException;

    /**
     * Internalizes the contents of the given <CODE> InputStream object into a new
     * <CODE>SOAPMessage object and returns the SOAPMessage 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 object that contains the data for a message
     * @return a new <CODE>SOAPMessage object containing the data from the given
     *         <CODE>InputStream object
     * @throws IOException   if there is a problem in reading data from the input stream
     * @throws SOAPException if the message is invalid
     */
    public abstract SOAPMessage createMessage(MimeHeaders mimeheaders,
                                              InputStream inputstream)
            throws IOException, SOAPException;

    public static MessageFactory newInstance(String soapVersion)
            throws SOAPException {
        return SAAJMetaFactory.getInstance().newMessageFactory(soapVersion);
    }

    private static final String DEFAULT_MESSAGE_FACTORY =
            "org.apache.axis2.saaj.MessageFactoryImpl";

    private static final String MESSAGE_FACTORY_PROPERTY =
            "javax.xml.soap.MessageFactory";
}