XMLSupport (UltraESB - API 2.6.1 API)

All Known Subinterfaces:

SOAPSupport
```
public interface XMLSupport
```
Mediation Support for DOM based mediation

Since:

1.7.0

Author:

asankha

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addAttributeToElements(Message msg, String exprn, String qName, String nsUri, String value, String[]... ns)` Add an attribute to one or more elements selected by an XPath expression e.g.
`void`	`addElementsAsChild(Message msg, String expression, String qualifiedTagName, String namespace, String[]... ns)` Inserts Element as a child to the specified elements pointed by an xpath expression
`void`	`addTextElementsAsChild(Message msg, String expression, String qualifiedTagName, String namespace, String elementContent, String[]... ns)` Inserts Text Element as a child to the specified elements pointed by an xpath expression
`void`	`aggregateWithBean(String beanName, Message msg)` Aggregate message using the Split-Aggregation Spring bean configuration
`void`	`convertDOMToSoap11(Message m)` Converts a DOM message to SOAP 1.1 by wrapping the message in a SOAP envelope and body
`void`	`convertDOMToSoap12(Message m)` Converts a DOM message to SOAP 1.2 by wrapping the message in a SOAP envelope and body
`void`	`convertFromFI(Message m)` Convert the payload of the current message from a FastInfoset binary to an XML message (Note the XML payload is still kept as a RawFileMessage by default and maybe converted into a DOM message if required)
`void`	`convertSoapToDOM(Message m)` Converts a SOAP message to DOM (POX) by stripping out the SOAP Envelope and Body and Header
`void`	`convertToDOM(Message m)` Convert the current message into a DOMMessage
`void`	`convertToFI(Message m)` Convert the XML message into a FastInfoset binary message
`<T> T`	`convertXMLToJAXBObject(Message msg, Class<? extends T> clazz)` Converts a XML payload into a JAXB Object.
`<T> T`	`convertXMLToJAXBObject(Message msg, String contextPath, Class<? extends T> clazz)` Converts a XML payload into a JAXB Object.
`void`	`convertXMLToJSONStream(Message m)` Convert the current XML message payload (which maybe available as any format such as raw file or DOM etc) into a file based JSON stream
`void`	`convertXMLToJSONStream(Message m, QName staringElement, boolean retainNSPrefixes)` Convert the current XML message payload (which maybe available as any format such as raw file or DOM etc) into a file based JSON stream
`Document`	`createDOMDocument()` Create a new DOM Document object and return
`void`	`deleteAttributes(Message msg, String exprn, String[]... ns)` Deletes the specified attribute/s e.g.
`void`	`deleteElements(Message msg, String expression, String[]... ns)` Delete Elements pointed by an xpath expression
`NodeList`	`extractAsNodeListUsingXPath(Message m, String exprn, String[]... ns)` Evaluate the given XPath expression against the XML payload, and return result as a NodeList This method converts the current payload into a DOMMessage
`NodeList`	`extractAsNodeListUsingXPath(Node n, String exprn, String[]... ns)`
`String`	`extractAsStringUsingXPath(Message m, String exprn, String[]... ns)` Evaluate the given XPath expression against the XML payload, and return result as a String This method converts the current payload into a DOMMessage
`String`	`extractAsStringUsingXPath(Node n, String exprn, String[]... ns)` Evaluate the given XPath expression against the DOM node, and return result as a String
`String`	`extractAsStringUsingXPath(String s, String exprn, String[]... ns)` Evaluate the given XPath expression against the XML payload contained in a String, and return result as a String.
`boolean`	`filter(Message m, String exprn, String[]... ns)` Evaluate the given boolean XPath expression over the XML payload
`boolean`	`filter(Message m, String exprn, String regex, String[]... ns)` Evaluate the given XPath expression over the XML payload and compare the resulting String value with the regular expression for a match.
`String`	`getAttribute(Message msg, String exprn, String[]... ns)` Get attribute value e.g.
`Document`	`getPayloadAsDOM(Message m)` Returns payload of the message as a DOM Document
`String`	`getTextElement(Message msg, String exprn, String[]... ns)` Get text element value for given XPath
`void`	`insertTextElementsAfter(Message msg, String expression, String qualifiedTagName, String namespace, String elementContent, String[]... ns)` Inserts an element/elements after the specified element pointed by the XPATH, to the current message.
`void`	`insertTextElementsBefore(Message msg, String expression, String qualifiedTagName, String namespace, String elementContent, String[]... ns)` Inserts an element/elements before the specified element pointed by the XPATH, to the current message.
`void`	`mergeXMLAttachmentsUnderElement(Message msg, String rootElemName)` Replace the current XML payload with a top level element as specified, and merge the payloads from the current body, and attachments underneath that
`void`	`mergeXMLAttachmentsUnderElement(Message msg, String rootElemName, String rootNS)` Replace the current XML payload with a top level element as specified, and merge the payloads from the current body, and attachments underneath that
`boolean`	`remove(Message m, String exprn, String[]... ns)` Remove the XPath expression specified node from the XML payload.
`void`	`replaceAttributes(Message msg, String expression, String value, String[]... ns)` Replaces the specified attribute/s value
`void`	`replaceTextElements(Message msg, String expression, String elementContent, String[]... ns)` Replace Text Elements pointed by an xpath expression
`void`	`retainElementAsPayload(Message m, String exprn, String[]... ns)` Replace the current XML payload with the resulting element from the XPath expression result
`void`	`serializeJAXBObjectAsXMLStream(Message msg, Object jaxb)` Serialize a JAXB Object as a XML Stream message
`void`	`serializeJAXBObjectAsXMLStream(Message msg, Object jaxb, String rootElement, String uri)` Serialize a JAXB Object as a XML Stream message
`void`	`serializeJAXBObjectAsXMLStream(Message msg, String contextPath, Object jaxb)` Serialize a JAXB Object as a XML Stream message
`void`	`serializeJAXBObjectAsXMLStream(Message msg, String contextPath, Object jaxb, String rootElement, String uri)` Serialize a JAXB Object as a XML Stream message
`void`	`setPayloadFromDOM(Message m, Document doc)` Set the payload of the message with the DOM Document
`void`	`splitAndProcess(Message msg, String exprn, String sequenceName, boolean ignoreErrors, String[]... ns)` Split current message into multiple messages using the given XPath expression, and hand over each such message to the given sequence
`void`	`splitWithBean(String beanName, Message msg)` Split message using the Split-Aggregation Spring bean configuration
`void`	`transform(Message msg, String xsltFilename)` Transform the message payload by XSLT (without any parameters), assuming a non DOM result and assuming that the complete message payload will be used as the source of the transformation, and the result will replace the complete message payload
`void`	`transform(Message msg, String xsltFilename, String exprn, boolean domResult, Map<String,Object> parameters, String[]... ns)` Transform the message payload by XSLT
`void`	`transform(Message msg, String xsltFilename, String exprn, String[]... ns)` Transform the message payload by XSLT (without any parameters), assuming a non DOM result
`void`	`validate(Message m, String... schemas)` Validate the current message against one or more schemas If validation failed, this will throw a `BusRuntimeException` with details of the XSD validation failures
`void`	`validate(Message m, String[] schemas, String exprn, String[]... ns)` Validate the current message - or an element of it selected via an XPath expression - against one or more schemas If validation failed, this will throw a `BusRuntimeException` with details of the XSD validation failures
`void`	`validate(Node n, String... schemas)` Validate the given String against one or more schemas If validation failed, this will throw a `BusRuntimeException` with details of the XSD validation failures
`void`	`validate(String s, String... schemas)` Validate the given String against one or more schemas If validation failed, this will throw a `BusRuntimeException` with details of the XSD validation failures
`void`	`validateAll(Message m, String[] schemas, String exprn, String[]... ns)` Validate the current message - or all elements of it selected via an XPath expression - against one or more schemas If validation failed, this will throw a `BusRuntimeException` with details of the XSD validation failures
`void`	`wrapPayload(Message msg, String elementName, String namespace)` Wrap the XML payload with an outer element

- Method Detail
  - createDOMDocument
```
Document createDOMDocument()
```
    Create a new DOM Document object and return
    
    Returns:
    a new DOM Document
  - setPayloadFromDOM
```
void setPayloadFromDOM(Message m,
                     Document doc)
```
    Set the payload of the message with the DOM Document
    
    Parameters:
    m - the current message whose payload will be set with the DOM message
    doc - the DOM document to be inserted as the payload
  - getPayloadAsDOM
```
Document getPayloadAsDOM(Message m)
```
    Returns payload of the message as a DOM Document
    
    Parameters:
    m - the current message to be passed
    
    Returns:
    A DOM document consisting content of the current payload
  - convertToDOM
```
void convertToDOM(Message m)
```
    Convert the current message into a DOMMessage
    
    Parameters:
    m - the current message to be transformed
  - convertFromFI
```
void convertFromFI(Message m)
```
    Convert the payload of the current message from a FastInfoset binary to an XML message (Note the XML payload is still kept as a RawFileMessage by default and maybe converted into a DOM message if required)
    
    Parameters:
    m - the current message to be transformed
  - convertToFI
```
void convertToFI(Message m)
```
    Convert the XML message into a FastInfoset binary message
    
    Parameters:
    m - the current message to be transformed
  - convertDOMToSoap11
```
void convertDOMToSoap11(Message m)
```
    Converts a DOM message to SOAP 1.1 by wrapping the message in a SOAP envelope and body
    
    Parameters:
    m - the current message to be processed
  - convertDOMToSoap12
```
void convertDOMToSoap12(Message m)
```
    Converts a DOM message to SOAP 1.2 by wrapping the message in a SOAP envelope and body
    
    Parameters:
    m - the current message to be processed
  - convertSoapToDOM
```
void convertSoapToDOM(Message m)
```
    Converts a SOAP message to DOM (POX) by stripping out the SOAP Envelope and Body and Header
    
    Parameters:
    m - the current message containing a SOAP payload to convert to DOM/POX
  - convertXMLToJSONStream
```
void convertXMLToJSONStream(Message m,
                          QName staringElement,
                          boolean retainNSPrefixes)
```
    Convert the current XML message payload (which maybe available as any format such as raw file or DOM etc) into a file based JSON stream
    
    Parameters:
    m - the message to be converted
    staringElement - an optional starting element to begin conversion (e.g. first element of the SOAP body)
    retainNSPrefixes - retain the namespace prefixes into JSON names for elements
  - convertXMLToJSONStream
```
void convertXMLToJSONStream(Message m)
```
    Convert the current XML message payload (which maybe available as any format such as raw file or DOM etc) into a file based JSON stream
    
    Parameters:
    m - the message to be converted
  - retainElementAsPayload
```
void retainElementAsPayload(Message m,
                          String exprn,
                          String[]... ns)
```
    Replace the current XML payload with the resulting element from the XPath expression result
    
    Parameters:
    m - the current message
    exprn - XPath expression selecting the node to retain
    ns - optional namespaces array
  - mergeXMLAttachmentsUnderElement
```
void mergeXMLAttachmentsUnderElement(Message msg,
                                   String rootElemName)
```
    Replace the current XML payload with a top level element as specified, and merge the payloads from the current body, and attachments underneath that
    
    Parameters:
    msg - the message to transform
    rootElemName - the new root element created
  - mergeXMLAttachmentsUnderElement
```
void mergeXMLAttachmentsUnderElement(Message msg,
                                   String rootElemName,
                                   String rootNS)
```
    Replace the current XML payload with a top level element as specified, and merge the payloads from the current body, and attachments underneath that
    
    Parameters:
    msg - the message to transform
    rootElemName - the new root element created
    rootNS - optional namespace for the root element, or null
  - validate
```
void validate(Message m,
            String[] schemas,
            String exprn,
            String[]... ns)
```
    Validate the current message - or an element of it selected via an XPath expression - against one or more schemas If validation failed, this will throw a BusRuntimeException with details of the XSD validation failures
    
    Parameters:
    m - the message holding the payload for validation
    schemas - an array of XSD filename to validate against. Note: the validator is sensitive to the order in which the Schemas are given. Otherwise you may end up with an error such as "SAXParseException: cvc-elt.1: Cannot find the declaration of element"
    exprn - an optional XPath expression selecting the node for validation
    ns - an optional array of namespace prefixes and namespaces used within the XPath expression
  - validate
```
void validate(Message m,
            String... schemas)
```
    Validate the current message against one or more schemas If validation failed, this will throw a BusRuntimeException with details of the XSD validation failures
    
    Parameters:
    m - the message holding the payload for validation
    schemas - an array of XSD filename to validate against Note: the validator is sensitive to the order in which the Schemas are given. Otherwise you may end up with an error such as "SAXParseException: cvc-elt.1: Cannot find the declaration of element"
  - validate
```
void validate(String s,
            String... schemas)
```
    Validate the given String against one or more schemas If validation failed, this will throw a BusRuntimeException with details of the XSD validation failures
    
    Parameters:
    s - the XML string
    schemas - an array of XSD filename to validate against Note: the validator is sensitive to the order in which the Schemas are given. Otherwise you may end up with an error such as "SAXParseException: cvc-elt.1: Cannot find the declaration of element"
  - validate
```
void validate(Node n,
            String... schemas)
```
    Validate the given String against one or more schemas If validation failed, this will throw a BusRuntimeException with details of the XSD validation failures
    
    Parameters:
    n - the DOM Node containing the XML to be validated
    schemas - an array of XSD filename to validate against Note: the validator is sensitive to the order in which the Schemas are given. Otherwise you may end up with an error such as "SAXParseException: cvc-elt.1: Cannot find the declaration of element"
  - validateAll
```
void validateAll(Message m,
               String[] schemas,
               String exprn,
               String[]... ns)
```
    Validate the current message - or all elements of it selected via an XPath expression - against one or more schemas If validation failed, this will throw a BusRuntimeException with details of the XSD validation failures
    
    Parameters:
    m - the message holding the payload for validation
    schemas - an array of XSD filename to validate against. Note: the validator is sensitive to the order in which the Schemas are given. Otherwise you may end up with an error such as "SAXParseException: cvc-elt.1: Cannot find the declaration of element"
    exprn - an optional XPath expression selecting the nodes for validation
    ns - an optional array of namespace prefixes and namespaces used within the XPath expression
  - transform
```
void transform(Message msg,
             String xsltFilename,
             String exprn,
             boolean domResult,
             Map<String,Object> parameters,
             String[]... ns)
```
    Transform the message payload by XSLT
    
    Parameters:
    msg - current message
    xsltFilename - the XSLT filename
    exprn - an optional XPath expression to select the source node for XSLT, and node to replace with the result
    domResult - is the result desired as a DOM payload? (useful for further XML processing)
    parameters - any XSLT parameters to be passed to the transformation
    ns - an optional array of namespace prefixes and namespace urls
  - transform
```
void transform(Message msg,
             String xsltFilename,
             String exprn,
             String[]... ns)
```
    Transform the message payload by XSLT (without any parameters), assuming a non DOM result
    
    Parameters:
    msg - current message
    xsltFilename - the XSLT filename
    exprn - an optional XPath expression to select the source node for XSLT, and node to replace with the result
    ns - an optional array of namespace prefixes and namespace urls
  - transform
```
void transform(Message msg,
             String xsltFilename)
```
    Transform the message payload by XSLT (without any parameters), assuming a non DOM result and assuming that the complete message payload will be used as the source of the transformation, and the result will replace the complete message payload
    
    Parameters:
    msg - current message
    xsltFilename - the XSLT filename
  - filter
```
boolean filter(Message m,
             String exprn,
             String regex,
             String[]... ns)
```
    Evaluate the given XPath expression over the XML payload and compare the resulting String value with the regular expression for a match. This method converts the current payload into a DOMMessage
    
    Parameters:
    m - the current message
    exprn - the XPath expression to evaluate against the message payload
    regex - an optional regular expression to evaluate the XPath results' String value against
    ns - an optional array of namespace prefixes and namespace urls
    
    Returns:
    true if the regular expression matches the String result of the XPath expression
  - filter
```
boolean filter(Message m,
             String exprn,
             String[]... ns)
```
    Evaluate the given boolean XPath expression over the XML payload
    
    Parameters:
    m - the current message
    exprn - the XPath expression to evaluate against the message payload
    ns - an optional array of namespace prefixes and namespace urls
    
    Returns:
    true if the XPath expression evaluates to true
  - addAttributeToElements
```
void addAttributeToElements(Message msg,
                          String exprn,
                          String qName,
                          String nsUri,
                          String value,
                          String[]... ns)
```
    Add an attribute to one or more elements selected by an XPath expression e.g. domSupport.addAttributeToElements(msg, "//order/symbol", null, "att1", null, "value1");
    
    Parameters:
    msg - the message where the transformation is performed
    exprn - the xpath expression to select the elements where the attribute should be added
    qName - the qualified name for the new attribute. To specify a custom prefix use it here (e.g. "myns:myqname")
    nsUri - the namespace URI for the new attribute, or null (to specify a custom prefix, see qName above)
    value - the new value of the attribute
    ns - an optional array of namespace prefixes and namespaces used within the XPath expression
  - getAttribute
```
String getAttribute(Message msg,
                  String exprn,
                  String[]... ns)
```
    Get attribute value e.g. domSupport.getAttribute(msg, "//order[1]/symbol/@att1", null)
    
    Parameters:
    msg - the message to read the attribute from
    exprn - the xpath expression to the element where the attribute should be added
    ns - an optional array of namespace prefixes and namespaces used within the XPath expression
    
    Returns:
    the value of the attribute
  - deleteAttributes
```
void deleteAttributes(Message msg,
                    String exprn,
                    String[]... ns)
```
    Deletes the specified attribute/s e.g. domSupport.deleteAttributes(msg, "//order/symbol/@s:att2", ns);
    
    Parameters:
    msg - the current message containing the payload
    exprn - the xpath expression to the attributes, which are to be deleted
    ns - an optional array of namespace prefixes and namespaces used within the XPath expression
  - replaceAttributes
```
void replaceAttributes(Message msg,
                     String expression,
                     String value,
                     String[]... ns)
```
    Replaces the specified attribute/s value
    
    Parameters:
    msg - the current message containing the payload
    expression - the xpath expression to the attribute, which is to be replaced
    value - the new value of the attribute
    ns - an optional array of namespace prefixes and namespaces used within the XPath expression
  - addTextElementsAsChild
```
void addTextElementsAsChild(Message msg,
                          String expression,
                          String qualifiedTagName,
                          String namespace,
                          String elementContent,
                          String[]... ns)
```
    Inserts Text Element as a child to the specified elements pointed by an xpath expression
    
    Parameters:
    msg - the current message containing the payload
    expression - the xpath expression to the node/s, which will be the parent for the new node/s
    qualifiedTagName - the qualified name of the new element to be added
    namespace - an optional String specifying the namespace url of the new element
    elementContent - the text content of the new element
    ns - an optional array of namespace prefixes and namespaces used within the XPath expression
  - addElementsAsChild
```
void addElementsAsChild(Message msg,
                      String expression,
                      String qualifiedTagName,
                      String namespace,
                      String[]... ns)
```
    Inserts Element as a child to the specified elements pointed by an xpath expression
    
    Parameters:
    msg - the current message containing the payload
    expression - the xpath expression to the node/s, which will be the parent for the new node/s
    qualifiedTagName - the qualified name of the new element to be added
    namespace - an optional String specifying the namespace url of the new element
    ns - an optional array of namespace prefixes and namespaces used within the XPath expression
  - getTextElement
```
String getTextElement(Message msg,
                    String exprn,
                    String[]... ns)
```
    Get text element value for given XPath
    
    Parameters:
    msg - the message to read the attribute from
    exprn - the xpath expression to the element where the text content should be read
    ns - an optional array of namespace prefixes and namespaces used within the XPath expression
    
    Returns:
    the value of the attribute
  - replaceTextElements
```
void replaceTextElements(Message msg,
                       String expression,
                       String elementContent,
                       String[]... ns)
```
    Replace Text Elements pointed by an xpath expression
    
    Parameters:
    msg - the current message containing the payload
    expression - the xpath expression to the text elements to be replaced
    elementContent - the text content of the new element/s
    ns - an optional array of namespace prefixes and namespaces used within the XPath expression
  - deleteElements
```
void deleteElements(Message msg,
                  String expression,
                  String[]... ns)
```
    Delete Elements pointed by an xpath expression
    
    Parameters:
    msg - the current message containing the payload
    expression - the xpath expression to the text elements to be replaced
    ns - an optional array of namespace prefixes and namespaces used within the XPath expression
  - insertTextElementsBefore
```
void insertTextElementsBefore(Message msg,
                            String expression,
                            String qualifiedTagName,
                            String namespace,
                            String elementContent,
                            String[]... ns)
```
    Inserts an element/elements before the specified element pointed by the XPATH, to the current message. If the XPath expression points to multiple elements, new element will be added before all the elements pointed by the XPath. The content of the new element should be String. No complex types are allowed.
    
    Parameters:
    msg - the current message containing the payload
    expression - the xpath expression to the node, where the new element should be added before
    qualifiedTagName - the qualified tag name of the new element to be added
    namespace - namespace uri for the new tag
    elementContent - the content of the new element
    ns - an optional array of namespace prefixes and namespaces used within the XPath expression
  - insertTextElementsAfter
```
void insertTextElementsAfter(Message msg,
                           String expression,
                           String qualifiedTagName,
                           String namespace,
                           String elementContent,
                           String[]... ns)
```
    Inserts an element/elements after the specified element pointed by the XPATH, to the current message. If the XPath expression points to multiple elements, new element will be added after all the elements pointed by the XPath.The content of the new element should be String. No complex types are allowed.
    
    Parameters:
    msg - the current message containing the payload
    expression - the xpath expression to the node, where the new element should be added after
    qualifiedTagName - the qualified tag name of the new element to be added
    namespace - namespace uri for the new tag
    elementContent - the content of the new element
    ns - an optional array of namespace prefixes and namespaces used within the XPath expression
  - remove
```
boolean remove(Message m,
             String exprn,
             String[]... ns)
```
    Remove the XPath expression specified node from the XML payload. This method converts the current payload of the message into a DOMMessage
    
    Parameters:
    m - the current message
    exprn - the XPath expression to evaluate against the message payload
    ns - an optional array of namespace prefixes and namespace urls
    
    Returns:
    true if the node was removed, false if not
  - extractAsStringUsingXPath
```
String extractAsStringUsingXPath(Message m,
                               String exprn,
                               String[]... ns)
```
    Evaluate the given XPath expression against the XML payload, and return result as a String This method converts the current payload into a DOMMessage
    
    Parameters:
    m - the current message
    exprn - the XPath expression to evaluate against the message payload
    ns - an optional array of namespace prefixes and namespace urls
    
    Returns:
    the result of the XPath expression as a String, or empty string if there isn't any matching elements
  - extractAsStringUsingXPath
```
String extractAsStringUsingXPath(String s,
                               String exprn,
                               String[]... ns)
```
    Evaluate the given XPath expression against the XML payload contained in a String, and return result as a String. Note that this will convert the given string content into a DOM document and if you by any chance already have access to the equivalent DOM, you should call the #extractAsStringUsingXPath(org.w3c.dom.Node, String, String[]...) instead of this method as that will be much more performance friendly
    
    Parameters:
    s - a String containing an XML payload
    exprn - the XPath expression to evaluate against the XML payload
    ns - an optional array of namespace prefixes and namespace urls
    
    Returns:
    the result of the XPath expression as a String, or empty string if there isn't any matching elements
  - extractAsStringUsingXPath
```
String extractAsStringUsingXPath(Node n,
                               String exprn,
                               String[]... ns)
```
    Evaluate the given XPath expression against the DOM node, and return result as a String
    
    Parameters:
    n - DOM node to be subjected to the evaluation
    exprn - the XPath expression to evaluate against the DOM node
    ns - an optional array of namespace prefixes and namespace urls
    
    Returns:
    the result of the XPath expression evaluation over the given node as a string or empty string if there isn't any matching elements
  - extractAsNodeListUsingXPath
```
NodeList extractAsNodeListUsingXPath(Message m,
                                   String exprn,
                                   String[]... ns)
```
    Evaluate the given XPath expression against the XML payload, and return result as a NodeList This method converts the current payload into a DOMMessage
    
    Parameters:
    m - the current message
    exprn - the XPath expression to evaluate against the message payload
    ns - an optional array of namespace prefixes and namespace urls
    
    Returns:
    the result of the XPath expression as a NodeList, or null
  - extractAsNodeListUsingXPath
```
NodeList extractAsNodeListUsingXPath(Node n,
                                   String exprn,
                                   String[]... ns)
```
  - splitAndProcess
```
void splitAndProcess(Message msg,
                   String exprn,
                   String sequenceName,
                   boolean ignoreErrors,
                   String[]... ns)
                     throws Exception
```
    Split current message into multiple messages using the given XPath expression, and hand over each such message to the given sequence
    
    Parameters:
    msg - the current message to be split and processed
    exprn - the XPath expression to split the message at
    sequenceName - the sequence to invoke on each resulting message
    ignoreErrors - ignore any errors encountered during sequence execution
    ns - name spaces used
    
    Throws:
    
    Exception - if the invoked sequence throws an exception
  - convertXMLToJAXBObject
```
<T> T convertXMLToJAXBObject(Message msg,
                           Class<? extends T> clazz)
```
    Converts a XML payload into a JAXB Object. This does NOT modify the current message
    
    Parameters:
    msg - the current message to read the payload from
    clazz - the JAXB class to convert the payload into
    
    Returns:
    an Object of the specified class if the payload was successfully converted
  - serializeJAXBObjectAsXMLStream
```
void serializeJAXBObjectAsXMLStream(Message msg,
                                  Object jaxb,
                                  String rootElement,
                                  String uri)
```
    Serialize a JAXB Object as a XML Stream message
    
    Parameters:
    msg - the current message to write the Object into as a XML stream
    jaxb - the JAXB Object to serialize
    rootElement - root element local name for serialization
    uri - namespace uri for the root element
  - serializeJAXBObjectAsXMLStream
```
void serializeJAXBObjectAsXMLStream(Message msg,
                                  Object jaxb)
```
    Serialize a JAXB Object as a XML Stream message
    
    Parameters:
    msg - the current message to write the Object into as a SOAP 1.1 stream
    jaxb - the JAXB Object to serialize
  - convertXMLToJAXBObject
```
<T> T convertXMLToJAXBObject(Message msg,
                           String contextPath,
                           Class<? extends T> clazz)
```
    Converts a XML payload into a JAXB Object. This does NOT modify the current message
    
    Parameters:
    msg - the current message to read the payload from
    contextPath - a list of colon separated java package names that contain schema-derived classes and/or fully qualified JAXB-annotated classes
    clazz - the JAXB class to convert the payload into
    
    Returns:
    an Object of the specified class if the payload was successfully converted
  - serializeJAXBObjectAsXMLStream
```
void serializeJAXBObjectAsXMLStream(Message msg,
                                  String contextPath,
                                  Object jaxb)
```
    Serialize a JAXB Object as a XML Stream message
    
    Parameters:
    msg - the current message to write the Object into as a SOAP 1.1 stream
    contextPath - a list of colon separated java package names that contain schema-derived classes and/or fully qualified JAXB-annotated classes
    jaxb - the JAXB Object to serialize
  - serializeJAXBObjectAsXMLStream
```
void serializeJAXBObjectAsXMLStream(Message msg,
                                  String contextPath,
                                  Object jaxb,
                                  String rootElement,
                                  String uri)
```
    Serialize a JAXB Object as a XML Stream message
    
    Parameters:
    msg - the current message to write the Object into as a XML stream
    contextPath - a list of colon separated java package names that contain schema-derived classes and/or fully qualified JAXB-annotated classes
    jaxb - the JAXB Object to serialize
    rootElement - root element local name for serialization
    uri - namespace uri for the root element
  - splitWithBean
```
void splitWithBean(String beanName,
                 Message msg)
```
    Split message using the Split-Aggregation Spring bean configuration
    
    Parameters:
    beanName - name of the Spring bean implementing the split-aggregate support
    msg - the message to be split based on the Split-Aggregation Spring bean
  - aggregateWithBean
```
void aggregateWithBean(String beanName,
                     Message msg)
```
    Aggregate message using the Split-Aggregation Spring bean configuration
    
    Parameters:
    beanName - name of the Spring bean implementing the split-aggregate support
    msg - the message to be aggregated based on the Split-Aggregation Spring bean
  - wrapPayload
```
void wrapPayload(Message msg,
               String elementName,
               String namespace)
```
    Wrap the XML payload with an outer element
    
    Parameters:
    msg - the message containing the payload to be wrapped
    elementName - name of the wrapper element
    namespace - optional namespace or null

Interface XMLSupport

Method Summary

Method Detail

createDOMDocument

setPayloadFromDOM

getPayloadAsDOM

convertToDOM

convertFromFI

convertToFI

convertDOMToSoap11

convertDOMToSoap12

convertSoapToDOM

convertXMLToJSONStream

convertXMLToJSONStream

retainElementAsPayload

mergeXMLAttachmentsUnderElement

mergeXMLAttachmentsUnderElement

validate

validate

validate

validate

validateAll

transform

transform

transform

filter

filter

addAttributeToElements

getAttribute

deleteAttributes

replaceAttributes

addTextElementsAsChild

addElementsAsChild

getTextElement

replaceTextElements

deleteElements

insertTextElementsBefore

insertTextElementsAfter

remove

extractAsStringUsingXPath

extractAsStringUsingXPath

extractAsStringUsingXPath

extractAsNodeListUsingXPath

extractAsNodeListUsingXPath

splitAndProcess

convertXMLToJAXBObject

serializeJAXBObjectAsXMLStream

serializeJAXBObjectAsXMLStream

convertXMLToJAXBObject

serializeJAXBObjectAsXMLStream

serializeJAXBObjectAsXMLStream

splitWithBean

aggregateWithBean

wrapPayload