1. Introduction
In this tutorial, we’ll explore how to convert a raw SOAP XML string into a usable SOAPMessage object in Java.
A SOAPMessage is part of the Java API for XML-based messaging (SAAJ) and represents a complete SOAP request or response, including the envelope, headers, and body.
2. Using SAAJ MessageFactory
The first approach uses the standard MessageFactory provided by the javax.xml.soap package. This factory creates a SOAPMessage directly from an input stream. The raw string is converted into a byte stream and passed to the factory, which builds a structured SOAP message.
Below is the implementation of a utility method named usingSAAJMessageFactory(), which performs this conversion:
static SOAPMessage usingSAAJMessageFactory(String soapXml) throws Exception {
ByteArrayInputStream input = new ByteArrayInputStream(soapXml.getBytes(StandardCharsets.UTF_8));
MessageFactory factory = MessageFactory.newInstance();
return factory.createMessage(null, input);
}
In the example above, we first convert the raw SOAP string into a byte-based input stream. This is because the createMessage() method in MessageFactory expects an InputStream. We use StandardCharsets.UTF_8 to ensure the character encoding is preserved during the conversion.
Once the stream is prepared, we invoke MessageFactory.newInstance() to get the default implementation, and then call createMessage() to parse the stream into a SOAPMessage.
Next, we prepare a sample SOAP string that represents a stock price request:
String xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
"<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\">" +
"<soapenv:Header/>" +
"<soapenv:Body>" +
"<m:GetStockPrice xmlns:m=\"http://example.com/stock\">" +
"<m:StockName>GOOG</m:StockName>" +
"</m:GetStockPrice>" +
"</soapenv:Body>" +
"</soapenv:Envelope>";
SOAPMessage message = SoapParser.usingSAAJMessageFactory(xml);
Let’s verify the correctness of the result using a few assertions:
SOAPBody body = message.getSOAPBody();
assertNotNull(message, "SOAPMessage should not be null");
assertNotNull(body, "SOAP Body should not be null");
assertTrue(body.getTextContent().contains("GOOG"), "Expected 'GOOG' not found in the SOAP body");
This solution is ideal for situations where we need full access to the components of a SOAP message, including the envelope, headers, and body.
3. Using DOM Parsing
An alternative approach to constructing a SOAPMessage from a string is to first parse the XML into a Document object using the DOM (Document Object Model) API, and then use that DOM representation to populate a SOAPPart.
Let’s define a utility method named usingDOMParsing() that demonstrates this approach:
static SOAPMessage usingDOMParsing(String soapXml) throws Exception {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setNamespaceAware(true);
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(new ByteArrayInputStream(soapXml.getBytes(StandardCharsets.UTF_8)));
MessageFactory factory = MessageFactory.newInstance();
SOAPMessage message = factory.createMessage();
SOAPPart part = message.getSOAPPart();
part.setContent(new DOMSource(doc.getDocumentElement()));
message.saveChanges();
return message;
}
In this method, we begin by creating a DocumentBuilderFactory with namespace awareness enabled – this is essential for parsing SOAP messages correctly, as SOAP heavily relies on XML namespaces. We then build a DocumentBuilder and use it to parse the input SOAP string into a Document object.
Once we have the DOM representation of the SOAP content, we initialize a SOAPMessage using MessageFactory. We retrieve the SOAPPart of this message and use the setContent() method to replace its content with a DOMSource wrapping the root element of our parsed document.
Finally, we call saveChanges() to finalize the message structure.
To test this implementation, we can use the same sample SOAP XML string as before:
SOAPMessage message = SoapParser.usingDOMParsing(xml);
We then apply similar assertions to verify the correctness of the resulting SOAPMessage:
SOAPBody body = message.getSOAPBody();
assertNotNull(message, "SOAPMessage should not be null");
assertNotNull(body, "SOAP Body should not be null");
assertTrue(body.getTextContent().contains("GOOG"), "Expected 'GOOG' not found in the SOAP body");
This approach gives us more flexibility, especially if we need to change the XML structure before creating the SOAPMessage. It’s also useful when working with systems that already use Document objects to handle XML.
4. Conclusion
In this article, we’ve learned how to convert a SOAP XML string into a SOAPMessage. The MessageFactory approach is simpler and ideal for straightforward conversions. The DOM-based method offers more control and is useful when we need to work with or modify the XML before building the SOAP message.
The code backing this article is available on GitHub. Once you're
logged in as a Baeldung Pro Member, start learning and coding on the project.
