Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://www.springframework.org/schema/integration/xml"
		xmlns:xsd="http://www.w3.org/2001/XMLSchema"
		xmlns:beans="http://www.springframework.org/schema/beans"
		xmlns:tool="http://www.springframework.org/schema/tool"
		xmlns:integration="http://www.springframework.org/schema/integration"
		targetNamespace="http://www.springframework.org/schema/integration/xml"
		elementFormDefault="qualified" attributeFormDefault="unqualified">

	<xsd:import namespace="http://www.springframework.org/schema/beans" />
	<xsd:import namespace="http://www.springframework.org/schema/tool" />
	<xsd:import namespace="http://www.springframework.org/schema/integration"
			schemaLocation="http://www.springframework.org/schema/integration/spring-integration-4.0.xsd"/>

	<xsd:annotation>
		<xsd:documentation>
	Defines the configuration elements for Spring Integration's XML support.
		</xsd:documentation>
	</xsd:annotation>

	<xsd:element name="marshalling-transformer">
		<xsd:annotation>
			<xsd:documentation>
				Defines an XML marshalling transformer.
			</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType >
			<xsd:complexContent>
				<xsd:extension base="inputOutputEndpoint">
					<xsd:attribute name="marshaller" type="xsd:string" use="required">
						<xsd:annotation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="org.springframework.oxm.Marshaller"/>
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="result-type" use="optional">
						<xsd:simpleType>
							<xsd:restriction base="xsd:string">
								<xsd:enumeration value="DOMResult"/>
								<xsd:enumeration value="StringResult"/>
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:attribute>
					<xsd:attribute name="result-factory" type="xsd:string" use="optional">
						<xsd:annotation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="org.springframework.integration.xml.result.ResultFactory"/>
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="result-transformer" type="xsd:string" use="optional">
						<xsd:annotation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="org.springframework.integration.xml.transformer.ResultTransformer"/>
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="extract-payload" type="xsd:string" default="true">
						<xsd:annotation>
							<xsd:documentation>
	Specify whether to extract the payload before passing to the Marshaller. By default, this
	value is "true". To have the full Message passed instead, set this to "false".
							</xsd:documentation>
						</xsd:annotation>
					</xsd:attribute>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>

	<xsd:element name="unmarshalling-transformer">
		<xsd:annotation>
			<xsd:documentation>
				Defines an XML unmarshalling transformer.
			</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="inputOutputEndpoint">
					<xsd:attribute name="unmarshaller" type="xsd:string" use="required">
						<xsd:annotation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="org.springframework.oxm.Unmarshaller"/>
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>

	<xsd:element name="xslt-transformer">
		<xsd:annotation>
			<xsd:documentation>
				Defines an XSLT transformer.
			</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="inputOutputEndpoint">
					<xsd:sequence>
						<xsd:element name="xslt-param" type="paramType" minOccurs="0" maxOccurs="unbounded">
						<xsd:annotation>
							<xsd:documentation><![CDATA[
								Allows to configure individual Xslt parameters.
								There the 'expression' and 'value' attribute are
								available. The expression attribute should be
								any valid SpEL expression with the message being
								the root object of the expression evaluation
								context.

								The value attribute, just like any value in Spring
								beans, allows you to specify simple static values.

								You can also use property placeholders (e.g.,
								${some.value}).
							]]></xsd:documentation>
						</xsd:annotation>
						</xsd:element>
					</xsd:sequence>
					<xsd:attribute name="xslt-param-headers" type="xsd:string" use="optional">
						<xsd:annotation>
							<xsd:documentation><![CDATA[
								If message header names match 1:1 to parameter
								names, you can use this attribute to make
								the parameters available.

								The use of wildcards for simple pattern
								matching is also possible. It supports the
								following simple pattern styles: 'xxx*', '*xxx',
								'*xxx*' and 'xxx*yyy'.
							]]></xsd:documentation>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="xsl-resource" type="xsd:string" use="optional">
						<xsd:annotation>
							<xsd:documentation><![CDATA[
								Allows you to specify a org.springframework.core.io.Resource,
								which will be used to create the javax.xml.transform.Templates
								instance.

								Either this attribute or the 'xsl-templates'
								attribute MUST be specified.
							]]></xsd:documentation>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="xsl-templates" type="xsd:string" use="optional">
						<xsd:annotation>
							<xsd:documentation><![CDATA[
								Reference to a Templates instance.

								Either this attribute or the 'xsl-resource'
								attribute MUST be specified.
							]]></xsd:documentation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="javax.xml.transform.Templates"/>
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="source-factory" type="xsd:string" use="optional">
						<xsd:annotation>
							<xsd:documentation><![CDATA[
								Reference to a 'SourceFactory' instance. Allows
								for the custom conversion to a javax.xml.transform.Source
								If not set, this property will internally default
								to 'DomSourceFactory'.
							]]></xsd:documentation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="org.springframework.integration.xml.source.SourceFactory"/>
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="result-factory" type="xsd:string" use="optional">
						<xsd:annotation>
							<xsd:documentation><![CDATA[
								Reference to a custom implementation of 'ResultFactory'.
								If this attribute is provided, you must not specify
								the 'result-type' attribute.
							]]></xsd:documentation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="org.springframework.integration.xml.result.ResultFactory"/>
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="result-type" use="optional">
						<xsd:annotation>
							<xsd:documentation><![CDATA[
								This attribute can be used to control the type
								of result created.

								If this attribute is provided, you must not specify
								the 'result-factory' attribute.

								If neither this property nor the 'result-factory'
								attribute are provided, 'DomResult' will be used.
							]]></xsd:documentation>
						</xsd:annotation>
						<xsd:simpleType>
							<xsd:restriction base="xsd:string">
								<xsd:enumeration value="DOMResult"/>
								<xsd:enumeration value="StringResult"/>
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:attribute>
					<xsd:attribute name="result-transformer" type="xsd:string" use="optional">
						<xsd:annotation>
							<xsd:documentation><![CDATA[
								If the XSLT transformation returns a 'Result' object,
								than you have the option to specify a reference
								to a 'ResultTransformer' instance. This allows
								you to transform the 'Result' into another format.

								By default 2 implementations are available:

								- 'ResultToDocumentTransformer' and
								- 'ResultToStringTransformer'
							]]></xsd:documentation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="org.springframework.integration.xml.transformer.ResultTransformer"/>
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="transformer-factory-class" type="xsd:string" use="optional">
						<xsd:annotation>
							<xsd:documentation><![CDATA[
								A fully qualified class name to a transformer factory
								class that overrides the current JVM default.
							]]></xsd:documentation>
							<xsd:appinfo>
								<xsd:appinfo>
									<tool:annotation kind="direct">
										<tool:expected-type type="java.lang.Class"/>
									</tool:annotation>
								</xsd:appinfo>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>

	<xsd:element name="xpath-transformer">
		<xsd:annotation>
			<xsd:documentation>
				Defines an XPath transformer.
			</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="inputOutputEndpoint">
					<xsd:attribute name="xpath-expression" type="xsd:string">
						<xsd:annotation>
							<xsd:documentation>
	The XPath expression string to be evaluated against the input Message's payload.
	Either this or 'xpath-expression-ref' must be provided, but not both.
							</xsd:documentation>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="xpath-expression-ref" type="xsd:string">
						<xsd:annotation>
							<xsd:documentation>
	Reference to the XPathExpression instance to be evaluated against the input Message's payload.
	Either this or 'xpath-expression' must be provided, but not both.
							</xsd:documentation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="org.springframework.xml.xpath.XPathExpression"/>
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="evaluation-type" default="STRING_RESULT">
						<xsd:annotation>
							<xsd:documentation>
	The result type expected from the XPath evaluation. This will be the payload type of the output Message.
							</xsd:documentation>
						</xsd:annotation>
						<xsd:simpleType>
							<xsd:restriction base="xsd:string">
								<xsd:enumeration value="BOOLEAN_RESULT"/>
								<xsd:enumeration value="STRING_RESULT"/>
								<xsd:enumeration value="NUMBER_RESULT"/>
								<xsd:enumeration value="NODE_RESULT"/>
								<xsd:enumeration value="NODE_LIST_RESULT"/>
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:attribute>
					<xsd:attribute name="node-mapper">
						<xsd:annotation>
							<xsd:documentation>
	Reference to a NodeMapper. If this is provided, the 'evaluation-type' will be ignored. Instead, the
	org.springframework.xml.xpath.XPathExpression's evaluateAsObject(Node node, NodeMapper nodeMapper)
	method will be invoked.
							</xsd:documentation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="org.springframework.xml.xpath.NodeMapper"/>
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="converter">
						<xsd:annotation>
							<xsd:documentation>
	Specify the XmlPayloadConverter to use when converting a Message payload prior to XPath evaluation.
	The DefaultXmlPayloadConverter is used if this reference is not provided, and it
	should be sufficient in most cases since it can convert from Node, Document, Source,
	File, and String typed payloads. If you need to extend beyond the capabilities of
	that default implementation, then an upstream Transformer is probably a better option
	than providing a reference to a custom implementation of this strategy here.
							</xsd:documentation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="org.springframework.integration.xml.XmlPayloadConverter"/>
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>

	<xsd:element name="xpath-header-enricher">
		<xsd:annotation>
			<xsd:documentation>
	Defines a Header Enricher Message Transformer that evaluates XPath expressions against the
	message payload and inserts the result of the evaluation into a message header.
			</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="inputOutputEndpoint">
					<xsd:sequence minOccurs="1" maxOccurs="unbounded">
						<xsd:element type="xpathHeaderType" name="header"/>
					</xsd:sequence>
					<xsd:attribute name="default-overwrite">
						<xsd:annotation>
							<xsd:documentation>
	Specify the default boolean value for whether to overwrite existing header values. This will
	only take effect for sub-elements that do not provide their own 'overwrite' attribute. If the
	'default-overwrite' attribute is not provided, then the specified header values will NOT
	overwrite any existing ones with the same header names.
							</xsd:documentation>
						</xsd:annotation>
						<xsd:simpleType>
							<xsd:union memberTypes="xsd:boolean xsd:string" />
						</xsd:simpleType>
					</xsd:attribute>
					<xsd:attribute name="should-skip-nulls">
						<xsd:annotation>
							<xsd:documentation>
	Specify whether null values, such as might be returned from an expression evaluation, should be
	skipped. The default value is true. Set this to false if a null value should trigger removal of
	the corresponding header instead.
							</xsd:documentation>
						</xsd:annotation>
						<xsd:simpleType>
							<xsd:union memberTypes="xsd:boolean xsd:string" />
						</xsd:simpleType>
					</xsd:attribute>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>

	<xsd:complexType name="xpathHeaderType">
		<xsd:annotation>
			<xsd:documentation>
	Defines an XPath expression to be configured within an &lt;xpath-header-enricher/&gt; element.
			</xsd:documentation>
		</xsd:annotation>
		<xsd:attribute name="name" type="xsd:string" use="required">
			<xsd:annotation>
				<xsd:documentation>
	The name of the header to be enriched.
				</xsd:documentation>
			</xsd:annotation>
		</xsd:attribute>
		<xsd:attribute name="xpath-expression">
			<xsd:annotation>
				<xsd:documentation>
	The XPath Expression as a String. Either this or 'xpath-expression-ref' must be provided, but not both.
				</xsd:documentation>
			</xsd:annotation>
		</xsd:attribute>
		<xsd:attribute name="xpath-expression-ref">
			<xsd:annotation>
				<xsd:documentation>
	The XPath Expression reference. Either this or 'xpath-expression' must be provided, but not both.
				</xsd:documentation>
				<xsd:appinfo>
					<tool:annotation kind="ref">
						<tool:expected-type type="org.springframework.xml.xpath.XPathExpression"/>
					</tool:annotation>
				</xsd:appinfo>
			</xsd:annotation>
		</xsd:attribute>
		<xsd:attribute name="evaluation-type" default="STRING_RESULT">
			<xsd:annotation>
				<xsd:documentation>
	The result type expected from the XPath evaluation. This will be the type of the header value.
				</xsd:documentation>
			</xsd:annotation>
			<xsd:simpleType>
				<xsd:restriction base="xsd:string">
					<xsd:enumeration value="BOOLEAN_RESULT"/>
					<xsd:enumeration value="STRING_RESULT"/>
					<xsd:enumeration value="NUMBER_RESULT"/>
					<xsd:enumeration value="NODE_RESULT"/>
					<xsd:enumeration value="NODE_LIST_RESULT"/>
				</xsd:restriction>
			</xsd:simpleType>
		</xsd:attribute>
		<xsd:attribute name="overwrite">
			<xsd:annotation>
				<xsd:documentation>
	Boolean value to indicate whether this header value should overwrite an existing header value
	for the same name if already present on the input Message.
				</xsd:documentation>
			</xsd:annotation>
			<xsd:simpleType>
				<xsd:union memberTypes="xsd:boolean xsd:string" />
			</xsd:simpleType>
		</xsd:attribute>
		<xsd:attribute name="header-type" type="xsd:string">
			<xsd:annotation>
				<xsd:documentation source="java:java.lang.Class"><![CDATA[
	The fully qualified class name of the header value's expected type.
						]]></xsd:documentation>
			</xsd:annotation>
		</xsd:attribute>
	</xsd:complexType>

	<!-- XPath Router definition -->

	<xsd:complexType name="commonXPathRouterType" abstract="true">
		<xsd:complexContent>
			<xsd:extension base="integration:abstractRouterType">
			<xsd:attribute name="evaluate-as-string" default="false">
				<xsd:annotation>
					<xsd:documentation><![CDATA[
						By default XPath expressions are evaluated as NODESET type and then converted
						to a List of channel names, thus handling single channel scenarios as well as multiple.
						However certain XPath expressions may evaluate to String type results from the very
						beginning (e.g., 'name(./node())' - which will return the name of the root node) thus resulting in
						an exception if the default evaluation type (NODESET) is used.

						This flag will allow you to manage the
						evaluation type. It is 'false' by default, however if
						set to 'true', then the String evaluation type will be used.
					]]></xsd:documentation>
				</xsd:annotation>
					<xsd:simpleType>
						<xsd:union memberTypes="xsd:boolean xsd:string" />
					</xsd:simpleType>
				</xsd:attribute>
				<xsd:attribute name="xpath-expression-ref" type="xsd:string" use="optional">
					<xsd:annotation>
						<xsd:documentation>
							Reference to the XPathExpression instance to be
							evaluated against the input Message's payload. Either
							this or 'xpath-expression' must be provided, but not
							both.
						</xsd:documentation>
						<xsd:appinfo>
							<tool:annotation kind="ref">
								<tool:expected-type type="org.springframework.xml.xpath.XPathExpression"/>
							</tool:annotation>
						</xsd:appinfo>
					</xsd:annotation>
				</xsd:attribute>
			</xsd:extension>
		</xsd:complexContent>
	</xsd:complexType>

	<xsd:complexType name="XPathRouterType">
		<xsd:complexContent>
			<xsd:extension base="commonXPathRouterType">
				<xsd:sequence>
					<xsd:element ref="integration:poller" minOccurs="0" maxOccurs="1"/>
					<xsd:element ref="xpath-expression"   minOccurs="0" maxOccurs="1">
						<xsd:annotation>
							<xsd:documentation><![CDATA[
								Internally XPath expressions will be evaluated as
								NODESET type and converted to a List<String>
								representing channel names. Typically such a list
								will contain a single channel name. However,
								based on the results of an XPath Expression, the
								XPath router can also take on the characteristics
								of a Recipient List Router if the XPath Expression
								returns more then one value. In that case, the
								List<String> will contain more then one channel
								name and consequently Messages will be sent to
								all channels in the list.
							]]></xsd:documentation>
						</xsd:annotation>
					</xsd:element>
					<xsd:element name="mapping" type="integration:mappingValueChannelType" minOccurs="0" maxOccurs="unbounded">
						<xsd:annotation>
							<xsd:documentation><![CDATA[
								If the values returned by the XPath Expression
								do not represent the channel names themselves, additional
								mappings can be specified using the "mapping" sub-element.

								For example if the '/request/responders' expression
								results in two values: 'responderA' and 'responderB',
								but you don't want to couple the responder names
								to channel names you may provide additional mappings
								such as:

								<int-xml:mapping value="responderA" channel="channelA"/>
								<int-xml:mapping value="responderB" channel="channelB"/>
								]]>
							</xsd:documentation>
						</xsd:annotation>
					</xsd:element>
					</xsd:sequence>
					<xsd:attributeGroup ref="integration:topLevelRouterAttributeGroup"/>
					<xsd:attribute name="converter" type="xsd:string">
					<xsd:annotation>
						<xsd:documentation>
							Specify the Converter to use when converting payloads prior to XPath evaluation.
							The DefaultXmlPayloadConverter is used if this reference is not provided, and it
							should be sufficient in most cases since it can convert from Node, Document, Source,
							File, and String typed payloads. If you need to extend beyond the capabilities of
							that default implementation, then an upstream Transformer is probably a better option
							than providing a reference to a custom implementation of this strategy here.
						</xsd:documentation>
						<xsd:appinfo>
							<tool:annotation kind="ref">
								<tool:expected-type type="org.springframework.integration.xml.XmlPayloadConverter"/>
							</tool:annotation>
						</xsd:appinfo>
					</xsd:annotation>
				</xsd:attribute>
			</xsd:extension>
		</xsd:complexContent>
	</xsd:complexType>

	<xsd:complexType name="XPathRouterTypeChain">
		<xsd:complexContent>
			<xsd:extension base="commonXPathRouterType">
				<xsd:sequence>
					<xsd:element ref="xpath-expression"                                    minOccurs="0" maxOccurs="1">
						<xsd:annotation>
							<xsd:documentation><![CDATA[
								Internally XPath expressions will be evaluated as
								NODESET type and converted to a List<String>
								representing channel names. Typically such a list
								will contain a single channel name. However,
								based on the results of an XPath Expression, the
								XPath router can also take on the characteristics
								of a Recipient List Router if the XPath Expression
								returns more then one value. In that case, the
								List<String> will contain more then one channel
								name and consequently Messages will be sent to
								all channels in the list.
							]]></xsd:documentation>
						</xsd:annotation>
					</xsd:element>
					<xsd:element name="mapping" type="integration:mappingValueChannelType" minOccurs="0" maxOccurs="unbounded">
						<xsd:annotation>
							<xsd:documentation><![CDATA[
								If the values returned by the XPath Expression
								do not represent the channel names themselves, additional
								mappings can be specified using the "mapping" sub-element.

								For example if the '/request/responders' expression
								results in two values: 'responderA' and 'responderB',
								but you don't want to couple the responder names
								to channel names you may provide additional mappings
								such as:

								<int-xml:mapping value="responderA" channel="channelA"/>
								<int-xml:mapping value="responderB" channel="channelB"/>
								]]>
							</xsd:documentation>
						</xsd:annotation>
					</xsd:element>
				</xsd:sequence>
			</xsd:extension>
		</xsd:complexContent>
	</xsd:complexType>

	<xsd:element name="xpath-router" type="XPathRouterType">
		<xsd:annotation>
			<xsd:documentation><![CDATA[
				Defines an XPath Router which allows for the routing of messages
				using XPath expressions. This Message Endpoint has no output
				channel. Instead, one or more output channels are determined
				dynamically using the provided XPath Expression.
			]]></xsd:documentation>
		</xsd:annotation>
	</xsd:element>

	<xsd:element name="xpath-filter">
		<xsd:annotation>
			<xsd:documentation>
	Defines an XPath-based Message Filter. If the XPath expression will evaluate to a boolean,
	no configuration attributes are required. If the XPath expression will evaluate to a String,
	a "match-value" should be provided against which the evaluation result will be matched.
	There are three options for the "match-type": exact, case-insensitive, and regex. These
	correspond to the equals, equals-ignore-case, and matches operations on java.lang.String,
	respectively. When providing a 'match-type' value of 'regex', the value provided in
	'match-value' must be a valid Regular Expression.
			</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="baseFilterType">
					<xsd:sequence>
						<xsd:element ref="xpath-expression" minOccurs="0" maxOccurs="1">
							<xsd:annotation>
								<xsd:documentation>
									The XPath expression to evaluate.
								</xsd:documentation>
							</xsd:annotation>
						</xsd:element>
					</xsd:sequence>
					<xsd:attribute name="xpath-expression-ref" type="xsd:string" use="optional">
						<xsd:annotation>
							<xsd:documentation>
								Reference to an XPath expression instance to evaluate.
							</xsd:documentation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="org.springframework.xml.xpath.XPathExpression"/>
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="match-value" type="xsd:string">
						<xsd:annotation>
							<xsd:documentation>
								String value to be matched against the XPath evaluation result. If this is not provided,
								then the XPath evaluation MUST produce a boolean result directly.
							</xsd:documentation>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="match-type" default="exact">
						<xsd:annotation>
							<xsd:documentation>
								Type of match to apply between the XPath evaluation result and the 'match-value'.
								Default is "exact".
							</xsd:documentation>
						</xsd:annotation>
						<xsd:simpleType>
							<xsd:union memberTypes="matchTypeEnumeration xsd:string" />
						</xsd:simpleType>
					</xsd:attribute>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>

	<xsd:simpleType name="matchTypeEnumeration">
		<xsd:restriction base="xsd:token">
			<xsd:enumeration value="exact"/>
			<xsd:enumeration value="case-insensitive"/>
			<xsd:enumeration value="regex"/>
		</xsd:restriction>
	</xsd:simpleType>

	<xsd:element name="xpath-expression">
		<xsd:annotation>
			<xsd:documentation><![CDATA[
				Defines an XPath expression.

				Internally XPath expressions will be evaluated as
				NODESET type and converted to a List<String>
				representing channel names. Typically such a list
				will contain a single channel name. However, based
				on the result of an XPath Expression the XPath router
				can also take on the characteristics of the
				Recipient List Router if the XPath Expression
				returns more than one value, thus resulting in
				the List<String> containing more than one channel
				name.

				In that case the Message will be sent to all channels
				in the list.
			]]></xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:sequence>
				<xsd:element ref="beans:map" minOccurs="0" maxOccurs="1"/>
			</xsd:sequence>
			<xsd:attribute name="id" type="xsd:string" use="optional"/>
			<xsd:attribute name="expression" type="xsd:string" use="required"/>
			<xsd:attribute name="ns-prefix" type="xsd:string" use="optional"/>
			<xsd:attribute name="ns-uri" type="xsd:string" use="optional"/>
			<xsd:attribute name="namespace-map" type="xsd:string" use="optional"/>
		</xsd:complexType>
	</xsd:element>

	<xsd:element name="xpath-splitter">
		<xsd:annotation>
			<xsd:documentation>
	Defines an XPath splitter.
			</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="inputOutputEndpoint">
					<xsd:sequence>
						<xsd:element ref="xpath-expression" minOccurs="0" maxOccurs="1"/>
					</xsd:sequence>
					<xsd:attribute name="xpath-expression-ref" type="xsd:string" use="optional">
						<xsd:annotation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="org.springframework.xml.xpath.XPathExpression"/>
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="doc-builder-factory" type="xsd:string" use="optional">
						<xsd:annotation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="javax.xml.parsers.DocumentBuilderFactory"/>
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="create-documents" type="xsd:string" use="optional"/>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>

	<xsd:element name="validating-filter">
		<xsd:annotation>
			<xsd:documentation>
	Defines an XML validating filter.
			</xsd:documentation>
		</xsd:annotation>
		<xsd:complexType>
			<xsd:complexContent>
				<xsd:extension base="baseFilterType">
					<xsd:attribute name="xml-validator" type="xsd:string">
						<xsd:annotation>
							<xsd:documentation>
								Reference to a custom 'org.springframework.xml.validation.XmlValidator' strategy
							</xsd:documentation>
							<xsd:appinfo>
								<tool:annotation kind="ref">
									<tool:expected-type type="org.springframework.xml.validation.XmlValidator" />
								</tool:annotation>
							</xsd:appinfo>
						</xsd:annotation>
					</xsd:attribute>
					<xsd:attribute name="schema-location"/>
					<xsd:attribute name="schema-type" default="xml-schema">
						<xsd:simpleType>
							<xsd:restriction base="xsd:string">
								<xsd:enumeration value="xml-schema"/>
								<xsd:enumeration value="relax-ng"/>
							</xsd:restriction>
						</xsd:simpleType>
					</xsd:attribute>
				</xsd:extension>
			</xsd:complexContent>
		</xsd:complexType>
	</xsd:element>

	<xsd:complexType name="baseFilterType">
		<xsd:annotation>
			<xsd:documentation>
	Base type for XML filters.
			</xsd:documentation>
		</xsd:annotation>
		<xsd:sequence>
			<xsd:element ref="integration:poller" minOccurs="0" maxOccurs="1"/>
		</xsd:sequence>
		<xsd:attribute name="id" type="xsd:string"/>
		<xsd:attribute name="input-channel" type="xsd:string">
			<xsd:annotation>
				<xsd:appinfo>
					<tool:annotation kind="ref">
						<tool:expected-type type="org.springframework.messaging.MessageChannel"/>
					</tool:annotation>
				</xsd:appinfo>
			</xsd:annotation>
		</xsd:attribute>
		<xsd:attribute name="output-channel" type="xsd:string">
			<xsd:annotation>
				<xsd:documentation>
					Message Channel where you want accepted messages to be sent.
				</xsd:documentation>
				<xsd:appinfo>
					<tool:annotation kind="ref">
						<tool:expected-type type="org.springframework.messaging.MessageChannel" />
					</tool:annotation>
				</xsd:appinfo>
			</xsd:annotation>
		</xsd:attribute>
		<xsd:attribute name="discard-channel" type="xsd:string">
			<xsd:annotation>
				<xsd:documentation>
					Message Channel where you want rejected messages to be sent.
				</xsd:documentation>
				<xsd:appinfo>
					<tool:annotation kind="ref">
						<tool:expected-type type="org.springframework.messaging.MessageChannel" />
					</tool:annotation>
				</xsd:appinfo>
			</xsd:annotation>
		</xsd:attribute>
		<xsd:attribute name="throw-exception-on-rejection" type="xsd:boolean" default="false"/>
	</xsd:complexType>

	<xsd:complexType name="inputOutputEndpoint">
		<xsd:sequence>
			<xsd:element ref="integration:poller" minOccurs="0" maxOccurs="1"/>
		</xsd:sequence>
		<xsd:attribute name="id" type="xsd:string"/>
		<xsd:attribute name="input-channel" type="xsd:string">
			<xsd:annotation>
				<xsd:appinfo>
					<tool:annotation kind="ref">
						<tool:expected-type type="org.springframework.messaging.MessageChannel"/>
					</tool:annotation>
				</xsd:appinfo>
			</xsd:annotation>
		</xsd:attribute>
		<xsd:attribute name="output-channel" type="xsd:string">
			<xsd:annotation>
				<xsd:appinfo>
					<tool:annotation kind="ref">
						<tool:expected-type type="org.springframework.messaging.MessageChannel"/>
					</tool:annotation>
				</xsd:appinfo>
			</xsd:annotation>
		</xsd:attribute>
	</xsd:complexType>

	<xsd:complexType name="paramType">
			<xsd:attribute name="name" type="xsd:string" use="required"/>
			<xsd:attribute name="expression" type="xsd:string" use="optional"/>
			<xsd:attribute name="value" type="xsd:string" use="optional"/>
	</xsd:complexType>

</xsd:schema>
New to GrepCode? Check out our FAQ X