Pretty Print SOAP message

[Daniel Larusso]

This is kind of a newbie question... i'm trying to pretty print my request SOAP message after a javax.xml.rpc.GenericHandler implementation adds in some custom headers in my client code.

Any idea how i do this? I'm basically trying to log the contents of the SOAPEnvelope object. Here is the code im working with:

SOAPMessageContext smc = (SOAPMessageContext)context;
SOAPEnvelope se = smc.getMessage().getSOAPPart().getEnvelope();

[Daniel Larusso]

Sorry... I should have RTFM'ed a little more. SOAPMessage has a function called "writeTo" that takes an OutputStream... Solved the printing problem, but it doesn't pretty print the SOAP message.

[Watsh Rajneesh]

You can use the following code to pretty print the soap message xml (code excerpted from Writer.java samples code with XercesJ 2.8.0 distribution).

    
import java.io.*;
import org.w3c.dom.*;
import java.lang.reflect.Method;
 
public class DomWriter {
    /** Print writer. */
    protected PrintWriter fOut;
    
    /** Creates a new instance of DomWriter */
    public DomWriter() {
    }
    //
    // Public methods
    //
 
    /** Sets the output stream for printing. */
    public void setOutput(OutputStream stream, String encoding)
        throws UnsupportedEncodingException {
 
        if (encoding == null) {
            encoding = "UTF8";
        }
 
        java.io.Writer writer = new OutputStreamWriter(stream, encoding);
        fOut = new PrintWriter(writer);
 
    } // setOutput(OutputStream,String)
 
    /** Sets the output writer. */
    public void setOutput(java.io.Writer writer) {
 
        fOut = writer instanceof PrintWriter
             ? (PrintWriter)writer : new PrintWriter(writer);
 
    } // setOutput(java.io.Writer)
    
    /** Writes the specified node, recursively. */
    public void write(Node node) {
 
        // is there anything to do?
        if (node == null) {
            return;
        }
 
        short type = node.getNodeType();
        switch (type) {
            case Node.DOCUMENT_NODE: {
                Document document = (Document)node;
                
                fOut.println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
                fOut.flush();
                write(document.getDoctype());
 
                write(document.getDocumentElement());
                break;
            }
 
            case Node.DOCUMENT_TYPE_NODE: {
                DocumentType doctype = (DocumentType)node;
                fOut.print("<!DOCTYPE ");
                fOut.print(doctype.getName());
                String publicId = doctype.getPublicId();
                String systemId = doctype.getSystemId();
                if (publicId != null) {
                    fOut.print(" PUBLIC '");
                    fOut.print(publicId);
                    fOut.print("' '");
                    fOut.print(systemId);
                    fOut.print('\'');
                }
                else if (systemId != null) {
                    fOut.print(" SYSTEM '");
                    fOut.print(systemId);
                    fOut.print('\'');
                }
                String internalSubset = doctype.getInternalSubset();
                if (internalSubset != null) {
                    fOut.println(" [");
                    fOut.print(internalSubset);
                    fOut.print(']');
                }
                fOut.println('>');
                break;
            }
 
            case Node.ELEMENT_NODE: {
                fOut.print('<');
                fOut.print(node.getNodeName());
                Attr attrs[] = sortAttributes(node.getAttributes());
                for (int i = 0; i < attrs.length; i++) {
                    Attr attr = attrs[i];
                    fOut.print(' ');
                    fOut.print(attr.getNodeName());
                    fOut.print("=\"");
                    normalizeAndPrint(attr.getNodeValue(), true);
                    fOut.print('"');
                }
                fOut.print('>');
                fOut.flush();
 
                Node child = node.getFirstChild();
                while (child != null) {
                    write(child);
                    child = child.getNextSibling();
                }
                break;
            }
 
            case Node.ENTITY_REFERENCE_NODE: {
                fOut.print('&');
                fOut.print(node.getNodeName());
                fOut.print(';');
                fOut.flush();
 
                break;
            }
 
            case Node.CDATA_SECTION_NODE: {
                fOut.print("<![CDATA[");
                fOut.print(node.getNodeValue());
                fOut.print("]]>");
                fOut.flush();
                break;
            }
 
            case Node.TEXT_NODE: {
                normalizeAndPrint(node.getNodeValue(), false);
                fOut.flush();
                break;
            }
 
            case Node.PROCESSING_INSTRUCTION_NODE: {
                fOut.print("<?");
                fOut.print(node.getNodeName());
                String data = node.getNodeValue();
                if (data != null && data.length() > 0) {
                    fOut.print(' ');
                    fOut.print(data);
                }
                fOut.print("?>");
                fOut.flush();
                break;
            }
            
            case Node.COMMENT_NODE: {
                fOut.print("<!--");
                String comment = node.getNodeValue();
                if (comment != null && comment.length() > 0) {
                    fOut.print(comment);
                }
                fOut.print("-->");
                fOut.flush();
            }
        }
 
        if (type == Node.ELEMENT_NODE) {
            fOut.print("</");
            fOut.print(node.getNodeName());
            fOut.print('>');
            fOut.flush();
        }
 
    } // write(Node)
    
    /** Returns a sorted list of attributes. */
    protected Attr[] sortAttributes(NamedNodeMap attrs) {
 
        int len = (attrs != null) ? attrs.getLength() : 0;
        Attr array[] = new Attr[len];
        for (int i = 0; i < len; i++) {
            array[i] = (Attr)attrs.item(i);
        }
        for (int i = 0; i < len - 1; i++) {
            String name = array[i].getNodeName();
            int index = i;
            for (int j = i + 1; j < len; j++) {
                String curName = array[j].getNodeName();
                if (curName.compareTo(name) < 0) {
                    name = curName;
                    index = j;
                }
            }
            if (index != i) {
                Attr temp = array[i];
                array[i] = array[index];
                array[index] = temp;
            }
        }
 
        return array;
 
    } // sortAttributes(NamedNodeMap):Attr[]
 
    //
    // Protected methods
    //
 
    /** Normalizes and prints the given string. */
    protected void normalizeAndPrint(String s, boolean isAttValue) {
 
        int len = (s != null) ? s.length() : 0;
        for (int i = 0; i < len; i++) {
            char c = s.charAt(i);
            normalizeAndPrint(c, isAttValue);
        }
 
    } // normalizeAndPrint(String,boolean)
 
    /** Normalizes and print the given character. */
    protected void normalizeAndPrint(char c, boolean isAttValue) {
 
        switch (c) {
            case '<': {
                fOut.print("<");
                break;
            }
            case '>': {
                fOut.print(">");
                break;
            }
            case '&': {
                fOut.print("&");
                break;
            }
            case '"': {
                // A '"' that appears in character data 
                // does not need to be escaped.
                if (isAttValue) {
                    fOut.print(""");
                }
                else {
                    fOut.print("\"");
                }
                break;
            }
            case '\r': {
            // If CR is part of the document's content, it
            // must not be printed as a literal otherwise
            // it would be normalized to LF when the document
            // is reparsed.
            fOut.print("
");
            break;
            }
            case '\n': {
                // default print char
            }
            default: {
                fOut.print(c); 
            }
        }
    } // normalizeAndPrint(char,boolean)
 
    /** Extracts the XML version from the Document. */
    protected String getVersion(Document document) {
    if (document == null) {
        return null;
    }
        String version = null;
        Method getXMLVersion = null;
        try {
            getXMLVersion = document.getClass().getMethod("getXmlVersion", new Class[]{});
            // If Document class implements DOM L3, this method will exist.
            if (getXMLVersion != null) {
                version = (String) getXMLVersion.invoke(document, (Object[]) null);
            }
        } 
        catch (Exception e) { 
            // Either this locator object doesn't have 
            // this method, or we're on an old JDK.
        }
        return version;
    } // getVersion(Document)
}
 

The usage for above writer is:
Writing to Stream:

   
    //Write to stream
    DomWriter writer = new DomWriter();
    File f = new File("./soap_msg.xml");
    FileWriter fw = new java.io.FileWriter(f);
    writer.setOutput(fw);
    writer.write(xmlDoc);
 

Writing to std out:

    
writer.setOutput(System.out, null);
writer.write(xmlDoc);

where, xmlDoc is of type org.w3c.dom.Document but you can pass a SOAPMessage org.w3c.dom.Node type too.
[ September 11, 2006: Message edited by: Watsh Rajneesh ]