org.apache.axis.SOAPPart Maven / Gradle / Ivy
/* * 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. *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* SOAPPart implements Part, providing common MIME operations. *
* 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 ([email protected]) * @author Doug Davis ([email protected]) * @author Glen Daniels ([email protected]) * @author Heejune Ahn ([email protected]) */ 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) *
* currentForm must have the corresponding value. *
* 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. *
* Do not call this directly! Should only be called by Message. * * @param parent the parent
Message* @param initialContents the initial contensObject* @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 theMessagefor thisPart. * * @return theMessagefor thisPart*/ public Message getMessage(){ return msgObject; } /** * Set the Message for this Part. * Do not call this Directly. Called by Message. * * @param msg theMessagefor 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. ** 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
SOAPEnvelopefor thisSOAPPart*/ public void setSOAPEnvelope(org.apache.axis.message.SOAPEnvelope env){ setCurrentMessage(env, FORM_SOAPENVELOPE) ; } /** * Write the contents to the specified stream. * * @param os thejava.io.OutputStreamto 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 theWriterto 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(""); } } 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. ** 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
Stringcontaining 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 aSOAPEnvelopecontaining 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 namedheader*/ 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. * Not part of JAX-RPC, JAX-M, SAAJ, etc. */ public String getContentIdRef() { return org.apache.axis.attachments.Attachments.CIDprefix + getContentId(); } /** * Get all headers that match. * * @param match an array ofStrings giving mime header names * @return anIteratorover 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 ofStrings giving mime header names * @return anIteratorover all values not matching these * headers */ public java.util.Iterator getNonMatchingMimeHeaders( final String[] match){ return mimeHeaders.getNonMatchingHeaders(match); } /** * Sets the content of theSOAPEnvelopeobject * with the data from the givenSourceobject. * @param source javax.xml.transform.Source* Sourceobject. * @return the content as a* javax.xml.transform.Sourceobject * @throws SOAPException if the implementation cannot * convert the specifiedSourceobject * @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 thisSOAPPart* object as an iterator over theMimeHeader* objects. * @return anIteratorobject with all of the Mime * headers for thisSOAPPartobject */ 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. * *Note that RFC822 headers can contain only US-ASCII * characters.
* @param name aStringgiving the * header name for which to search * @param value aStringgiving 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 newMimeHeaderobject. * @ 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 theMimeHeaderobject * in thisSOAPPartobject that is identified by * the givenString. * @param name the name of the header; example: * "Content-Type" * @return aStringarray 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 theMimeHeaderobjects for this *SOAPEnvelopeobject. */ public void removeAllMimeHeaders() { mimeHeaders.removeAllHeaders(); } /** * Removes all MIME headers that match the given name. * @param header aStringgiving * the name of the MIME header(s) to be removed */ public void removeMimeHeader(String header) { mimeHeaders.removeHeader(header); } /** * Gets theSOAPEnvelopeobject associated with * thisSOAPPartobject. Once the SOAP envelope is * obtained, it can be used to get its contents. * @return theSOAPEnvelopeobject for this* SOAPPartobject * @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); } }