Java tutorial
/* * Copyright 2001-2004 The Apache Software Foundation. * * Licensed 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.axis; import org.apache.axis.components.logger.LogFactory; import org.apache.axis.encoding.DeserializationContext; import org.apache.axis.encoding.SerializationContext; import org.apache.axis.message.InputStreamBody; import org.apache.axis.message.MimeHeaders; import org.apache.axis.message.SOAPDocumentImpl; import org.apache.axis.message.SOAPEnvelope; import org.apache.axis.message.SOAPHeaderElement; import org.apache.axis.transport.http.HTTPConstants; import org.apache.axis.utils.ByteArray; import org.apache.axis.utils.Messages; import org.apache.axis.utils.SessionUtils; import org.apache.axis.utils.XMLUtils; import org.apache.axis.handlers.HandlerChainImpl; import org.apache.commons.logging.Log; import org.w3c.dom.Attr; import org.w3c.dom.CDATASection; import org.w3c.dom.Comment; import org.w3c.dom.DOMException; import org.w3c.dom.DOMImplementation; import org.w3c.dom.Document; import org.w3c.dom.DocumentFragment; import org.w3c.dom.DocumentType; import org.w3c.dom.Element; import org.w3c.dom.EntityReference; import org.w3c.dom.NamedNodeMap; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import org.w3c.dom.ProcessingInstruction; import org.w3c.dom.Text; import org.xml.sax.InputSource; import org.xml.sax.SAXException; import javax.xml.soap.SOAPException; import javax.xml.soap.SOAPMessage; import javax.xml.transform.Source; import javax.xml.transform.dom.DOMSource; import javax.xml.transform.stream.StreamSource; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStreamWriter; import java.io.PrintWriter; import java.io.Reader; import java.io.StringReader; import java.io.StringWriter; import java.io.UnsupportedEncodingException; import java.io.Writer; import java.util.Iterator; import java.util.Vector; /** * The SOAPPart provides access to the root part of the Message which * contains the envelope. * <p> * SOAPPart implements Part, providing common MIME operations. * <p> * SOAPPart also allows access to its envelope, * as a string, byte[], InputStream, or SOAPEnvelope. (This functionality * used to be in Message, and has been moved here more or less verbatim * pending further cleanup.) * * @author Rob Jellinghaus (robj@unrealities.com) * @author Doug Davis (dug@us.ibm.com) * @author Glen Daniels (gdaniels@allaire.com) * @author Heejune Ahn (cityboy@tmax.co.kr) */ public class SOAPPart extends javax.xml.soap.SOAPPart implements Part { protected static Log log = LogFactory.getLog(SOAPPart.class.getName()); public static final int FORM_STRING = 1; public static final int FORM_INPUTSTREAM = 2; public static final int FORM_SOAPENVELOPE = 3; public static final int FORM_BYTES = 4; public static final int FORM_BODYINSTREAM = 5; public static final int FORM_FAULT = 6; public static final int FORM_OPTIMIZED = 7; private int currentForm; /** * property used to set SOAPEnvelope as default form */ public static final String ALLOW_FORM_OPTIMIZATION = "axis.form.optimization"; //private Hashtable headers = new Hashtable(); private MimeHeaders mimeHeaders = new MimeHeaders(); private static final String[] formNames = { "", "FORM_STRING", "FORM_INPUTSTREAM", "FORM_SOAPENVELOPE", "FORM_BYTES", "FORM_BODYINSTREAM", "FORM_FAULT", "FORM_OPTIMIZED" }; /** * The current representation of the SOAP contents of this part. * May be a String, byte[], InputStream, or SOAPEnvelope, depending * on whatever was last asked for. (ack) * <p> * currentForm must have the corresponding value. * <p> * As someone once said: "Just a placeholder until we figure out what the actual Message * object is." */ private Object currentMessage; /** * default message encoding charset */ private String currentEncoding = "UTF-8"; // These two fields are used for caching in getAsString and getAsBytes private String currentMessageAsString = null; private byte[] currentMessageAsBytes = null; private org.apache.axis.message.SOAPEnvelope currentMessageAsEnvelope = null; /** * Message object this part is tied to. Used for serialization settings. */ private Message msgObject; /** Field contentSource. */ private Source contentSource = null; /** * The original message. Again, may be String, byte[], InputStream, * or SOAPEnvelope. */ // private Object originalMessage ; //free up reference this is not in use. /** * Create a new SOAPPart. * <p> * Do not call this directly! Should only be called by Message. * * @param parent the parent <code>Message</code> * @param initialContents the initial contens <code>Object</code> * @param isBodyStream if the body is in a stream */ public SOAPPart(Message parent, Object initialContents, boolean isBodyStream) { setMimeHeader(HTTPConstants.HEADER_CONTENT_ID, SessionUtils.generateSessionId()); setMimeHeader(HTTPConstants.HEADER_CONTENT_TYPE, "text/xml"); msgObject = parent; // originalMessage = initialContents; int form = FORM_STRING; if (initialContents instanceof SOAPEnvelope) { form = FORM_SOAPENVELOPE; ((SOAPEnvelope) initialContents).setOwnerDocument(this); } else if (initialContents instanceof InputStream) { form = isBodyStream ? FORM_BODYINSTREAM : FORM_INPUTSTREAM; } else if (initialContents instanceof byte[]) { form = FORM_BYTES; } else if (initialContents instanceof AxisFault) { form = FORM_FAULT; } if (log.isDebugEnabled()) { log.debug("Enter: SOAPPart ctor(" + formNames[form] + ")"); } setCurrentMessage(initialContents, form); if (log.isDebugEnabled()) { log.debug("Exit: SOAPPart ctor()"); } } /** * Get the <code>Message</code> for this <code>Part</code>. * * @return the <code>Message</code> for this <code>Part</code> */ public Message getMessage() { return msgObject; } /** * Set the Message for this Part. * Do not call this Directly. Called by Message. * * @param msg the <code>Message</code> for this part */ public void setMessage(Message msg) { this.msgObject = msg; } /** * Content type is always "text/xml" for SOAPParts. * * @return the content type */ public String getContentType() { return "text/xml"; } /** * Get the content length for this SOAPPart. * This will force buffering of the SOAPPart, but it will * also cache the byte[] form of the SOAPPart. * * @return the content length in bytes */ public long getContentLength() throws AxisFault { saveChanges(); if (currentForm == FORM_OPTIMIZED) { return ((ByteArray) currentMessage).size(); } else if (currentForm == FORM_BYTES) { return ((byte[]) currentMessage).length; } byte[] bytes = this.getAsBytes(); return bytes.length; } /** * This set the SOAP Envelope for this part. * <p> * Note: It breaks the chicken/egg created. * I need a message to create an attachment... * From the attachment I should be able to get a reference... * I now want to edit elements in the envelope in order to * place the attachment reference to it. * How do I now update the SOAP envelope with what I've changed? * * @param env the <code>SOAPEnvelope</CODE> for this <code>SOAPPart</code> */ public void setSOAPEnvelope(org.apache.axis.message.SOAPEnvelope env) { setCurrentMessage(env, FORM_SOAPENVELOPE); } /** * Write the contents to the specified stream. * * @param os the <code>java.io.OutputStream</code> to write to */ public void writeTo(java.io.OutputStream os) throws IOException { if (currentForm == FORM_BYTES) { os.write((byte[]) currentMessage); } else if (currentForm == FORM_OPTIMIZED) { ((ByteArray) currentMessage).writeTo(os); } else { Writer writer = new OutputStreamWriter(os, currentEncoding); writer = new BufferedWriter(new PrintWriter(writer)); writeTo(writer); writer.flush(); } } /** * Write the contents to the specified writer. * * @param writer the <code>Writer</code> to write to */ public void writeTo(Writer writer) throws IOException { boolean inclXmlDecl = false; if (msgObject.getMessageContext() != null) { // if we have message context (JAX-RPC), write xml decl always. inclXmlDecl = true; } else { // if we have no message context (SAAJ), write xml decl according to property. try { String xmlDecl = (String) msgObject.getProperty(SOAPMessage.WRITE_XML_DECLARATION); if (xmlDecl != null && xmlDecl.equals("true")) { inclXmlDecl = true; } } catch (SOAPException e) { throw new IOException(e.getMessage()); } } if (currentForm == FORM_FAULT) { AxisFault env = (AxisFault) currentMessage; try { SerializationContext serContext = new SerializationContext(writer, getMessage().getMessageContext()); serContext.setSendDecl(inclXmlDecl); serContext.setEncoding(currentEncoding); env.output(serContext); } catch (Exception e) { log.error(Messages.getMessage("exception00"), e); throw env; } return; } if (currentForm == FORM_SOAPENVELOPE) { SOAPEnvelope env = (SOAPEnvelope) currentMessage; try { SerializationContext serContext = new SerializationContext(writer, getMessage().getMessageContext()); serContext.setSendDecl(inclXmlDecl); serContext.setEncoding(currentEncoding); env.output(serContext); } catch (Exception e) { throw AxisFault.makeFault(e); } return; } String xml = this.getAsString(); if (inclXmlDecl) { if (!xml.startsWith("<?xml")) { writer.write("<?xml version=\"1.0\" encoding=\""); writer.write(currentEncoding); writer.write("\"?>"); } } writer.write(xml); } /** * Get the current message, in whatever form it happens to be right now. * Will return a String, byte[], InputStream, or SOAPEnvelope, depending * on circumstances. * <p> * The method name is historical. * TODO: rename this for clarity; should be more like getContents. * * @return the current content */ public Object getCurrentMessage() { return currentMessage; } /** * Set the current message * @param currMsg * @param form */ public void setCurrentMessage(Object currMsg, int form) { currentMessageAsString = null; //Get rid of any cached stuff this is new. currentMessageAsBytes = null; currentMessageAsEnvelope = null; setCurrentForm(currMsg, form); } /** * Set the current contents of this Part. * The method name is historical. * TODO: rename this for clarity to something more like setContents??? * * @param currMsg the new content of this part * @param form the form of the message */ private void setCurrentForm(Object currMsg, int form) { if (log.isDebugEnabled()) { String msgStr; if (currMsg instanceof String) { msgStr = (String) currMsg; } else { msgStr = currMsg.getClass().getName(); } log.debug(Messages.getMessage("setMsgForm", formNames[form], "" + msgStr)); } // only change form if allowed if (isFormOptimizationAllowed()) { currentMessage = currMsg; currentForm = form; if (currentForm == FORM_SOAPENVELOPE) { currentMessageAsEnvelope = (org.apache.axis.message.SOAPEnvelope) currMsg; } } } /** * check if the allow optimization flag is on * @return form optimization flag */ private boolean isFormOptimizationAllowed() { boolean allowFormOptimization = true; Message msg = getMessage(); if (msg != null) { MessageContext ctx = msg.getMessageContext(); if (ctx != null) { Boolean propFormOptimization = (Boolean) ctx.getProperty(ALLOW_FORM_OPTIMIZATION); if (propFormOptimization != null) { allowFormOptimization = propFormOptimization.booleanValue(); } } } return allowFormOptimization; } public int getCurrentForm() { return currentForm; } /** * Get the contents of this Part (not the headers!), as a byte * array. This will force buffering of the message. * * @return an array of bytes containing a byte representation of this Part * @throws AxisFault if this Part can't be serialized to the byte array */ public byte[] getAsBytes() throws AxisFault { log.debug("Enter: SOAPPart::getAsBytes"); if (currentForm == FORM_OPTIMIZED) { log.debug("Exit: SOAPPart::getAsBytes"); try { return ((ByteArray) currentMessage).toByteArray(); } catch (IOException e) { throw AxisFault.makeFault(e); } } if (currentForm == FORM_BYTES) { log.debug("Exit: SOAPPart::getAsBytes"); return (byte[]) currentMessage; } if (currentForm == FORM_BODYINSTREAM) { try { getAsSOAPEnvelope(); } catch (Exception e) { log.fatal(Messages.getMessage("makeEnvFail00"), e); log.debug("Exit: SOAPPart::getAsBytes"); return null; } } if (currentForm == FORM_INPUTSTREAM) { // Assumes we don't need a content length try { InputStream inp = null; byte[] buf = null; try { inp = (InputStream) currentMessage; ByteArrayOutputStream baos = new ByteArrayOutputStream(); buf = new byte[4096]; int len; while ((len = inp.read(buf, 0, 4096)) != -1) baos.write(buf, 0, len); buf = baos.toByteArray(); } finally { if (inp != null && currentMessage instanceof org.apache.axis.transport.http.SocketInputStream) inp.close(); } setCurrentForm(buf, FORM_BYTES); log.debug("Exit: SOAPPart::getAsBytes"); return (byte[]) currentMessage; } catch (Exception e) { log.error(Messages.getMessage("exception00"), e); } log.debug("Exit: SOAPPart::getAsBytes"); return null; } if (currentForm == FORM_SOAPENVELOPE || currentForm == FORM_FAULT) { currentEncoding = XMLUtils.getEncoding(msgObject, null); ByteArrayOutputStream baos = new ByteArrayOutputStream(); BufferedOutputStream os = new BufferedOutputStream(baos); try { this.writeTo(os); os.flush(); } catch (Exception e) { throw AxisFault.makeFault(e); } setCurrentForm(baos.toByteArray(), FORM_BYTES); if (log.isDebugEnabled()) { log.debug("Exit: SOAPPart::getAsBytes(): " + currentMessage); } return (byte[]) currentMessage; } if (currentForm == FORM_STRING) { // If the current message was already converted from // a byte[] to String, return the byte[] representation // (this is done to avoid unnecessary conversions) if (currentMessage == currentMessageAsString && currentMessageAsBytes != null) { if (log.isDebugEnabled()) { log.debug("Exit: SOAPPart::getAsBytes()"); } return currentMessageAsBytes; } // Save this message in case it is requested later in getAsString currentMessageAsString = (String) currentMessage; try { currentEncoding = XMLUtils.getEncoding(msgObject, null); setCurrentForm(((String) currentMessage).getBytes(currentEncoding), FORM_BYTES); } catch (UnsupportedEncodingException ue) { setCurrentForm(((String) currentMessage).getBytes(), FORM_BYTES); } currentMessageAsBytes = (byte[]) currentMessage; log.debug("Exit: SOAPPart::getAsBytes"); return (byte[]) currentMessage; } log.error(Messages.getMessage("cantConvert00", "" + currentForm)); log.debug("Exit: SOAPPart::getAsBytes"); return null; } public void saveChanges() throws AxisFault { log.debug("Enter: SOAPPart::saveChanges"); if (currentForm == FORM_SOAPENVELOPE || currentForm == FORM_FAULT) { currentEncoding = XMLUtils.getEncoding(msgObject, null); ByteArray array = new ByteArray(); try { writeTo(array); array.flush(); } catch (Exception e) { throw AxisFault.makeFault(e); } setCurrentForm(array, FORM_OPTIMIZED); if (log.isDebugEnabled()) { log.debug("Exit: SOAPPart::saveChanges(): " + currentMessage); } } } /** * Get the contents of this Part (not the headers!), as a String. * This will force buffering of the message. * * @return a <code>String</code> containing the content of this message * @throws AxisFault if there is an error serializing this part */ public String getAsString() throws AxisFault { log.debug("Enter: SOAPPart::getAsString"); if (currentForm == FORM_STRING) { if (log.isDebugEnabled()) { log.debug("Exit: SOAPPart::getAsString(): " + currentMessage); } return (String) currentMessage; } if (currentForm == FORM_INPUTSTREAM || currentForm == FORM_BODYINSTREAM) { getAsBytes(); // Fall thru to "Bytes" } if (currentForm == FORM_OPTIMIZED) { try { currentMessageAsBytes = ((ByteArray) currentMessage).toByteArray(); } catch (IOException e) { throw AxisFault.makeFault(e); } try { setCurrentForm(new String((byte[]) currentMessageAsBytes, currentEncoding), FORM_STRING); } catch (UnsupportedEncodingException ue) { setCurrentForm(new String((byte[]) currentMessageAsBytes), FORM_STRING); } if (log.isDebugEnabled()) { log.debug("Exit: SOAPPart::getAsString(): " + currentMessage); } return (String) currentMessage; } if (currentForm == FORM_BYTES) { // If the current message was already converted from // a String to byte[], return the String representation // (this is done to avoid unnecessary conversions) if (currentMessage == currentMessageAsBytes && currentMessageAsString != null) { if (log.isDebugEnabled()) { log.debug("Exit: SOAPPart::getAsString(): " + currentMessageAsString); } return currentMessageAsString; } // Save this message in case it is requested later in getAsBytes currentMessageAsBytes = (byte[]) currentMessage; try { setCurrentForm(new String((byte[]) currentMessage, currentEncoding), FORM_STRING); } catch (UnsupportedEncodingException ue) { setCurrentForm(new String((byte[]) currentMessage), FORM_STRING); } currentMessageAsString = (String) currentMessage; if (log.isDebugEnabled()) { log.debug("Exit: SOAPPart::getAsString(): " + currentMessage); } return (String) currentMessage; } if (currentForm == FORM_FAULT) { StringWriter writer = new StringWriter(); try { this.writeTo(writer); } catch (Exception e) { log.error(Messages.getMessage("exception00"), e); return null; } setCurrentForm(writer.getBuffer().toString(), FORM_STRING); if (log.isDebugEnabled()) { log.debug("Exit: SOAPPart::getAsString(): " + currentMessage); } return (String) currentMessage; } if (currentForm == FORM_SOAPENVELOPE) { StringWriter writer = new StringWriter(); try { this.writeTo(writer); } catch (Exception e) { throw AxisFault.makeFault(e); } setCurrentForm(writer.getBuffer().toString(), FORM_STRING); if (log.isDebugEnabled()) { log.debug("Exit: SOAPPart::getAsString(): " + currentMessage); } return (String) currentMessage; } log.error(Messages.getMessage("cantConvert01", "" + currentForm)); log.debug("Exit: SOAPPart::getAsString()"); return null; } /** * Get the contents of this Part (not the MIME headers!), as a * SOAPEnvelope. This will force a complete parse of the * message. * * @return a <code>SOAPEnvelope</code> containing the message content * @throws AxisFault if the envelope could not be constructed */ public SOAPEnvelope getAsSOAPEnvelope() throws AxisFault { if (log.isDebugEnabled()) { log.debug("Enter: SOAPPart::getAsSOAPEnvelope()"); log.debug(Messages.getMessage("currForm", formNames[currentForm])); } if (currentForm == FORM_SOAPENVELOPE) return (SOAPEnvelope) currentMessage; if (currentForm == FORM_BODYINSTREAM) { InputStreamBody bodyEl = new InputStreamBody((InputStream) currentMessage); SOAPEnvelope env = new SOAPEnvelope(); env.setOwnerDocument(this); env.addBodyElement(bodyEl); setCurrentForm(env, FORM_SOAPENVELOPE); return env; } InputSource is; if (currentForm == FORM_INPUTSTREAM) { is = new InputSource((InputStream) currentMessage); String encoding = XMLUtils.getEncoding(msgObject, null, null); if (encoding != null) { currentEncoding = encoding; is.setEncoding(currentEncoding); } } else { is = new InputSource(new StringReader(getAsString())); } DeserializationContext dser = new DeserializationContext(is, getMessage().getMessageContext(), getMessage().getMessageType()); dser.getEnvelope().setOwnerDocument(this); // This may throw a SAXException try { dser.parse(); } catch (SAXException e) { Exception real = e.getException(); if (real == null) real = e; throw AxisFault.makeFault(real); } SOAPEnvelope nse = dser.getEnvelope(); if (currentMessageAsEnvelope != null) { //Need to synchronize back processed header info. Vector newHeaders = nse.getHeaders(); Vector oldHeaders = currentMessageAsEnvelope.getHeaders(); if (null != newHeaders && null != oldHeaders) { Iterator ohi = oldHeaders.iterator(); Iterator nhi = newHeaders.iterator(); while (ohi.hasNext() && nhi.hasNext()) { SOAPHeaderElement nhe = (SOAPHeaderElement) nhi.next(); SOAPHeaderElement ohe = (SOAPHeaderElement) ohi.next(); if (ohe.isProcessed()) nhe.setProcessed(true); } } } setCurrentForm(nse, FORM_SOAPENVELOPE); log.debug("Exit: SOAPPart::getAsSOAPEnvelope"); SOAPEnvelope env = (SOAPEnvelope) currentMessage; env.setOwnerDocument(this); return env; } /** * Add the specified MIME header, as per JAXM. * * @param header the header to add * @param value the value of that header */ public void addMimeHeader(String header, String value) { mimeHeaders.addHeader(header, value); } /** * Get the specified MIME header. * * @param header the name of a MIME header * @return the value of the first header named <code>header</code> */ private String getFirstMimeHeader(String header) { String[] values = mimeHeaders.getHeader(header); if (values != null && values.length > 0) return values[0]; return null; } /** * Total size in bytes (of all content and headers, as encoded). public abstract int getSize(); */ /** * Content location. * * @return the content location */ public String getContentLocation() { return getFirstMimeHeader(HTTPConstants.HEADER_CONTENT_LOCATION); } /** * Set content location. * * @param loc the content location */ public void setContentLocation(String loc) { setMimeHeader(HTTPConstants.HEADER_CONTENT_LOCATION, loc); } /** * Sets Content-Id of this part. * already defined. * @param newCid new Content-Id */ public void setContentId(String newCid) { setMimeHeader(HTTPConstants.HEADER_CONTENT_ID, newCid); } /** * Content ID. * * @return the content ID */ public String getContentId() { return getFirstMimeHeader(HTTPConstants.HEADER_CONTENT_ID); } /** * Content ID. * * @return the contentId reference value that should be used directly * as an href in a SOAP element to reference this attachment. * <B>Not part of JAX-RPC, JAX-M, SAAJ, etc. </B> */ public String getContentIdRef() { return org.apache.axis.attachments.Attachments.CIDprefix + getContentId(); } /** * Get all headers that match. * * @param match an array of <code>String</code>s giving mime header names * @return an <code>Iterator</code> over all values matching these headers */ public java.util.Iterator getMatchingMimeHeaders(final String[] match) { return mimeHeaders.getMatchingHeaders(match); } /** * Get all headers that do not match. * * @param match an array of <code>String</code>s giving mime header names * @return an <code>Iterator</code> over all values not matching these * headers */ public java.util.Iterator getNonMatchingMimeHeaders(final String[] match) { return mimeHeaders.getNonMatchingHeaders(match); } /** * Sets the content of the <CODE>SOAPEnvelope</CODE> object * with the data from the given <CODE>Source</CODE> object. * @param source javax.xml.transform.Source</CODE> object with the data to * be set * @throws SOAPException if there is a problem in * setting the source * @see #getContent() getContent() */ public void setContent(Source source) throws SOAPException { if (source == null) throw new SOAPException(Messages.getMessage("illegalArgumentException00")); // override the checks in HandlerChainImpl for JAXRPCHandler kludge MessageContext ctx = getMessage().getMessageContext(); if (ctx != null) { ctx.setProperty(org.apache.axis.SOAPPart.ALLOW_FORM_OPTIMIZATION, Boolean.TRUE); } contentSource = source; InputSource in = org.apache.axis.utils.XMLUtils.sourceToInputSource(contentSource); InputStream is = in.getByteStream(); if (is != null) { setCurrentMessage(is, FORM_INPUTSTREAM); } else { Reader r = in.getCharacterStream(); if (r == null) { throw new SOAPException(Messages.getMessage("noCharacterOrByteStream")); } BufferedReader br = new BufferedReader(r); String line = null; StringBuffer sb = new StringBuffer(); try { while ((line = br.readLine()) != null) { sb.append(line); } } catch (IOException e) { throw new SOAPException(Messages.getMessage("couldNotReadFromCharStream"), e); } setCurrentMessage(sb.toString(), FORM_STRING); } } /** * Returns the content of the SOAPEnvelope as a JAXP <CODE> * Source</CODE> object. * @return the content as a <CODE> * javax.xml.transform.Source</CODE> object * @throws SOAPException if the implementation cannot * convert the specified <CODE>Source</CODE> object * @see #setContent(javax.xml.transform.Source) setContent(javax.xml.transform.Source) */ public Source getContent() throws SOAPException { if (contentSource == null) { switch (currentForm) { case FORM_STRING: String s = (String) currentMessage; contentSource = new StreamSource(new StringReader(s)); break; case FORM_INPUTSTREAM: contentSource = new StreamSource((InputStream) currentMessage); break; case FORM_SOAPENVELOPE: SOAPEnvelope se = (SOAPEnvelope) currentMessage; try { contentSource = new DOMSource(se.getAsDocument()); } catch (Exception e) { throw new SOAPException(Messages.getMessage("errorGetDocFromSOAPEnvelope"), e); } break; case FORM_OPTIMIZED: try { ByteArrayInputStream baos = new ByteArrayInputStream( ((ByteArray) currentMessage).toByteArray()); contentSource = new StreamSource(baos); } catch (IOException e) { throw new SOAPException(Messages.getMessage("errorGetDocFromSOAPEnvelope"), e); } break; case FORM_BYTES: byte[] bytes = (byte[]) currentMessage; contentSource = new StreamSource(new ByteArrayInputStream(bytes)); break; case FORM_BODYINSTREAM: contentSource = new StreamSource((InputStream) currentMessage); break; } } return contentSource; } /** * Retrieves all the headers for this <CODE>SOAPPart</CODE> * object as an iterator over the <CODE>MimeHeader</CODE> * objects. * @return an <CODE>Iterator</CODE> object with all of the Mime * headers for this <CODE>SOAPPart</CODE> object */ public Iterator getAllMimeHeaders() { return mimeHeaders.getAllHeaders(); } /** * Changes the first header entry that matches the given * header name so that its value is the given value, adding a * new header with the given name and value if no existing * header is a match. If there is a match, this method clears * all existing values for the first header that matches and * sets the given value instead. If more than one header has * the given name, this method removes all of the matching * headers after the first one. * * <P>Note that RFC822 headers can contain only US-ASCII * characters.</P> * @param name a <CODE>String</CODE> giving the * header name for which to search * @param value a <CODE>String</CODE> giving the * value to be set. This value will be substituted for the * current value(s) of the first header that is a match if * there is one. If there is no match, this value will be * the value for a new <CODE>MimeHeader</CODE> object. * @ throws java.lang.IllegalArgumentException if * there was a problem with the specified mime header name * or value * @see #getMimeHeader(java.lang.String) getMimeHeader(java.lang.String) */ public void setMimeHeader(String name, String value) { mimeHeaders.setHeader(name, value); } /** * Gets all the values of the <CODE>MimeHeader</CODE> object * in this <CODE>SOAPPart</CODE> object that is identified by * the given <CODE>String</CODE>. * @param name the name of the header; example: * "Content-Type" * @return a <CODE>String</CODE> array giving all the values for * the specified header * @see #setMimeHeader(java.lang.String, java.lang.String) setMimeHeader(java.lang.String, java.lang.String) */ public String[] getMimeHeader(String name) { return mimeHeaders.getHeader(name); } /** * Removes all the <CODE>MimeHeader</CODE> objects for this * <CODE>SOAPEnvelope</CODE> object. */ public void removeAllMimeHeaders() { mimeHeaders.removeAllHeaders(); } /** * Removes all MIME headers that match the given name. * @param header a <CODE>String</CODE> giving * the name of the MIME header(s) to be removed */ public void removeMimeHeader(String header) { mimeHeaders.removeHeader(header); } /** * Gets the <CODE>SOAPEnvelope</CODE> object associated with * this <CODE>SOAPPart</CODE> object. Once the SOAP envelope is * obtained, it can be used to get its contents. * @return the <CODE>SOAPEnvelope</CODE> object for this <CODE> * SOAPPart</CODE> object * @throws SOAPException if there is a SOAP error */ public javax.xml.soap.SOAPEnvelope getEnvelope() throws SOAPException { try { return getAsSOAPEnvelope(); } catch (AxisFault af) { throw new SOAPException(af); } } /** * Implementation of org.w3c.Document * Most of methods will be implemented using the delgate * instance of SOAPDocumentImpl * This is for two reasons: * - possible change of message classes, by extenstion of xerces implementation * - we cannot extends SOAPPart (multiple inheritance), * since it is defined as Abstract class * *********************************************************** */ private Document document = new SOAPDocumentImpl(this); /** * @since SAAJ 1.2 */ public Document getSOAPDocument() { if (document == null) { document = new SOAPDocumentImpl(this); } return document; } /** * @return */ public DocumentType getDoctype() { return document.getDoctype(); } /** * @return */ public DOMImplementation getImplementation() { return document.getImplementation(); } /** * SOAPEnvelope is the Document Elements of this XML docuement */ protected Document mDocument; public Element getDocumentElement() { try { return getEnvelope(); } catch (SOAPException se) { return null; } } /** * * @param tagName * @return * @throws DOMException */ public Element createElement(String tagName) throws DOMException { return document.createElement(tagName); } public DocumentFragment createDocumentFragment() { return document.createDocumentFragment(); } public Text createTextNode(String data) { return document.createTextNode(data); } public Comment createComment(String data) { return document.createComment(data); } public CDATASection createCDATASection(String data) throws DOMException { return document.createCDATASection(data); } public ProcessingInstruction createProcessingInstruction(String target, String data) throws DOMException { return document.createProcessingInstruction(target, data); } public Attr createAttribute(String name) throws DOMException { return document.createAttribute(name); } public EntityReference createEntityReference(String name) throws DOMException { return document.createEntityReference(name); } public NodeList getElementsByTagName(String tagname) { return document.getElementsByTagName(tagname); } public Node importNode(Node importedNode, boolean deep) throws DOMException { return document.importNode(importedNode, deep); } public Element createElementNS(String namespaceURI, String qualifiedName) throws DOMException { return document.createElementNS(namespaceURI, qualifiedName); } public Attr createAttributeNS(String namespaceURI, String qualifiedName) throws DOMException { return document.createAttributeNS(namespaceURI, qualifiedName); } public NodeList getElementsByTagNameNS(String namespaceURI, String localName) { return document.getElementsByTagNameNS(namespaceURI, localName); } public Element getElementById(String elementId) { return document.getElementById(elementId); } ///////////////////////////////////////////////////////////// public String getEncoding() { return currentEncoding; } public void setEncoding(String s) { currentEncoding = s; } public boolean getStandalone() { throw new UnsupportedOperationException("Not yet implemented.71"); } public void setStandalone(boolean flag) { throw new UnsupportedOperationException("Not yet implemented.72"); } public boolean getStrictErrorChecking() { throw new UnsupportedOperationException("Not yet implemented.73"); } public void setStrictErrorChecking(boolean flag) { throw new UnsupportedOperationException("Not yet implemented. 74"); } public String getVersion() { throw new UnsupportedOperationException("Not yet implemented. 75"); } public void setVersion(String s) { throw new UnsupportedOperationException("Not yet implemented.76"); } public Node adoptNode(Node node) throws DOMException { throw new UnsupportedOperationException("Not yet implemented.77"); } /** * Node Implementation */ public String getNodeName() { return document.getNodeName(); } public String getNodeValue() throws DOMException { return document.getNodeValue(); } public void setNodeValue(String nodeValue) throws DOMException { document.setNodeValue(nodeValue); } public short getNodeType() { return document.getNodeType(); } public Node getParentNode() { return document.getParentNode(); } public NodeList getChildNodes() { return document.getChildNodes(); } public Node getFirstChild() { return document.getFirstChild(); } public Node getLastChild() { return document.getLastChild(); } public Node getPreviousSibling() { return document.getPreviousSibling(); } public Node getNextSibling() { return document.getNextSibling(); } public NamedNodeMap getAttributes() { return document.getAttributes(); } public Document getOwnerDocument() { return document.getOwnerDocument(); } public Node insertBefore(Node newChild, Node refChild) throws DOMException { return document.insertBefore(newChild, refChild); } public Node replaceChild(Node newChild, Node oldChild) throws DOMException { return document.replaceChild(newChild, oldChild); } public Node removeChild(Node oldChild) throws DOMException { return document.removeChild(oldChild); } public Node appendChild(Node newChild) throws DOMException { return document.appendChild(newChild); } public boolean hasChildNodes() { return document.hasChildNodes(); } public Node cloneNode(boolean deep) { return document.cloneNode(deep); } public void normalize() { document.normalize(); } public boolean isSupported(String feature, String version) { return document.isSupported(feature, version); } public String getNamespaceURI() { return document.getNamespaceURI(); } public String getPrefix() { return document.getPrefix(); } public void setPrefix(String prefix) throws DOMException { document.setPrefix(prefix); } public String getLocalName() { return document.getLocalName(); } public boolean hasAttributes() { return document.hasAttributes(); } public boolean isBodyStream() { return (currentForm == SOAPPart.FORM_INPUTSTREAM || currentForm == SOAPPart.FORM_BODYINSTREAM); } }