SOAP (Simple Object Access Protocol) is widely used in enterprise applications for communication between services. While working with SOAP-based systems in Java, developers often need access to the raw XML of a SOAP message for logging, debugging, auditing, or transformation purposes. Let us delve into understanding how to extract a SOAP message’s raw XML for effective debugging and monitoring in Java applications.<\/p>\n
SOAP (Simple Object Access Protocol)<\/a> is a protocol used for exchanging structured information between applications over a network. It relies on XML as its message format and typically uses HTTP or HTTPS as the transport protocol. SOAP is widely used in enterprise systems because of its extensibility, strict standards, and built-in error handling mechanisms. A SOAP message is a well-defined XML document that follows a specific structure. Understanding this structure is crucial when working with raw SOAP messages, especially for debugging, logging, or implementing custom handlers.<\/p>\n Raw XML refers to the complete SOAP message in its original, unprocessed XML format as it is sent over the network. It represents the exact payload exchanged between the client and the server without any abstraction or transformation by frameworks such as JAX-WS or Spring WS. Accessing raw XML is particularly useful in the following scenarios:<\/p>\n A raw SOAP message consists of the following core components:<\/p>\n Below is an example of a raw SOAP XML request:<\/p>\n In this example, the When we talk about “getting raw XML” in Java, we essentially mean accessing this complete SOAP message as a string or stream before it is parsed into Java objects (or after it is generated but before being sent over the network).<\/p>\n SAAJ (SOAP with Attachments API for Java) provides low-level control over SOAP messages.<\/p>\n This code demonstrates how to create and extract raw SOAP XML using the SAAJ API in Java. It starts by creating a The output represents the raw SOAP XML message generated by the SAAJ API. The JAX-WS allows interception of SOAP messages using handlers.<\/p>\n This code defines a custom SOAP handler named The output shows the complete raw SOAP XML message intercepted by the Apache CXF provides interceptors to access raw SOAP messages.<\/p>\n This code defines a custom Apache CXF interceptor named The output displays the complete raw SOAP XML message intercepted by the Spring Web Services provides built-in interceptors for handling SOAP messages.<\/p>\n This code defines a custom Spring Web Services interceptor named 1.1 Understanding Raw XML in SOAP<\/h3>\n
\n
\n
<soapenv:Envelope xmlns:soapenv=\"http:\/\/schemas.xmlsoap.org\/soap\/envelope\/\" \n xmlns:ns=\"http:\/\/example.com\/user\">\n\n <soapenv:Header>\n <ns:AuthToken>abc123<\/ns:AuthToken>\n <\/soapenv:Header>\n\n <soapenv:Body>\n <ns:getUser>\n <ns:id>101<\/ns:id>\n <\/ns:getUser>\n <\/soapenv:Body>\n\n<\/soapenv:Envelope>\n<\/pre>\n
Envelope<\/code> defines the SOAP message boundaries, the Header<\/code> carries an authentication token, and the Body<\/code> contains the actual operation (getUser<\/code>) along with its input parameter.<\/p>\n<\/a>2. Extracting Raw XML Using SAAJ (SOAPMessage)<\/h2>\n
\/\/ SaajExample.java\nimport javax.xml.soap.*;\nimport java.io.ByteArrayOutputStream;\n\npublic class SaajExample {\n\n public static void main(String[] args) throws Exception {\n MessageFactory factory = MessageFactory.newInstance();\n SOAPMessage message = factory.createMessage();\n\n SOAPBody body = message.getSOAPBody();\n body.addBodyElement(\n message.getSOAPPart().getEnvelope().createName(\"test\", \"ns\", \"http:\/\/example.com\")\n ).addTextNode(\"Hello World\");\n\n ByteArrayOutputStream outputStream = new ByteArrayOutputStream();\n message.writeTo(outputStream);\n\n String rawXml = new String(outputStream.toByteArray());\n System.out.println(rawXml);\n }\n}\n<\/pre>\n2.1 Code Explanation<\/h3>\n
MessageFactory<\/code> instance to generate a new SOAPMessage<\/code>. Then, it retrieves the SOAPBody<\/code> from the message and adds a new body element named test<\/code> with a namespace http:\/\/example.com<\/code>, inserting the text value “Hello World” into it. After constructing the SOAP message, a ByteArrayOutputStream<\/code> is used to capture the entire SOAP message in its raw XML format by calling message.writeTo(outputStream)<\/code>. Finally, the byte stream is converted into a string representing the complete raw SOAP XML, which is printed to the console.<\/p>\n2.2 Code Output<\/h3>\n
<SOAP-ENV:Envelope>\n <SOAP-ENV:Body>\n <ns:test>Hello World<\/ns:test>\n <\/SOAP-ENV:Body>\n<\/SOAP-ENV:Envelope>\n<\/pre>\n
SOAP-ENV:Envelope<\/code> is the root element that wraps the entire SOAP message and defines it as a valid SOAP structure. Inside it, the SOAP-ENV:Body<\/code> contains the actual payload of the message. Within the body, the custom element ns:test<\/code> is present, which was programmatically added in the code using a namespace and assigned the value “Hello World”. The absence of a Header<\/code> element indicates that no additional metadata (such as authentication or transaction details) was included in this message. Overall, this output shows a minimal SOAP request structure with a single operation and its corresponding data.<\/a>3. Capturing SOAP Messages with JAX-WS Handlers<\/h2>\n
\/\/ LoggingSOAPHandler.java\nimport javax.xml.namespace.QName;\nimport javax.xml.ws.handler.soap.*;\nimport javax.xml.ws.handler.MessageContext;\nimport javax.xml.soap.SOAPMessage;\nimport java.io.ByteArrayOutputStream;\nimport java.util.Set;\n\npublic class LoggingSOAPHandler implements SOAPHandler<SOAPMessageContext> {\n\n @Override\n public boolean handleMessage(SOAPMessageContext context) {\n try {\n SOAPMessage message = context.getMessage();\n ByteArrayOutputStream out = new ByteArrayOutputStream();\n message.writeTo(out);\n\n String rawXml = new String(out.toByteArray());\n System.out.println(\"SOAP Message:\\n\" + rawXml);\n\n } catch (Exception e) {\n e.printStackTrace();\n }\n return true;\n }\n\n @Override\n public Set<QName> getHeaders() {\n return null;\n }\n\n @Override\n public boolean handleFault(SOAPMessageContext context) {\n return true;\n }\n\n @Override\n public void close(MessageContext context) {}\n}\n<\/pre>\n3.1 Code Explanation<\/h3>\n
LoggingSOAPHandler<\/code> that implements the SOAPHandler<SOAPMessageContext><\/code> interface to intercept and log SOAP messages in their raw XML form. Inside the handleMessage<\/code> method, the current SOAPMessage<\/code> is retrieved from the SOAPMessageContext<\/code>, and a ByteArrayOutputStream<\/code> is used to capture the entire SOAP message by invoking message.writeTo()<\/code>. The resulting byte stream is then converted into a string to obtain the raw XML, which is printed to the console for logging or debugging purposes. The method returns true<\/code> to allow further processing in the handler chain. The getHeaders<\/code> method returns null<\/code>, indicating that this handler does not process specific SOAP headers, while handleFault<\/code> simply returns true<\/code> to continue fault processing if an error occurs. The close<\/code> method is left empty as no resource cleanup is required. Overall, this handler is useful for inspecting inbound and outbound SOAP messages in JAX-WS-based applications.<\/p>\n3.2 Code Output<\/h3>\n
SOAP Message:\n<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http:\/\/schemas.xmlsoap.org\/soap\/envelope\/\">\n <SOAP-ENV:Header\/>\n <SOAP-ENV:Body>\n <ns:getUser xmlns:ns=\"http:\/\/example.com\">\n <ns:id>101<\/ns:id>\n <\/ns:getUser>\n <\/SOAP-ENV:Body>\n<\/SOAP-ENV:Envelope>\n<\/pre>\n
LoggingSOAPHandler<\/code>. The line \"SOAP Message:\"<\/code> is printed first, followed by the full SOAP envelope captured from the message context. The Envelope<\/code> element wraps the entire message and defines the SOAP namespace, while the Header<\/code> is present but empty, indicating that no additional metadata was included. The Body<\/code> contains the actual business request, in this case the getUser<\/code> operation with an input parameter id<\/code> set to 101<\/code>. This output confirms that the handler successfully intercepted the SOAP message and converted it into raw XML format using writeTo()<\/code>, making it useful for debugging, logging, or monitoring SOAP requests and responses in real-time.<\/p>\n<\/a>4. Intercepting SOAP Messages with Apache CXF<\/h2>\n
\/\/ CXFLoggingInterceptor.java\nimport org.apache.cxf.interceptor.AbstractPhaseInterceptor;\nimport org.apache.cxf.phase.Phase;\nimport org.apache.cxf.message.Message;\n\nimport java.io.InputStream;\nimport java.io.ByteArrayOutputStream;\n\npublic class CXFLoggingInterceptor extends AbstractPhaseInterceptor<Message> {\n\n public CXFLoggingInterceptor() {\n super(Phase.RECEIVE);\n }\n\n @Override\n public void handleMessage(Message message) {\n try {\n InputStream is = message.getContent(InputStream.class);\n ByteArrayOutputStream buffer = new ByteArrayOutputStream();\n\n int nRead;\n byte[] data = new byte[1024];\n\n while ((nRead = is.read(data, 0, data.length)) != -1) {\n buffer.write(data, 0, nRead);\n }\n\n String rawXml = buffer.toString(\"UTF-8\");\n System.out.println(\"Raw SOAP XML:\\n\" + rawXml);\n\n } catch (Exception e) {\n e.printStackTrace();\n }\n }\n}\n<\/pre>\n4.1 Code Explanation<\/h3>\n
CXFLoggingInterceptor<\/code> that extends AbstractPhaseInterceptor<Message><\/code> to intercept SOAP messages at a specific phase in the CXF processing pipeline. In the constructor, the interceptor is registered for the Phase.RECEIVE<\/code>, meaning it will execute when an incoming SOAP request is received. Inside the handleMessage<\/code> method, the raw message content is accessed as an InputStream<\/code> using message.getContent(InputStream.class)<\/code>. The stream is then read in chunks using a byte buffer and written into a ByteArrayOutputStream<\/code> to reconstruct the full message. After reading the entire stream, it is converted into a UTF-8 encoded string representing the raw SOAP XML, which is printed to the console. This interceptor is particularly useful for logging, debugging, or auditing incoming SOAP requests in Apache CXF-based applications by allowing developers to inspect the exact XML payload being processed.<\/p>\n4.2 Code Output<\/h3>\n
Raw SOAP XML:\n<soap:Envelope xmlns:soap=\"http:\/\/schemas.xmlsoap.org\/soap\/envelope\/\">\n <soap:Header\/>\n <soap:Body>\n <ns:getUser xmlns:ns=\"http:\/\/example.com\">\n <ns:id>101<\/ns:id>\n <\/ns:getUser>\n <\/soap:Body>\n<\/soap:Envelope>\n<\/pre>\n
CXFLoggingInterceptor<\/code> during the RECEIVE<\/code> phase. The prefix \"Raw SOAP XML:\"<\/code> is printed first, followed by the full SOAP message captured from the input stream. The Envelope<\/code> element defines the SOAP structure and namespace, enclosing both the Header<\/code> and Body<\/code>. The Header<\/code> is empty, indicating no additional metadata was included, while the Body<\/code> contains the actual request payload, in this case the getUser<\/code> operation with an id<\/code> value of 101<\/code>. This output confirms that the interceptor successfully read the incoming message stream, reconstructed it into a string, and logged the exact SOAP XML being received by the application, which is highly useful for debugging and monitoring purposes.<\/p>\n<\/a>5. Handling SOAP Messages in Spring Web Services<\/h2>\n
\/\/ SpringSoapInterceptor.java\nimport org.springframework.ws.context.MessageContext;\nimport org.springframework.ws.server.EndpointInterceptor;\nimport org.springframework.ws.soap.SoapMessage;\n\nimport java.io.ByteArrayOutputStream;\n\npublic class SpringSoapInterceptor implements EndpointInterceptor {\n\n @Override\n public boolean handleRequest(MessageContext messageContext, Object endpoint) throws Exception {\n SoapMessage soapMessage = (SoapMessage) messageContext.getRequest();\n\n ByteArrayOutputStream out = new ByteArrayOutputStream();\n soapMessage.writeTo(out);\n\n String rawXml = new String(out.toByteArray());\n System.out.println(\"Request XML:\\n\" + rawXml);\n\n return true;\n }\n\n @Override\n public boolean handleResponse(MessageContext messageContext, Object endpoint) {\n return true;\n }\n\n @Override\n public boolean handleFault(MessageContext messageContext, Object endpoint) {\n return true;\n }\n\n @Override\n public void afterCompletion(MessageContext messageContext, Object endpoint, Exception ex) {}\n}\n<\/pre>\n5.1 Code Explanation<\/h3>\n
SpringSoapInterceptor<\/code> that implements the EndpointInterceptor<\/code> interface to intercept and log SOAP request messages. In the handleRequest<\/code> method, the incoming request is retrieved from the MessageContext<\/code> and cast to a SoapMessage<\/code>, allowing direct access to the SOAP payload. A ByteArrayOutputStream<\/code> is then used to capture the full SOAP message by invoking soapMessage.writeTo()<\/code>, which writes the complete XML (including envelope, header, and body) into the stream. This byte data is converted into a string to obtain the raw XML representation, which is printed to the console with the label “Request XML”. The method returns true<\/code> to allow the request to proceed further in the processing chain. The handleResponse<\/code> and handleFault<\/code> methods simply return true<\/code>, indicating no additional processing for responses or faults, while afterCompletion<\/code> is left empty as no cleanup is required. This interceptor is useful for logging and debugging SOAP requests in Spring WS applications by exposing the exact XML being received.<\/p>\n5.2 Code Output<\/h3>\n
Request XML:\n<soapenv:Envelope xmlns:soapenv=\"http:\/\/schemas.xmlsoap.org\/soap\/envelope\/\">\n <soapenv:Header\/>\n <soapenv:Body>\n <ns:getUser xmlns:ns=\"http:\/\/example.com\">\n <ns:id>101<\/ns:id>\n <\/ns:getUser>\n <\/soapenv:Body>\n<\/soapenv:Envelope>\n<\/pre>\n