Upgrade to Tomcat 8.5.11

build.gradle

@@ -75,7 +75,7 @@ configure(allprojects) { project ->
 	ext.testngVersion        = "6.9.10"
 	ext.tiles2Version        = "2.2.2"
 	ext.tiles3Version        = "3.0.7"
-	ext.tomcatVersion        = "8.5.9"
+	ext.tomcatVersion        = "8.5.11"
 	ext.tyrusVersion         = "1.3.5"  // constrained by WebLogic 12.1.3 support
 	ext.undertowVersion      = "1.3.25.Final"
 	ext.xmlunitVersion       = "1.6"

classes/production/spring-aop/META-INF/spring.handlers

@@ -0,0 +1 @@
+http\://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler

classes/production/spring-aop/META-INF/spring.schemas

@@ -0,0 +1,10 @@
+http\://www.springframework.org/schema/aop/spring-aop-2.0.xsd=org/springframework/aop/config/spring-aop.xsd
+http\://www.springframework.org/schema/aop/spring-aop-2.5.xsd=org/springframework/aop/config/spring-aop.xsd
+http\://www.springframework.org/schema/aop/spring-aop-3.0.xsd=org/springframework/aop/config/spring-aop.xsd
+http\://www.springframework.org/schema/aop/spring-aop-3.1.xsd=org/springframework/aop/config/spring-aop.xsd
+http\://www.springframework.org/schema/aop/spring-aop-3.2.xsd=org/springframework/aop/config/spring-aop.xsd
+http\://www.springframework.org/schema/aop/spring-aop-4.0.xsd=org/springframework/aop/config/spring-aop.xsd
+http\://www.springframework.org/schema/aop/spring-aop-4.1.xsd=org/springframework/aop/config/spring-aop.xsd
+http\://www.springframework.org/schema/aop/spring-aop-4.2.xsd=org/springframework/aop/config/spring-aop.xsd
+http\://www.springframework.org/schema/aop/spring-aop-4.3.xsd=org/springframework/aop/config/spring-aop.xsd
+http\://www.springframework.org/schema/aop/spring-aop.xsd=org/springframework/aop/config/spring-aop.xsd

classes/production/spring-aop/META-INF/spring.tooling

@@ -0,0 +1,4 @@
+# Tooling related information for the aop namespace
+http\://www.springframework.org/schema/aop@name=aop Namespace
+http\://www.springframework.org/schema/aop@prefix=aop
+http\://www.springframework.org/schema/aop@icon=org/springframework/aop/config/spring-aop.gif

classes/production/spring-aop/org/springframework/aop/config/spring-aop.xsd

@@ -0,0 +1,409 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+
+<xsd:schema xmlns="http://www.springframework.org/schema/aop"
+			xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+			xmlns:tool="http://www.springframework.org/schema/tool"
+			targetNamespace="http://www.springframework.org/schema/aop"
+			elementFormDefault="qualified"
+			attributeFormDefault="unqualified">
+
+	<xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd"/>
+
+	<xsd:annotation>
+		<xsd:documentation><![CDATA[
+	Defines the configuration elements for the Spring Framework's AOP support.
+		]]></xsd:documentation>
+	</xsd:annotation>
+
+	<xsd:element name="config">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	A section (compartmentalization) of AOP-specific configuration (including
+	aspects, pointcuts, etc).
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:sequence>
+				<xsd:element name="pointcut" type="pointcutType" minOccurs="0" maxOccurs="unbounded">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	A named pointcut definition.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+				<xsd:element name="advisor" type="advisorType" minOccurs="0" maxOccurs="unbounded">
+					<xsd:annotation>
+						<xsd:documentation source="java:org.springframework.aop.Advisor"><![CDATA[
+	A named advisor definition.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+				<xsd:element name="aspect" type="aspectType" minOccurs="0" maxOccurs="unbounded">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	A named aspect definition.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+			</xsd:sequence>
+			<xsd:attribute name="proxy-target-class" type="xsd:boolean" default="false">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Are class-based (CGLIB) proxies to be created? By default, standard
+	Java interface-based proxies are created.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="expose-proxy" type="xsd:boolean" default="false">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Indicate that the proxy should be exposed by the AOP framework as a
+	ThreadLocal for retrieval via the AopContext class. Off by default,
+	i.e. no guarantees that AopContext access will work.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="aspectj-autoproxy">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"><![CDATA[
+	Enables the use of the @AspectJ style of Spring AOP.
+
+	See org.springframework.context.annotation.EnableAspectJAutoProxy Javadoc
+	for information on code-based alternatives to this XML element.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:sequence>
+				<xsd:element name="include" type="includeType" minOccurs="0" maxOccurs="unbounded">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	Indicates that only @AspectJ beans with names matched by the (regex)
+	pattern will be considered as defining aspects to use for Spring autoproxying.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+			</xsd:sequence>
+			<xsd:attribute name="proxy-target-class" type="xsd:boolean" default="false">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Are class-based (CGLIB) proxies to be created? By default, standard
+	Java interface-based proxies are created.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="expose-proxy" type="xsd:boolean" default="false">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Indicate that the proxy should be exposed by the AOP framework as a
+	ThreadLocal for retrieval via the AopContext class. Off by default,
+	i.e. no guarantees that AopContext access will work.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="scoped-proxy">
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.aop.scope.ScopedProxyFactoryBean"><![CDATA[
+	Marks a bean definition as being a scoped proxy.
+
+	A bean marked as such will be exposed via a proxy, with the 'real'
+	bean instance being retrieved from some other source (such as a
+	HttpSession) as and when required.
+				]]></xsd:documentation>
+			</xsd:annotation>
+			<xsd:attribute name="proxy-target-class" type="xsd:boolean" default="true">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Are class-based (CGLIB) proxies to be created? This is the default; in order to
+	switch to standard Java interface-based proxies, turn this flag to "false".
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:complexType name="aspectType">
+		<xsd:choice minOccurs="0" maxOccurs="unbounded">
+			<xsd:element name="pointcut" type="pointcutType">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A named pointcut definition.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="declare-parents" type="declareParentsType">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Allows this aspect to introduce additional interfaces that the advised
+	object will transparently implement.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="before" type="basicAdviceType">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A before advice definition.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="after" type="basicAdviceType">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	An after advice definition.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="after-returning" type="afterReturningAdviceType">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	An after-returning advice definition.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="after-throwing" type="afterThrowingAdviceType">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	An after-throwing advice definition.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+			<xsd:element name="around" type="basicAdviceType">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	An around advice definition.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:choice>
+		<xsd:attribute name="id" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The unique identifier for an aspect.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="ref" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The name of the (backing) bean that encapsulates the aspect.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="order" type="xsd:token">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.core.Ordered"><![CDATA[
+	Controls the ordering of the execution of this aspect when multiple
+	advice executes at a specific joinpoint.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:complexType name="includeType">
+		<xsd:attribute name="name" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:java.util.regex.Pattern"><![CDATA[
+	The regular expression defining which beans are to be included in the
+	list of @AspectJ beans; beans with names matched by the pattern will
+	be included.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:complexType name="pointcutType">
+		<xsd:annotation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="org.springframework.aop.Pointcut"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:attribute name="id" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The unique identifier for a pointcut.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="expression" use="required" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The pointcut expression.
+
+	For example : 'execution(* com.xyz.myapp.service.*.*(..))'
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:complexType name="declareParentsType">
+		<xsd:attribute name="types-matching" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.aop.aspectj.TypePatternClassFilter"><![CDATA[
+	The AspectJ type expression that defines what types (classes) the
+	introduction is restricted to.
+
+	An example would be 'org.springframework.beans.ITestBean+'.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="implement-interface" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation source="java:java.lang.Class"><![CDATA[
+	The fully qualified name of the interface that will be introduced.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="default-impl" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:java.lang.Class"><![CDATA[
+	The fully qualified name of the class that will be instantiated to serve
+	as the default implementation of the introduced interface.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="delegate-ref" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	A reference to the bean that will serve
+	as the default implementation of the introduced interface.
+				]]></xsd:documentation>
+				<xsd:appinfo>
+					<tool:annotation kind="ref"/>
+				</xsd:appinfo>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:complexType name="basicAdviceType">
+		<xsd:attribute name="pointcut" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The associated pointcut expression.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="pointcut-ref" type="pointcutRefType">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The name of an associated pointcut definition.
+				]]></xsd:documentation>
+				<xsd:appinfo>
+					<tool:annotation kind="ref">
+						<tool:expected-type type="org.springframework.aop.Pointcut"/>
+					</tool:annotation>
+				</xsd:appinfo>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="method" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The name of the method that defines the logic of the advice.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="arg-names" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The comma-delimited list of advice method argument (parameter) names
+	that will be matched from pointcut parameters.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:complexType name="afterReturningAdviceType">
+		<xsd:complexContent>
+			<xsd:extension base="basicAdviceType">
+				<xsd:attribute name="returning" type="xsd:string">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	The name of the method parameter to which the return value must
+	be passed.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+
+	<xsd:complexType name="afterThrowingAdviceType">
+		<xsd:complexContent>
+			<xsd:extension base="basicAdviceType">
+				<xsd:attribute name="throwing" type="xsd:string">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	The name of the method parameter to which the thrown exception must
+	be passed.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+
+	<xsd:complexType name="advisorType">
+		<xsd:annotation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="org.springframework.aop.Advisor"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:attribute name="id" type="xsd:string"/>
+		<xsd:attribute name="advice-ref" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	A reference to an advice bean.
+				]]></xsd:documentation>
+				<xsd:appinfo>
+					<tool:annotation kind="ref">
+						<tool:expected-type type="org.aopalliance.aop.Advice"/>
+					</tool:annotation>
+				</xsd:appinfo>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="pointcut" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	A pointcut expression.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="pointcut-ref" type="pointcutRefType">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	A reference to a pointcut definition.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="order" type="xsd:token">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.core.Ordered"><![CDATA[
+	Controls the ordering of the execution of this advice when multiple
+	advice executes at a specific joinpoint.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:simpleType name="pointcutRefType">
+		<xsd:annotation>
+			<xsd:appinfo>
+				<tool:annotation kind="ref">
+					<tool:expected-type type="org.springframework.aop.Pointcut"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:union memberTypes="xsd:string"/>
+	</xsd:simpleType>
+
+</xsd:schema>

classes/production/spring-aspects/META-INF/aop.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0"?>
+
+<!--
+	AspectJ load-time weaving config file to install common Spring aspects.
+-->
+<aspectj>
+
+	<!--
+	<weaver options="-showWeaveInfo"/>
+	-->
+
+	<aspects>
+		<aspect name="org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect"/>
+		<aspect name="org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect"/>
+		<aspect name="org.springframework.transaction.aspectj.AnnotationTransactionAspect"/>
+		<aspect name="org.springframework.transaction.aspectj.JtaAnnotationTransactionAspect"/>
+		<aspect name="org.springframework.cache.aspectj.AnnotationCacheAspect"/>
+		<aspect name="org.springframework.cache.aspectj.JCacheCacheAspect"/>
+	</aspects>
+
+</aspectj>

classes/production/spring-beans/META-INF/spring.factories

@@ -0,0 +1 @@
+org.springframework.beans.BeanInfoFactory=org.springframework.beans.ExtendedBeanInfoFactory

classes/production/spring-beans/META-INF/spring.handlers

@@ -0,0 +1,3 @@
+http\://www.springframework.org/schema/c=org.springframework.beans.factory.xml.SimpleConstructorNamespaceHandler
+http\://www.springframework.org/schema/p=org.springframework.beans.factory.xml.SimplePropertyNamespaceHandler
+http\://www.springframework.org/schema/util=org.springframework.beans.factory.xml.UtilNamespaceHandler

classes/production/spring-beans/META-INF/spring.schemas

@@ -0,0 +1,30 @@
+http\://www.springframework.org/schema/beans/spring-beans-2.0.xsd=org/springframework/beans/factory/xml/spring-beans.xsd
+http\://www.springframework.org/schema/beans/spring-beans-2.5.xsd=org/springframework/beans/factory/xml/spring-beans.xsd
+http\://www.springframework.org/schema/beans/spring-beans-3.0.xsd=org/springframework/beans/factory/xml/spring-beans.xsd
+http\://www.springframework.org/schema/beans/spring-beans-3.1.xsd=org/springframework/beans/factory/xml/spring-beans.xsd
+http\://www.springframework.org/schema/beans/spring-beans-3.2.xsd=org/springframework/beans/factory/xml/spring-beans.xsd
+http\://www.springframework.org/schema/beans/spring-beans-4.0.xsd=org/springframework/beans/factory/xml/spring-beans.xsd
+http\://www.springframework.org/schema/beans/spring-beans-4.1.xsd=org/springframework/beans/factory/xml/spring-beans.xsd
+http\://www.springframework.org/schema/beans/spring-beans-4.2.xsd=org/springframework/beans/factory/xml/spring-beans.xsd
+http\://www.springframework.org/schema/beans/spring-beans-4.3.xsd=org/springframework/beans/factory/xml/spring-beans.xsd
+http\://www.springframework.org/schema/beans/spring-beans.xsd=org/springframework/beans/factory/xml/spring-beans.xsd
+http\://www.springframework.org/schema/tool/spring-tool-2.0.xsd=org/springframework/beans/factory/xml/spring-tool.xsd
+http\://www.springframework.org/schema/tool/spring-tool-2.5.xsd=org/springframework/beans/factory/xml/spring-tool.xsd
+http\://www.springframework.org/schema/tool/spring-tool-3.0.xsd=org/springframework/beans/factory/xml/spring-tool.xsd
+http\://www.springframework.org/schema/tool/spring-tool-3.1.xsd=org/springframework/beans/factory/xml/spring-tool.xsd
+http\://www.springframework.org/schema/tool/spring-tool-3.2.xsd=org/springframework/beans/factory/xml/spring-tool.xsd
+http\://www.springframework.org/schema/tool/spring-tool-4.0.xsd=org/springframework/beans/factory/xml/spring-tool.xsd
+http\://www.springframework.org/schema/tool/spring-tool-4.1.xsd=org/springframework/beans/factory/xml/spring-tool.xsd
+http\://www.springframework.org/schema/tool/spring-tool-4.2.xsd=org/springframework/beans/factory/xml/spring-tool.xsd
+http\://www.springframework.org/schema/tool/spring-tool-4.3.xsd=org/springframework/beans/factory/xml/spring-tool.xsd
+http\://www.springframework.org/schema/tool/spring-tool.xsd=org/springframework/beans/factory/xml/spring-tool.xsd
+http\://www.springframework.org/schema/util/spring-util-2.0.xsd=org/springframework/beans/factory/xml/spring-util.xsd
+http\://www.springframework.org/schema/util/spring-util-2.5.xsd=org/springframework/beans/factory/xml/spring-util.xsd
+http\://www.springframework.org/schema/util/spring-util-3.0.xsd=org/springframework/beans/factory/xml/spring-util.xsd
+http\://www.springframework.org/schema/util/spring-util-3.1.xsd=org/springframework/beans/factory/xml/spring-util.xsd
+http\://www.springframework.org/schema/util/spring-util-3.2.xsd=org/springframework/beans/factory/xml/spring-util.xsd
+http\://www.springframework.org/schema/util/spring-util-4.0.xsd=org/springframework/beans/factory/xml/spring-util.xsd
+http\://www.springframework.org/schema/util/spring-util-4.1.xsd=org/springframework/beans/factory/xml/spring-util.xsd
+http\://www.springframework.org/schema/util/spring-util-4.2.xsd=org/springframework/beans/factory/xml/spring-util.xsd
+http\://www.springframework.org/schema/util/spring-util-4.3.xsd=org/springframework/beans/factory/xml/spring-util.xsd
+http\://www.springframework.org/schema/util/spring-util.xsd=org/springframework/beans/factory/xml/spring-util.xsd

classes/production/spring-beans/META-INF/spring.tooling

@@ -0,0 +1,9 @@
+# Tooling related information for the beans namespace
+http\://www.springframework.org/schema/beans@name=beans Namespace
+http\://www.springframework.org/schema/beans@prefix=beans
+http\://www.springframework.org/schema/beans@icon=org/springframework/beans/factory/xml/spring-beans.gif
+
+# Tooling related information for the util namespace
+http\://www.springframework.org/schema/util@name=util Namespace
+http\://www.springframework.org/schema/util@prefix=util
+http\://www.springframework.org/schema/util@icon=org/springframework/beans/factory/xml/spring-util.gif

classes/production/spring-beans/org/springframework/beans/factory/xml/spring-beans.dtd

@@ -0,0 +1,662 @@
+<!--
+	Spring XML Beans DTD, version 2.0
+	Authors: Rod Johnson, Juergen Hoeller, Alef Arendsen, Colin Sampaleanu, Rob Harrop
+
+	This defines a simple and consistent way of creating a namespace
+	of JavaBeans objects, managed by a Spring BeanFactory, read by
+	XmlBeanDefinitionReader (with DefaultBeanDefinitionDocumentReader).
+
+	This document type is used by most Spring functionality, including
+	web application contexts, which are based on bean factories.
+
+	Each "bean" element in this document defines a JavaBean.
+	Typically the bean class is specified, along with JavaBean properties
+	and/or constructor arguments.
+
+	A bean instance can be a "singleton" (shared instance) or a "prototype"
+	(independent instance). Further scopes can be provided by extended
+	bean factories, for example in a web environment.
+
+	References among beans are supported, that is, setting a JavaBean property
+	or a constructor argument to refer to another bean in the same factory
+	(or an ancestor factory).
+
+	As alternative to bean references, "inner bean definitions" can be used.
+	Singleton flags of such inner bean definitions are effectively ignored:
+	Inner beans are typically anonymous prototypes.
+
+	There is also support for lists, sets, maps, and java.util.Properties
+	as bean property types or constructor argument types.
+
+	For simple purposes, this DTD is sufficient. As of Spring 2.0,
+	XSD-based bean definitions are supported as more powerful alternative.
+
+	XML documents that conform to this DTD should declare the following doctype:
+
+	<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
+			"http://www.springframework.org/dtd/spring-beans-2.0.dtd">
+-->
+
+
+<!--
+	The document root. A document can contain bean definitions only,
+	imports only, or a mixture of both (typically with imports first).
+-->
+<!ELEMENT beans (
+	description?,
+	(import | alias | bean)*
+)>
+
+<!--
+	Default values for all bean definitions. Can be overridden at
+	the "bean" level. See those attribute definitions for details.
+-->
+<!ATTLIST beans default-lazy-init (true | false) "false">
+<!ATTLIST beans default-merge (true | false) "false">
+<!ATTLIST beans default-autowire (no | byName | byType | constructor | autodetect) "no">
+<!ATTLIST beans default-init-method CDATA #IMPLIED>
+<!ATTLIST beans default-destroy-method CDATA #IMPLIED>
+
+<!--
+	Element containing informative text describing the purpose of the enclosing
+	element. Always optional.
+	Used primarily for user documentation of XML bean definition documents.
+-->
+<!ELEMENT description (#PCDATA)>
+
+
+<!--
+	Specifies an XML bean definition resource to import.
+-->
+<!ELEMENT import EMPTY>
+
+<!--
+	The relative resource location of the XML bean definition file to import,
+	for example "myImport.xml" or "includes/myImport.xml" or "../myImport.xml".
+-->
+<!ATTLIST import resource CDATA #REQUIRED>
+
+
+<!--
+	Defines an alias for a bean, which can reside in a different definition file.
+-->
+<!ELEMENT alias EMPTY>
+
+<!--
+	The name of the bean to define an alias for.
+-->
+<!ATTLIST alias name CDATA #REQUIRED>
+
+<!--
+	The alias name to define for the bean.
+-->
+<!ATTLIST alias alias CDATA #REQUIRED>
+
+<!--
+	Allows for arbitrary metadata to be attached to a bean definition.
+-->
+<!ELEMENT meta EMPTY>
+
+<!--
+	Specifies the key name of the metadata parameter being defined.
+-->
+<!ATTLIST meta key CDATA #REQUIRED>
+
+<!--
+	Specifies the value of the metadata parameter being defined as a String.
+-->
+<!ATTLIST meta value CDATA #REQUIRED>
+
+<!--
+	Defines a single (usually named) bean.
+
+	A bean definition may contain nested tags for constructor arguments,
+	property values, lookup methods, and replaced methods. Mixing constructor
+	injection and setter injection on the same bean is explicitly supported.
+-->
+<!ELEMENT bean (
+	description?,
+	(meta | constructor-arg | property | lookup-method | replaced-method)*
+)>
+
+<!--
+	Beans can be identified by an id, to enable reference checking.
+
+	There are constraints on a valid XML id: if you want to reference your bean
+	in Java code using a name that's illegal as an XML id, use the optional
+	"name" attribute. If neither is given, the bean class name is used as id
+	(with an appended counter like "#2" if there is already a bean with that name).
+-->
+<!ATTLIST bean id ID #IMPLIED>
+
+<!--
+	Optional. Can be used to create one or more aliases illegal in an id.
+	Multiple aliases can be separated by any number of spaces, commas, or
+	semi-colons (or indeed any mixture of the three).
+-->
+<!ATTLIST bean name CDATA #IMPLIED>
+
+<!--
+	Each bean definition must specify the fully qualified name of the class,
+	except if it serves only as a parent definition for child bean definitions.
+-->
+<!ATTLIST bean class CDATA #IMPLIED>
+
+<!--
+	Optionally specify a parent bean definition.
+
+	Will use the bean class of the parent if none specified, but can
+	also override it. In the latter case, the child bean class must be
+	compatible with the parent, i.e. accept the parent's property values
+	and constructor argument values, if any.
+
+	A child bean definition will inherit constructor argument values,
+	property values and method overrides from the parent, with the option
+	to add new values. If init method, destroy method, factory bean and/or factory
+	method are specified, they will override the corresponding parent settings.
+
+	The remaining settings will always be taken from the child definition:
+	depends on, autowire mode, dependency check, scope, lazy init.
+-->
+<!ATTLIST bean parent CDATA #IMPLIED>
+
+<!--
+	The scope of this bean: typically "singleton" (one shared instance,
+	which will be returned by all calls to getBean() with the id),
+	or "prototype" (independent instance resulting from each call to
+	getBean(). Default is "singleton".
+
+	Singletons are most commonly used, and are ideal for multi-threaded
+	service objects. Further scopes, such as "request" or "session",
+	might be supported by extended bean factories (for example, in a
+	web environment).
+
+	Note: This attribute will not be inherited by child bean definitions.
+	Hence, it needs to be specified per concrete bean definition.
+
+	Inner bean definitions inherit the singleton status of their containing
+	bean definition, unless explicitly specified: The inner bean will be a
+	singleton if the containing bean is a singleton, and a prototype if
+	the containing bean has any other scope.
+-->
+<!ATTLIST bean scope CDATA #IMPLIED>
+
+<!--
+	Is this bean "abstract", i.e. not meant to be instantiated itself but
+	rather just serving as parent for concrete child bean definitions.
+	Default is "false". Specify "true" to tell the bean factory to not try to
+	instantiate that particular bean in any case.
+
+	Note: This attribute will not be inherited by child bean definitions.
+	Hence, it needs to be specified per abstract bean definition.
+-->
+<!ATTLIST bean abstract (true | false) #IMPLIED>
+
+<!--
+	If this bean should be lazily initialized.
+	If false, it will get instantiated on startup by bean factories
+	that perform eager initialization of singletons.
+
+	Note: This attribute will not be inherited by child bean definitions.
+	Hence, it needs to be specified per concrete bean definition.
+-->
+<!ATTLIST bean lazy-init (true | false | default) "default">
+
+<!--
+	Optional attribute controlling whether to "autowire" bean properties.
+	This is an automagical process in which bean references don't need to be coded
+	explicitly in the XML bean definition file, but Spring works out dependencies.
+
+	There are 5 modes:
+
+	1. "no"
+	The traditional Spring default. No automagical wiring. Bean references
+	must be defined in the XML file via the <ref> element. We recommend this
+	in most cases as it makes documentation more explicit.
+
+	2. "byName"
+	Autowiring by property name. If a bean of class Cat exposes a dog property,
+	Spring will try to set this to the value of the bean "dog" in the current factory.
+	If there is no matching bean by name, nothing special happens.
+
+	3. "byType"
+	Autowiring if there is exactly one bean of the property type in the bean factory.
+	If there is more than one, a fatal error is raised, and you can't use byType
+	autowiring for that bean. If there is none, nothing special happens.
+
+	4. "constructor"
+	Analogous to "byType" for constructor arguments. If there isn't exactly one bean
+	of the constructor argument type in the bean factory, a fatal error is raised.
+
+	5. "autodetect"
+	Chooses "constructor" or "byType" through introspection of the bean class.
+	If a default constructor is found, "byType" gets applied.
+
+	The latter two are similar to PicoContainer and make bean factories simple to
+	configure for small namespaces, but doesn't work as well as standard Spring
+	behaviour for bigger applications.
+
+	Note that explicit dependencies, i.e. "property" and "constructor-arg" elements,
+	always override autowiring. Autowire behavior can be combined with dependency
+	checking, which will be performed after all autowiring has been completed.
+
+	Note: This attribute will not be inherited by child bean definitions.
+	Hence, it needs to be specified per concrete bean definition.
+-->
+<!ATTLIST bean autowire (no | byName | byType | constructor | autodetect | default) "default">
+
+<!--
+	The names of the beans that this bean depends on being initialized.
+	The bean factory will guarantee that these beans get initialized before.
+
+	Note that dependencies are normally expressed through bean properties or
+	constructor arguments. This property should just be necessary for other kinds
+	of dependencies like statics (*ugh*) or database preparation on startup.
+
+	Note: This attribute will not be inherited by child bean definitions.
+	Hence, it needs to be specified per concrete bean definition.
+-->
+<!ATTLIST bean depends-on CDATA #IMPLIED>
+
+<!--
+	Indicates whether or not this bean should be considered when looking
+	for matching candidates to satisfy another bean's autowiring requirements.
+	Note that this does not affect explicit references by name, which will get
+	resolved even if the specified bean is not marked as an autowire candidate.
+-->
+<!ATTLIST bean autowire-candidate (true | false) #IMPLIED>
+
+<!--
+	Optional attribute for the name of the custom initialization method
+	to invoke after setting bean properties. The method must have no arguments,
+	but may throw any exception.
+-->
+<!ATTLIST bean init-method CDATA #IMPLIED>
+
+<!--
+	Optional attribute for the name of the custom destroy method to invoke
+	on bean factory shutdown. The method must have no arguments,
+	but may throw any exception.
+
+	Note: Only invoked on beans whose lifecycle is under full control
+	of the factory - which is always the case for singletons, but not
+	guaranteed for any other scope.
+-->
+<!ATTLIST bean destroy-method CDATA #IMPLIED>
+
+<!--
+	Optional attribute specifying the name of a factory method to use to
+	create this object. Use constructor-arg elements to specify arguments
+	to the factory method, if it takes arguments. Autowiring does not apply
+	to factory methods.
+
+	If the "class" attribute is present, the factory method will be a static
+	method on the class specified by the "class" attribute on this bean
+	definition. Often this will be the same class as that of the constructed
+	object - for example, when the factory method is used as an alternative
+	to a constructor. However, it may be on a different class. In that case,
+	the created object will *not* be of the class specified in the "class"
+	attribute. This is analogous to FactoryBean behavior.
+
+	If the "factory-bean" attribute is present, the "class" attribute is not
+	used, and the factory method will be an instance method on the object
+	returned from a getBean call with the specified bean name. The factory
+	bean may be defined as a singleton or a prototype.
+
+	The factory method can have any number of arguments. Autowiring is not
+	supported. Use indexed constructor-arg elements in conjunction with the
+	factory-method attribute.
+
+	Setter Injection can be used in conjunction with a factory method.
+	Method Injection cannot, as the factory method returns an instance,
+	which will be used when the container creates the bean.
+-->
+<!ATTLIST bean factory-method CDATA #IMPLIED>
+
+<!--
+	Alternative to class attribute for factory-method usage.
+	If this is specified, no class attribute should be used.
+	This should be set to the name of a bean in the current or
+	ancestor factories that contains the relevant factory method.
+	This allows the factory itself to be configured using Dependency
+	Injection, and an instance (rather than static) method to be used.
+-->
+<!ATTLIST bean factory-bean CDATA #IMPLIED>
+
+<!--
+	Bean definitions can specify zero or more constructor arguments.
+	This is an alternative to "autowire constructor".
+	Arguments correspond to either a specific index of the constructor argument
+	list or are supposed to be matched generically by type.
+
+	Note: A single generic argument value will just be used once, rather than
+	potentially matched multiple times (as of Spring 1.1).
+
+	constructor-arg elements are also used in conjunction with the factory-method
+	element to construct beans using static or instance factory methods.
+-->
+<!ELEMENT constructor-arg (
+	description?,
+	(bean | ref | idref | value | null | list | set | map | props)?
+)>
+
+<!--
+	The constructor-arg tag can have an optional index attribute,
+	to specify the exact index in the constructor argument list. Only needed
+	to avoid ambiguities, e.g. in case of 2 arguments of the same type.
+-->
+<!ATTLIST constructor-arg index CDATA #IMPLIED>
+
+<!--
+	The constructor-arg tag can have an optional type attribute,
+	to specify the exact type of the constructor argument. Only needed
+	to avoid ambiguities, e.g. in case of 2 single argument constructors
+	that can both be converted from a String.
+-->
+<!ATTLIST constructor-arg type CDATA #IMPLIED>
+
+<!--
+	A short-cut alternative to a child element "ref bean=".
+-->
+<!ATTLIST constructor-arg ref CDATA #IMPLIED>
+
+<!--
+	A short-cut alternative to a child element "value".
+-->
+<!ATTLIST constructor-arg value CDATA #IMPLIED>
+
+
+<!--
+	Bean definitions can have zero or more properties.
+	Property elements correspond to JavaBean setter methods exposed
+	by the bean classes. Spring supports primitives, references to other
+	beans in the same or related factories, lists, maps and properties.
+-->
+<!ELEMENT property (
+	description?, meta*,
+	(bean | ref | idref | value | null | list | set | map | props)?
+)>
+
+<!--
+	The property name attribute is the name of the JavaBean property.
+	This follows JavaBean conventions: a name of "age" would correspond
+	to setAge()/optional getAge() methods.
+-->
+<!ATTLIST property name CDATA #REQUIRED>
+
+<!--
+	A short-cut alternative to a child element "ref bean=".
+-->
+<!ATTLIST property ref CDATA #IMPLIED>
+
+<!--
+	A short-cut alternative to a child element "value".
+-->
+<!ATTLIST property value CDATA #IMPLIED>
+
+
+<!--
+	A lookup method causes the IoC container to override the given method and return
+	the bean with the name given in the bean attribute. This is a form of Method Injection.
+	It's particularly useful as an alternative to implementing the BeanFactoryAware
+	interface, in order to be able to make getBean() calls for non-singleton instances
+	at runtime. In this case, Method Injection is a less invasive alternative.
+-->
+<!ELEMENT lookup-method EMPTY>
+
+<!--
+	Name of a lookup method. This method should take no arguments.
+-->
+<!ATTLIST lookup-method name CDATA #IMPLIED>
+
+<!--
+	Name of the bean in the current or ancestor factories that the lookup method
+	should resolve to. Often this bean will be a prototype, in which case the
+	lookup method will return a distinct instance on every invocation. This
+	is useful for single-threaded objects.
+-->
+<!ATTLIST lookup-method bean CDATA #IMPLIED>
+
+
+<!--
+	Similar to the lookup method mechanism, the replaced-method element is used to control
+	IoC container method overriding: Method Injection. This mechanism allows the overriding
+	of a method with arbitrary code.
+-->
+<!ELEMENT replaced-method (
+	(arg-type)*
+)>
+
+<!--
+	Name of the method whose implementation should be replaced by the IoC container.
+	If this method is not overloaded, there's no need to use arg-type subelements.
+	If this method is overloaded, arg-type subelements must be used for all
+	override definitions for the method.
+-->
+<!ATTLIST replaced-method name CDATA #IMPLIED>
+
+<!--
+	Bean name of an implementation of the MethodReplacer interface in the current
+	or ancestor factories. This may be a singleton or prototype bean. If it's
+	a prototype, a new instance will be used for each method replacement.
+	Singleton usage is the norm.
+-->
+<!ATTLIST replaced-method replacer CDATA #IMPLIED>
+
+<!--
+	Subelement of replaced-method identifying an argument for a replaced method
+	in the event of method overloading.
+-->
+<!ELEMENT arg-type (#PCDATA)>
+
+<!--
+	Specification of the type of an overloaded method argument as a String.
+	For convenience, this may be a substring of the FQN. E.g. all the
+	following would match "java.lang.String":
+	- java.lang.String
+	- String
+	- Str
+
+	As the number of arguments will be checked also, this convenience can often
+	be used to save typing.
+-->
+<!ATTLIST arg-type match CDATA #IMPLIED>
+
+
+<!--
+	Defines a reference to another bean in this factory or an external
+	factory (parent or included factory).
+-->
+<!ELEMENT ref EMPTY>
+
+<!--
+	References must specify a name of the target bean.
+	The "bean" attribute can reference any name from any bean in the context,
+	to be checked at runtime.
+	Local references, using the "local" attribute, have to use bean ids;
+	they can be checked by this DTD, thus should be preferred for references
+	within the same bean factory XML file.
+-->
+<!ATTLIST ref bean CDATA #IMPLIED>
+<!ATTLIST ref local IDREF #IMPLIED>
+<!ATTLIST ref parent CDATA #IMPLIED>
+
+
+<!--
+	Defines a string property value, which must also be the id of another
+	bean in this factory or an external factory (parent or included factory).
+	While a regular 'value' element could instead be used for the same effect,
+	using idref in this case allows validation of local bean ids by the XML
+	parser, and name completion by supporting tools.
+-->
+<!ELEMENT idref EMPTY>
+
+<!--
+	ID refs must specify a name of the target bean.
+	The "bean" attribute can reference any name from any bean in the context,
+	potentially to be checked at runtime by bean factory implementations.
+	Local references, using the "local" attribute, have to use bean ids;
+	they can be checked by this DTD, thus should be preferred for references
+	within the same bean factory XML file.
+-->
+<!ATTLIST idref bean CDATA #IMPLIED>
+<!ATTLIST idref local IDREF #IMPLIED>
+
+
+<!--
+	Contains a string representation of a property value.
+	The property may be a string, or may be converted to the required
+	type using the JavaBeans PropertyEditor machinery. This makes it
+	possible for application developers to write custom PropertyEditor
+	implementations that can convert strings to arbitrary target objects.
+
+	Note that this is recommended for simple objects only.
+	Configure more complex objects by populating JavaBean
+	properties with references to other beans.
+-->
+<!ELEMENT value (#PCDATA)>
+
+<!--
+	The value tag can have an optional type attribute, to specify the
+	exact type that the value should be converted to. Only needed
+	if the type of the target property or constructor argument is
+	too generic: for example, in case of a collection element.
+-->
+<!ATTLIST value type CDATA #IMPLIED>
+
+<!--
+	Denotes a Java null value. Necessary because an empty "value" tag
+	will resolve to an empty String, which will not be resolved to a
+	null value unless a special PropertyEditor does so.
+-->
+<!ELEMENT null (#PCDATA)>
+
+
+<!--
+	A list can contain multiple inner bean, ref, collection, or value elements.
+	Java lists are untyped, pending generics support in Java 1.5,
+	although references will be strongly typed.
+	A list can also map to an array type. The necessary conversion
+	is automatically performed by the BeanFactory.
+-->
+<!ELEMENT list (
+	(bean | ref | idref | value | null | list | set | map | props)*
+)>
+
+<!--
+	Enable/disable merging for collections when using parent/child beans.
+-->
+<!ATTLIST list merge (true | false | default) "default">
+
+<!--
+	Specify the default Java type for nested values.
+-->
+<!ATTLIST list value-type CDATA #IMPLIED>
+
+
+<!--
+	A set can contain multiple inner bean, ref, collection, or value elements.
+	Java sets are untyped, pending generics support in Java 1.5,
+	although references will be strongly typed.
+-->
+<!ELEMENT set (
+	(bean | ref | idref | value | null | list | set | map | props)*
+)>
+
+<!--
+	Enable/disable merging for collections when using parent/child beans.
+-->
+<!ATTLIST set merge (true | false | default) "default">
+
+<!--
+	Specify the default Java type for nested values.
+-->
+<!ATTLIST set value-type CDATA #IMPLIED>
+
+
+<!--
+	A Spring map is a mapping from a string key to object.
+	Maps may be empty.
+-->
+<!ELEMENT map (
+	(entry)*
+)>
+
+<!--
+	Enable/disable merging for collections when using parent/child beans.
+-->
+<!ATTLIST map merge (true | false | default) "default">
+
+<!--
+	Specify the default Java type for nested entry keys.
+-->
+<!ATTLIST map key-type CDATA #IMPLIED>
+
+<!--
+	Specify the default Java type for nested entry values.
+-->
+<!ATTLIST map value-type CDATA #IMPLIED>
+
+<!--
+	A map entry can be an inner bean, ref, value, or collection.
+	The key of the entry is given by the "key" attribute or child element.
+-->
+<!ELEMENT entry (
+	key?,
+	(bean | ref | idref | value | null | list | set | map | props)?
+)>
+
+<!--
+	Each map element must specify its key as attribute or as child element.
+	A key attribute is always a String value.
+-->
+<!ATTLIST entry key CDATA #IMPLIED>
+
+<!--
+	A short-cut alternative to a "key" element with a "ref bean=" child element.
+-->
+<!ATTLIST entry key-ref CDATA #IMPLIED>
+
+<!--
+	A short-cut alternative to a child element "value".
+-->
+<!ATTLIST entry value CDATA #IMPLIED>
+
+<!--
+	A short-cut alternative to a child element "ref bean=".
+-->
+<!ATTLIST entry value-ref CDATA #IMPLIED>
+
+<!--
+	A key element can contain an inner bean, ref, value, or collection.
+-->
+<!ELEMENT key (
+	(bean | ref | idref | value | null | list | set | map | props)
+)>
+
+
+<!--
+	Props elements differ from map elements in that values must be strings.
+	Props may be empty.
+-->
+<!ELEMENT props (
+	(prop)*
+)>
+
+<!--
+	Enable/disable merging for collections when using parent/child beans.
+-->
+<!ATTLIST props merge (true | false | default) "default">
+
+<!--
+	Element content is the string value of the property.
+	Note that whitespace is trimmed off to avoid unwanted whitespace
+	caused by typical XML formatting.
+-->
+<!ELEMENT prop (#PCDATA)>
+
+<!--
+	Each property element must specify its key.
+-->
+<!ATTLIST prop key CDATA #REQUIRED>
+

classes/production/spring-beans/org/springframework/beans/factory/xml/spring-tool.xsd

@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+
+<xsd:schema xmlns="http://www.springframework.org/schema/tool"
+		xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+		targetNamespace="http://www.springframework.org/schema/tool"
+		elementFormDefault="qualified">
+
+	<xsd:import namespace="http://www.w3.org/XML/1998/namespace"/>
+
+	<xsd:annotation>
+		<xsd:documentation><![CDATA[
+	Defines the tool support annotations for Spring's configuration namespaces.
+	Used in other namespace XSD files; not intended for direct use in config files.
+		]]></xsd:documentation>
+	</xsd:annotation>
+
+	<xsd:element name="annotation">
+		<xsd:complexType>
+			<xsd:sequence minOccurs="0">
+				<xsd:element name="expected-type" type="typedParameterType" minOccurs="0" maxOccurs="1"/>
+				<xsd:element name="assignable-to" type="assignableToType" minOccurs="0" maxOccurs="1"/>
+				<xsd:element name="exports" type="exportsType" minOccurs="0" maxOccurs="unbounded"/>
+				<xsd:element name="registers-scope" type="registersScopeType" minOccurs="0" maxOccurs="unbounded"/>
+				<xsd:element name="expected-method" type="expectedMethodType" minOccurs="0" maxOccurs="unbounded"/>
+			</xsd:sequence>
+			<xsd:attribute name="kind" default="direct">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="ref"/>
+						<xsd:enumeration value="direct"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:complexType name="typedParameterType">
+		<xsd:attribute name="type" type="xsd:string" use="required"/>
+	</xsd:complexType>
+
+	<xsd:complexType name="assignableToType">
+		<xsd:attribute name="type" type="xsd:string"/>
+		<xsd:attribute name="restriction" default="both">
+			<xsd:simpleType>
+				<xsd:restriction base="xsd:NMTOKEN">
+					<xsd:enumeration value="both"/>
+					<xsd:enumeration value="interface-only"/>
+					<xsd:enumeration value="class-only"/>
+				</xsd:restriction>
+			</xsd:simpleType>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:complexType name="expectedMethodType">
+		<xsd:attribute name="type" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Defines an XPath query that can be executed against the node annotated with this
+	type to determine the class for which the this method is valid
+		]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="type-ref" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Defines an XPath query that can be executed against the node annotated with this
+	type to determine a referenced bean (by id or alias) for which the given method is valid
+		]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="expression" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Defines an AspectJ method execution pointcut expressions that matches valid methods
+		]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:complexType name="exportsType">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Indicates that an annotated type exports an application visible component.
+		]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:attribute name="type" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The type of the exported component. May be null if the type is not known until runtime.
+		]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="identifier" type="xsd:string" default="@id">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Defines an XPath query that can be executed against the node annotated with this
+	type to determine the identifier of any exported component.
+		]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:complexType name="registersScopeType">
+		<xsd:attribute name="name" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Defines the name of a custom bean scope that the annotated type registers, e.g. "conversation".
+	Such a scope will be available in addition to the standard "singleton" and "prototype" scopes
+	(plus "request", "session" and "globalSession" in a web application environment).
+		]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+</xsd:schema>

classes/production/spring-beans/org/springframework/beans/factory/xml/spring-util.xsd

@@ -0,0 +1,221 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+
+<xsd:schema xmlns="http://www.springframework.org/schema/util"
+		xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+		xmlns:beans="http://www.springframework.org/schema/beans"
+		xmlns:tool="http://www.springframework.org/schema/tool"
+		targetNamespace="http://www.springframework.org/schema/util"
+		elementFormDefault="qualified"
+		attributeFormDefault="unqualified">
+
+	<xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd"/>
+
+	<xsd:element name="constant">
+		<xsd:annotation>
+			<xsd:documentation>
+	Reference a public, static field on a type and expose its value as
+	a bean. For example <code>&lt;util:constant static-field=&quot;java.lang.Integer.MAX_VALUE&quot;/&gt;</code>.
+			</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:attribute name="id" type="xsd:string"/>
+			<xsd:attribute name="static-field" type="xsd:string" use="required"/>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="property-path">
+		<xsd:annotation>
+			<xsd:documentation>
+	Reference a property on a bean (or as a nested value) and expose its values as
+	a bean. For example &lt;util:property-path path=&quot;order.customer.name&quot;/&gt;.
+			</xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:attribute name="id" type="xsd:string"/>
+			<xsd:attribute name="path" type="xsd:string" use="required"/>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="list">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.beans.factory.config.ListFactoryBean">
+	Builds a List instance of the specified type, populated with the specified content.
+			</xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="java.util.List"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="beans:listOrSetType">
+					<xsd:attribute name="id" type="xsd:string"/>
+					<xsd:attribute name="list-class" type="xsd:string">
+						<xsd:annotation>
+							<xsd:appinfo>
+								<tool:annotation>
+									<tool:expected-type type="java.lang.Class"/>
+									<tool:assignable-to type="java.util.List"/>
+								</tool:annotation>
+							</xsd:appinfo>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="scope" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The scope of this collection bean: typically "singleton" (one shared instance,
+	which will be returned by all calls to getBean with the given id), or
+	"prototype" (independent instance resulting from each call to getBean).
+	Default is "singleton". Further scopes, such as "request" or "session",
+	might be supported by extended bean factories (e.g. in a web environment).
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="set">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.beans.factory.config.SetFactoryBean">
+	Builds a Set instance of the specified type, populated with the specified content.
+			</xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="java.util.Set"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="beans:listOrSetType">
+					<xsd:attribute name="id" type="xsd:string"/>
+					<xsd:attribute name="set-class" type="xsd:string">
+						<xsd:annotation>
+							<xsd:appinfo>
+								<tool:annotation>
+									<tool:expected-type type="java.lang.Class"/>
+									<tool:assignable-to type="java.util.Set"/>
+								</tool:annotation>
+							</xsd:appinfo>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="scope" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The scope of this collection bean: typically "singleton" (one shared instance,
+	which will be returned by all calls to getBean with the given id), or
+	"prototype" (independent instance resulting from each call to getBean).
+	Default is "singleton". Further scopes, such as "request" or "session",
+	might be supported by extended bean factories (e.g. in a web environment).
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="map">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.beans.factory.config.MapFactoryBean">
+	Builds a Map instance of the specified type, populated with the specified content.
+			</xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="java.util.Map"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="beans:mapType">
+					<xsd:attribute name="id" type="xsd:string"/>
+					<xsd:attribute name="map-class" type="xsd:string">
+						<xsd:annotation>
+							<xsd:appinfo>
+								<tool:annotation>
+									<tool:expected-type type="java.lang.Class"/>
+									<tool:assignable-to type="java.util.Map"/>
+								</tool:annotation>
+							</xsd:appinfo>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="scope" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The scope of this collection bean: typically "singleton" (one shared instance,
+	which will be returned by all calls to getBean with the given id), or
+	"prototype" (independent instance resulting from each call to getBean).
+	Default is "singleton". Further scopes, such as "request" or "session",
+	might be supported by extended bean factories (e.g. in a web environment).
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="properties">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.beans.factory.config.PropertiesFactoryBean">
+	Loads a Properties instance from the resource location specified by the '<code>location</code>' attribute.
+			</xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="java.util.Properties"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="beans:propsType">
+					<xsd:attribute name="id" type="xsd:string"/>
+					<xsd:attribute name="location" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The location of the properties file, as a Spring resource location: a URL,
+	a "classpath:" pseudo URL, or a relative file path. Multiple locations may be
+	specified, separated by commas.
+				]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="ignore-resource-not-found" type="xsd:boolean" default="false">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	Specifies if failure to find the property resource location should be ignored.
+	Default is "false", meaning that if there is no file in the location specified
+	an exception will be raised at runtime.
+				]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="local-override" type="xsd:boolean" default="false">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	Specifies whether local properties override properties from files.
+	Default is "false": properties from files override local defaults.
+	If set to "true", local properties will override defaults from files.
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="scope" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The scope of this collection bean: typically "singleton" (one shared instance,
+	which will be returned by all calls to getBean with the given id), or
+	"prototype" (independent instance resulting from each call to getBean).
+	Default is "singleton". Further scopes, such as "request" or "session",
+	might be supported by extended bean factories (e.g. in a web environment).
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+</xsd:schema>

classes/production/spring-build-src/META-INF/gradle-plugins/detect-split-packages.properties

@@ -0,0 +1 @@
+implementation-class=org.springframework.build.gradle.DetectSplitPackagesPlugin

classes/production/spring-build-src/META-INF/gradle-plugins/merge.properties

@@ -0,0 +1 @@
+implementation-class=org.springframework.build.gradle.MergePlugin

classes/production/spring-build-src/META-INF/gradle-plugins/test-source-set-dependencies.properties

@@ -0,0 +1 @@
+implementation-class=org.springframework.build.gradle.TestSourceSetDependenciesPlugin

classes/production/spring-context-indexer/META-INF/services/javax.annotation.processing.Processor

@@ -0,0 +1 @@
+org.springframework.context.index.CandidateComponentsIndexer

classes/production/spring-context-support/org/springframework/mail/javamail/mime.types

@@ -0,0 +1,323 @@
+################################################################################
+# Copyright 2002-2010 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+################################################################################
+
+################################################################################
+#
+# Defaults for the Java Activation Framework
+# Additional extensions registered in this file:
+# text/plain				java c c++ pl cc h
+#
+################################################################################
+
+text/html				html htm HTML HTM
+text/plain				txt text TXT TEXT java c c++ pl cc h
+image/gif				gif GIF
+image/ief				ief
+image/jpeg				jpeg jpg jpe JPG
+image/tiff				tiff tif
+image/x-xwindowdump			xwd
+application/postscript			ai eps ps
+application/rtf				rtf
+application/x-tex			tex
+application/x-texinfo			texinfo texi
+application/x-troff			t tr roff
+audio/basic				au
+audio/midi				midi mid
+audio/x-aifc				aifc
+audio/x-aiff				aif aiff
+audio/x-mpeg				mpeg mpg
+audio/x-wav				wav
+video/mpeg				mpeg mpg mpe
+video/quicktime				qt mov
+video/x-msvideo				avi
+
+################################################################################
+#
+# Additional file types adapted from
+# http://www.utoronto.ca/webdocs/HTMLdocs/Book/Book-3ed/appb/mimetype.html
+# kindly re-licensed to Apache Software License 2.0 by Ian Graham.
+#
+################################################################################
+
+# TEXT TYPES
+
+text/x-speech				talk
+text/css				css
+text/csv				csv
+
+# IMAGE TYPES
+
+# X-Windows bitmap (b/w)
+image/x-xbitmap				xbm
+# X-Windows pixelmap (8-bit color)
+image/x-xpixmap				xpm
+# Portable Network Graphics
+image/x-png				png
+# Image Exchange Format (RFC 1314)
+image/ief				ief
+# JPEG
+image/jpeg				jpeg jpg jpe
+# RGB
+image/rgb				rgb
+# Group III Fax (RFC 1494)
+image/g3fax				g3f
+# X Windowdump format
+image/x-xwindowdump			xwd
+# Macintosh PICT format
+image/x-pict				pict
+# PPM (UNIX PPM package)
+image/x-portable-pixmap			ppm
+# PGM (UNIX PPM package)
+image/x-portable-graymap		pgm
+# PBM (UNIX PPM package)
+image/x-portable-bitmap			pbm
+# PNM (UNIX PPM package)
+image/x-portable-anymap			pnm
+# Microsoft Windows bitmap
+image/x-ms-bmp				bmp
+# CMU raster
+image/x-cmu-raster			ras
+# Kodak Photo-CD
+image/x-photo-cd			pcd
+# Computer Graphics Metafile
+image/cgm				cgm
+# CALS Type 1 or 2
+image/x-cals				mil cal
+# Fractal Image Format (Iterated Systems)
+image/fif				fif
+# QuickSilver active image (Micrografx)
+image/x-mgx-dsf				dsf
+# CMX vector image (Corel)
+image/x-cmx				cmx
+# Wavelet-compressed (Summus)
+image/wavelet				wi
+# AutoCad Drawing (SoftSource)
+image/vnd.dwg				dwg
+# AutoCad DXF file (SoftSource)
+image/vnd.dxf				dxf
+# Simple Vector Format (SoftSource)
+image/vnd.svf				svf
+
+# AUDIO/VOICE/MUSIC RELATED TYPES
+
+# """basic""audio - 8-bit u-law PCM"
+audio/basic				au snd
+# Macintosh audio format (AIpple)
+audio/x-aiff				aif aiff aifc
+# Microsoft audio
+audio/x-wav				wav
+# MPEG audio
+audio/x-mpeg				mpa abs mpega
+# MPEG-2 audio
+audio/x-mpeg-2				mp2a mpa2
+# compressed speech (Echo Speech Corp.)
+audio/echospeech			es
+# Toolvox speech audio (Voxware)
+audio/voxware				vox
+# RapidTransit compressed audio (Fast Man)
+application/fastman			lcc
+# Realaudio (Progressive Networks)
+application/x-pn-realaudio		ra ram
+# MIDI music data
+x-music/x-midi				mmid
+# Koan music data (SSeyo)
+application/vnd.koan			skp
+# Speech synthesis data (MVP Solutions)
+text/x-speech				talk
+
+# VIDEO TYPES
+
+# MPEG video
+video/mpeg				mpeg mpg mpe
+# MPEG-2 video
+video/mpeg-2				mpv2 mp2v
+# Macintosh Quicktime
+video/quicktime				qt mov
+# Microsoft video
+video/x-msvideo				avi
+# SGI Movie format
+video/x-sgi-movie			movie
+# VDOlive streaming video (VDOnet)
+video/vdo				vdo
+# Vivo streaming video (Vivo software)
+video/vnd.vivo				viv
+
+# SPECIAL HTTP/WEB APPLICATION TYPES
+
+# Proxy autoconfiguration (Netscape browsers)
+application/x-ns-proxy-autoconfig	pac
+# Netscape Cooltalk chat data (Netscape)
+x-conference/x-cooltalk			ice
+
+# TEXT-RELATED
+
+# PostScript
+application/postscript			ai eps ps
+# Microsoft Rich Text Format
+application/rtf				rtf
+# Adobe Acrobat PDF
+application/pdf				pdf
+# Maker Interchange Format (FrameMaker)
+application/vnd.mif			mif
+# Troff document
+application/x-troff			t tr roff
+# Troff document with MAN macros
+application/x-troff-man			man
+# Troff document with ME macros
+application/x-troff-me			me
+# Troff document with MS macros
+application/x-troff-ms			ms
+# LaTeX document
+application/x-latex			latex
+# Tex/LateX document
+application/x-tex			tex
+# GNU TexInfo document
+application/x-texinfo			texinfo texi
+# TeX dvi format
+application/x-dvi			dvi
+# MS word document
+application/msword			doc DOC
+# Office Document Architecture
+application/oda				oda
+# Envoy Document
+application/envoy			evy
+
+# ARCHIVE/COMPRESSED ARCHIVES
+
+# Gnu tar format
+application/x-gtar			gtar
+# 4.3BSD tar format
+application/x-tar			tar
+# POSIX tar format
+application/x-ustar			ustar
+# Old CPIO format
+application/x-bcpio			bcpio
+# POSIX CPIO format
+application/x-cpio			cpio
+# UNIX sh shell archive
+application/x-shar			shar
+# DOS/PC - Pkzipped archive
+application/zip				zip
+# Macintosh Binhexed archive
+application/mac-binhex40		hqx
+# Macintosh Stuffit Archive
+application/x-stuffit			sit sea
+# Fractal Image Format
+application/fractals			fif
+# "Binary UUencoded"
+application/octet-stream		bin uu
+# PC executable
+application/octet-stream		exe
+# "WAIS ""sources"""
+application/x-wais-source		src wsrc
+# NCSA HDF data format
+application/hdf				hdf
+
+# DOWNLOADABLE PROGRAM/SCRIPTS
+
+# Javascript program
+text/javascript				js ls mocha
+# UNIX bourne shell program
+application/x-sh			sh
+# UNIX c-shell program
+application/x-csh			csh
+# Perl program
+application/x-perl			pl
+# Tcl (Tool Control Language) program
+application/x-tcl			tcl
+
+# ANIMATION/MULTIMEDIA
+
+# FutureSplash vector animation (FutureWave)
+application/futuresplash		spl
+# mBED multimedia data (mBED)
+application/mbedlet			mbd
+# PowerMedia multimedia (RadMedia)
+application/x-rad-powermedia		rad
+
+# PRESENTATION
+
+# PowerPoint presentation (Microsoft)
+application/mspowerpoint		ppz
+# ASAP WordPower (Software Publishing Corp.)
+application/x-asap			asp
+# Astound Web Player multimedia data (GoldDisk)
+application/astound			asn
+
+# SPECIAL EMBEDDED OBJECT
+
+# OLE script e.g. Visual Basic (Ncompass)
+application/x-olescript			axs
+# OLE Object (Microsoft/NCompass)
+application/x-oleobject			ods
+# OpenScape OLE/OCX objects (Business@Web)
+x-form/x-openscape			opp
+# Visual Basic objects (Amara)
+application/x-webbasic			wba
+# Specialized data entry forms (Alpha Software)
+application/x-alpha-form		frm
+# client-server objects (Wayfarer Communications)
+x-script/x-wfxclient			wfx
+
+# GENERAL APPLICATIONS
+
+# Undefined binary data (often executable progs)
+application/octet-stream		exe com
+# Pointcast news data (Pointcast)
+application/x-pcn			pcn
+# Excel spreadsheet (Microsoft)
+application/vnd.ms-excel		xls
+# PowerPoint (Microsoft)
+application/vnd.ms-powerpoint		ppt
+# Microsoft Project (Microsoft)
+application/vnd.ms-project		mpp
+# SourceView document (Dataware Electronics)
+application/vnd.svd			svd
+# Net Install - software install (20/20 Software)
+application/x-net-install		ins
+# Carbon Copy - remote control/access (Microcom)
+application/ccv				ccv
+# Spreadsheets (Visual Components)
+workbook/formulaone			vts
+
+# 2D/3D DATA/VIRTUAL REALITY TYPES
+
+# VRML data file
+x-world/x-vrml				wrl vrml
+# WIRL - VRML data (VREAM)
+x-world/x-vream				vrw
+# Play3D 3d scene data (Play3D)
+application/x-p3d			p3d
+# Viscape Interactive 3d world data (Superscape)
+x-world/x-svr				svr
+# WebActive 3d data (Plastic Thought)
+x-world/x-wvr				wvr
+# QuickDraw3D scene data (Apple)
+x-world/x-3dmf				3dmf
+
+# SCIENTIFIC/MATH/CAD TYPES
+
+# Mathematica notebook
+application/mathematica			ma
+# Computational meshes for numerical simulations
+x-model/x-mesh				msh
+# Vis5D 5-dimensional data
+application/vis5d			v5d
+# IGES models -- CAD/CAM (CGM) data
+application/iges			igs
+# Autocad WHIP vector drawings
+drawing/x-dwf				dwf
+

classes/production/spring-context/META-INF/spring.handlers

@@ -0,0 +1,5 @@
+http\://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler
+http\://www.springframework.org/schema/jee=org.springframework.ejb.config.JeeNamespaceHandler
+http\://www.springframework.org/schema/lang=org.springframework.scripting.config.LangNamespaceHandler
+http\://www.springframework.org/schema/task=org.springframework.scheduling.config.TaskNamespaceHandler
+http\://www.springframework.org/schema/cache=org.springframework.cache.config.CacheNamespaceHandler

classes/production/spring-context/META-INF/spring.schemas

@@ -0,0 +1,44 @@
+http\://www.springframework.org/schema/context/spring-context-2.5.xsd=org/springframework/context/config/spring-context.xsd
+http\://www.springframework.org/schema/context/spring-context-3.0.xsd=org/springframework/context/config/spring-context.xsd
+http\://www.springframework.org/schema/context/spring-context-3.1.xsd=org/springframework/context/config/spring-context.xsd
+http\://www.springframework.org/schema/context/spring-context-3.2.xsd=org/springframework/context/config/spring-context.xsd
+http\://www.springframework.org/schema/context/spring-context-4.0.xsd=org/springframework/context/config/spring-context.xsd
+http\://www.springframework.org/schema/context/spring-context-4.1.xsd=org/springframework/context/config/spring-context.xsd
+http\://www.springframework.org/schema/context/spring-context-4.2.xsd=org/springframework/context/config/spring-context.xsd
+http\://www.springframework.org/schema/context/spring-context-4.3.xsd=org/springframework/context/config/spring-context.xsd
+http\://www.springframework.org/schema/context/spring-context.xsd=org/springframework/context/config/spring-context.xsd
+http\://www.springframework.org/schema/jee/spring-jee-2.0.xsd=org/springframework/ejb/config/spring-jee.xsd
+http\://www.springframework.org/schema/jee/spring-jee-2.5.xsd=org/springframework/ejb/config/spring-jee.xsd
+http\://www.springframework.org/schema/jee/spring-jee-3.0.xsd=org/springframework/ejb/config/spring-jee.xsd
+http\://www.springframework.org/schema/jee/spring-jee-3.1.xsd=org/springframework/ejb/config/spring-jee.xsd
+http\://www.springframework.org/schema/jee/spring-jee-3.2.xsd=org/springframework/ejb/config/spring-jee.xsd
+http\://www.springframework.org/schema/jee/spring-jee-4.0.xsd=org/springframework/ejb/config/spring-jee.xsd
+http\://www.springframework.org/schema/jee/spring-jee-4.1.xsd=org/springframework/ejb/config/spring-jee.xsd
+http\://www.springframework.org/schema/jee/spring-jee-4.2.xsd=org/springframework/ejb/config/spring-jee.xsd
+http\://www.springframework.org/schema/jee/spring-jee-4.3.xsd=org/springframework/ejb/config/spring-jee.xsd
+http\://www.springframework.org/schema/jee/spring-jee.xsd=org/springframework/ejb/config/spring-jee.xsd
+http\://www.springframework.org/schema/lang/spring-lang-2.0.xsd=org/springframework/scripting/config/spring-lang.xsd
+http\://www.springframework.org/schema/lang/spring-lang-2.5.xsd=org/springframework/scripting/config/spring-lang.xsd
+http\://www.springframework.org/schema/lang/spring-lang-3.0.xsd=org/springframework/scripting/config/spring-lang.xsd
+http\://www.springframework.org/schema/lang/spring-lang-3.1.xsd=org/springframework/scripting/config/spring-lang.xsd
+http\://www.springframework.org/schema/lang/spring-lang-3.2.xsd=org/springframework/scripting/config/spring-lang.xsd
+http\://www.springframework.org/schema/lang/spring-lang-4.0.xsd=org/springframework/scripting/config/spring-lang.xsd
+http\://www.springframework.org/schema/lang/spring-lang-4.1.xsd=org/springframework/scripting/config/spring-lang.xsd
+http\://www.springframework.org/schema/lang/spring-lang-4.2.xsd=org/springframework/scripting/config/spring-lang.xsd
+http\://www.springframework.org/schema/lang/spring-lang-4.3.xsd=org/springframework/scripting/config/spring-lang.xsd
+http\://www.springframework.org/schema/lang/spring-lang.xsd=org/springframework/scripting/config/spring-lang.xsd
+http\://www.springframework.org/schema/task/spring-task-3.0.xsd=org/springframework/scheduling/config/spring-task.xsd
+http\://www.springframework.org/schema/task/spring-task-3.1.xsd=org/springframework/scheduling/config/spring-task.xsd
+http\://www.springframework.org/schema/task/spring-task-3.2.xsd=org/springframework/scheduling/config/spring-task.xsd
+http\://www.springframework.org/schema/task/spring-task-4.0.xsd=org/springframework/scheduling/config/spring-task.xsd
+http\://www.springframework.org/schema/task/spring-task-4.1.xsd=org/springframework/scheduling/config/spring-task.xsd
+http\://www.springframework.org/schema/task/spring-task-4.2.xsd=org/springframework/scheduling/config/spring-task.xsd
+http\://www.springframework.org/schema/task/spring-task-4.3.xsd=org/springframework/scheduling/config/spring-task.xsd
+http\://www.springframework.org/schema/task/spring-task.xsd=org/springframework/scheduling/config/spring-task.xsd
+http\://www.springframework.org/schema/cache/spring-cache-3.1.xsd=org/springframework/cache/config/spring-cache.xsd
+http\://www.springframework.org/schema/cache/spring-cache-3.2.xsd=org/springframework/cache/config/spring-cache.xsd
+http\://www.springframework.org/schema/cache/spring-cache-4.0.xsd=org/springframework/cache/config/spring-cache.xsd
+http\://www.springframework.org/schema/cache/spring-cache-4.1.xsd=org/springframework/cache/config/spring-cache.xsd
+http\://www.springframework.org/schema/cache/spring-cache-4.2.xsd=org/springframework/cache/config/spring-cache.xsd
+http\://www.springframework.org/schema/cache/spring-cache-4.3.xsd=org/springframework/cache/config/spring-cache.xsd
+http\://www.springframework.org/schema/cache/spring-cache.xsd=org/springframework/cache/config/spring-cache.xsd

classes/production/spring-context/META-INF/spring.tooling

@@ -0,0 +1,24 @@
+# Tooling related information for the context namespace
+http\://www.springframework.org/schema/context@name=context Namespace
+http\://www.springframework.org/schema/context@prefix=context
+http\://www.springframework.org/schema/context@icon=org/springframework/context/config/spring-context.gif
+
+# Tooling related information for the jee namespace
+http\://www.springframework.org/schema/jee@name=jee Namespace
+http\://www.springframework.org/schema/jee@prefix=jee
+http\://www.springframework.org/schema/jee@icon=org/springframework/ejb/config/spring-jee.gif
+
+# Tooling related information for the scheduling namespace
+http\://www.springframework.org/schema/task@name=task Namespace
+http\://www.springframework.org/schema/task@prefix=task
+http\://www.springframework.org/schema/task@icon=org/springframework/scheduling/config/spring-task.gif
+
+# Tooling related information for the lang namespace
+http\://www.springframework.org/schema/lang@name=lang Namespace
+http\://www.springframework.org/schema/lang@prefix=lang
+http\://www.springframework.org/schema/lang@icon=org/springframework/scripting/config/spring-lang.gif
+
+# Tooling related information for the cache namespace
+http\://www.springframework.org/schema/cache@name=cache Namespace
+http\://www.springframework.org/schema/cache@prefix=cache
+http\://www.springframework.org/schema/cache@icon=org/springframework/cache/config/spring-cache.gif

classes/production/spring-context/org/springframework/cache/config/spring-cache.xsd

@@ -0,0 +1,317 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+
+<xsd:schema xmlns="http://www.springframework.org/schema/cache"
+		xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+		xmlns:beans="http://www.springframework.org/schema/beans"
+		xmlns:tool="http://www.springframework.org/schema/tool"
+		targetNamespace="http://www.springframework.org/schema/cache"
+		elementFormDefault="qualified"
+		attributeFormDefault="unqualified">
+
+	<xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd"/>
+
+	<xsd:annotation>
+		<xsd:documentation><![CDATA[
+	Defines the elements used in the Spring Framework's declarative
+	cache management infrastructure.
+		]]></xsd:documentation>
+	</xsd:annotation>
+
+	<xsd:element name="annotation-driven">
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.cache.annotation.AnnotationCacheOperationDefinitionSource"><![CDATA[
+	Indicates that cache configuration is defined by Java 5
+	annotations on bean classes, and that proxies are automatically
+	to be created for the relevant annotated beans.
+
+	The default annotations supported are Spring's @Cacheable, @CachePut and @CacheEvict. If
+	spring-context-support and the JSR-107 API are on the classpath, additional proxies are
+	automatically created for JSR-107 annotated beans, that is @CacheResult, @CachePut,
+	@CacheRemove and @CacheRemoveAll.
+
+	See org.springframework.cache.annotation.EnableCaching Javadoc
+	for information on code-based alternatives to this XML element.
+				]]></xsd:documentation>
+			</xsd:annotation>
+			<xsd:attribute name="cache-manager" type="xsd:string" default="cacheManager">
+				<xsd:annotation>
+					<xsd:documentation source="java:org.springframework.cache.CacheManager"><![CDATA[
+	The bean name of the CacheManager that is to be used to retrieve the backing
+	caches. A default CacheResolver will be initialized behind the scenes with
+	this cache manager (or "cacheManager" if not set). For more fine-grained
+	management of the cache resolution, consider setting the 'cache-resolver'
+	attribute.
+
+	Note that this attribute is still mandatory if you are using JSR-107 as an
+	additional exception cache resolver should be created and requires a CacheManager
+	to do so.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.cache.CacheManager"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="cache-resolver" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation source="java:org.springframework.cache.interceptor.CacheResolver"><![CDATA[
+	The bean name of the CacheResolver that is to be used to resolve the backing caches.
+
+	This attribute is not required, and only needs to be specified as an alternative to
+	the 'cache-manager' attribute. See the javadoc of CacheResolver for more details.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.cache.interceptor.CacheResolver"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="key-generator" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation source="java:org.springframework.cache.interceptor.KeyGenerator"><![CDATA[
+	The bean name of the KeyGenerator that is to be used to retrieve the backing caches.
+
+	This attribute is not required, and only needs to be specified
+	explicitly if the default strategy (DefaultKeyGenerator) is not sufficient.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.cache.interceptor.KeyGenerator"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="error-handler" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation source="java:org.springframework.cache.interceptor.CacheErrorHandler"><![CDATA[
+	The bean name of the CacheErrorHandler that is to be used to handle cache-related errors.
+
+	This attribute is not required, and only needs to be specified
+	explicitly if the default strategy (SimpleCacheErrorHandler) is not sufficient.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.cache.interceptor.CacheErrorHandler"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="mode" default="proxy">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Should annotated beans be proxied using Spring's AOP framework,
+	or should they rather be weaved with an AspectJ transaction aspect?
+
+	AspectJ weaving requires spring-aspects.jar on the classpath,
+	as well as load-time weaving (or compile-time weaving) enabled.
+
+	Note: The weaving-based aspect requires the @Cacheable and @CacheInvalidate
+	annotations to be defined on the concrete class. Annotations in interfaces
+	will not work in that case (they will rather only work with interface-based proxies)!
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="proxy"/>
+						<xsd:enumeration value="aspectj"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="proxy-target-class" type="xsd:boolean" default="false">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Are class-based (CGLIB) proxies to be created? By default, standard
+	Java interface-based proxies are created.
+
+	Note: Class-based proxies require the @Cacheable and @CacheInvalidate annotations
+	to be defined on the concrete class. Annotations in interfaces will not work
+	in that case (they will rather only work with interface-based proxies)!
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="order" type="xsd:token">
+				<xsd:annotation>
+					<xsd:documentation source="java:org.springframework.core.Ordered"><![CDATA[
+	Controls the ordering of the execution of the cache advisor
+	when multiple advice executes at a specific joinpoint.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="advice">
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.cache.interceptor.CacheInterceptor"><![CDATA[
+	Defines the cache semantics of the AOP advice that is to be
+	executed.
+
+	That is, this advice element is where the cacheable semantics of
+	any	number of methods are defined (where cacheable semantics
+	includes the backing cache(s), the key, cache condition rules, and suchlike).
+				]]></xsd:documentation>
+				<xsd:appinfo>
+					<tool:annotation>
+						<tool:exports type="java:org.springframework.cache.interceptor.CacheInterceptor"/>
+					</tool:annotation>
+				</xsd:appinfo>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="beans:identifiedType">
+					<xsd:sequence>
+						<xsd:element name="caching" type="definitionsType" minOccurs="0" maxOccurs="unbounded"/>
+					</xsd:sequence>
+					<xsd:attribute name="cache-manager" type="xsd:string" default="cacheManager">
+						<xsd:annotation>
+							<xsd:documentation source="java:org.springframework.cache.CacheManager"><![CDATA[
+	The bean name of the CacheManager that is to be used
+	for storing and retrieving data.
+
+	This attribute is not required, and only needs to be specified
+	explicitly if the bean name of the desired CacheManager
+	is not 'cacheManager'.
+							]]></xsd:documentation>
+							<xsd:appinfo>
+								<tool:annotation kind="ref">
+									<tool:expected-type type="org.springframework.cache.CacheManager"/>
+								</tool:annotation>
+							</xsd:appinfo>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="key-generator" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation source="java:org.springframework.cache.interceptor.KeyGenerator"><![CDATA[
+	The bean name of the KeyGenerator that is to be used to retrieve the backing caches.
+
+	This attribute is not required, and only needs to be specified
+	explicitly if the default strategy (DefaultKeyGenerator) is not sufficient.
+							]]></xsd:documentation>
+							<xsd:appinfo>
+								<tool:annotation kind="ref">
+									<tool:expected-type type="org.springframework.cache.interceptor.KeyGenerator"/>
+								</tool:annotation>
+							</xsd:appinfo>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:complexType name="basedefinitionType">
+		<xsd:attribute name="cache" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The name of the backing cache(s). Multiple caches can be specified by separating them using comma: 'orders, books']]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="key" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The SpEL expression used for computing the cache key, mutually exclusive with the key-generator parameter.]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+        <xsd:attribute name="key-generator" type="xsd:string" use="optional">
+            <xsd:annotation>
+                <xsd:documentation><![CDATA[
+	The name of the KeyGenerator bean responsible to compute the key, mutually exclusive with the key parameter.]]></xsd:documentation>
+            </xsd:annotation>
+        </xsd:attribute>
+		<xsd:attribute name="cache-manager" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The name of the CacheManager bean responsible to manage the operation.]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="condition" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The SpEL expression used for conditioning the method caching.]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="method" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The method name(s) with which the cache attributes are to be
+	associated. The wildcard (*) character can be used to associate the
+	same cache attribute settings with a number of methods; for
+	example, 'get*', 'handle*', '*Order', 'on*Event', etc.]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+
+	</xsd:complexType>
+
+	<xsd:complexType name="definitionsType">
+		<xsd:complexContent>
+			<xsd:extension base="basedefinitionType">
+				<xsd:sequence>
+				  <xsd:choice minOccurs="0" maxOccurs="unbounded">
+					<xsd:element name="cacheable" minOccurs="0" maxOccurs="unbounded">
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="basedefinitionType">
+									<xsd:attribute name="unless" type="xsd:string" use="optional">
+										<xsd:annotation>
+											<xsd:documentation><![CDATA[
+	The SpEL expression used to veto the method caching.]]></xsd:documentation>
+										</xsd:annotation>
+									</xsd:attribute>
+									<xsd:attribute name="sync" type="xsd:boolean" use="optional" default="false">
+										<xsd:annotation>
+											<xsd:documentation><![CDATA[
+	Synchronize the invocation of the underlying method if several threads
+	are attempting to load a value for the same key]]></xsd:documentation>
+										</xsd:annotation>
+									</xsd:attribute>
+								</xsd:extension>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="cache-put" minOccurs="0" maxOccurs="unbounded">
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="basedefinitionType">
+									<xsd:attribute name="unless" type="xsd:string" use="optional">
+										<xsd:annotation>
+											<xsd:documentation><![CDATA[
+	The SpEL expression used to veto the method caching.]]></xsd:documentation>
+										</xsd:annotation>
+									</xsd:attribute>
+								</xsd:extension>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="cache-evict" minOccurs="0" maxOccurs="unbounded">
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="basedefinitionType">
+									<xsd:attribute name="all-entries" type="xsd:boolean" use="optional">
+										<xsd:annotation>
+											<xsd:documentation><![CDATA[
+	Whether all the entries should be evicted.]]></xsd:documentation>
+										</xsd:annotation>
+									</xsd:attribute>
+									<xsd:attribute name="before-invocation" type="xsd:boolean" use="optional">
+										<xsd:annotation>
+											<xsd:documentation><![CDATA[
+	Whether the eviction should occur after the method is successfully
+	invoked (default) or before.]]></xsd:documentation>
+										</xsd:annotation>
+									</xsd:attribute>
+
+								</xsd:extension>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+				  </xsd:choice>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+
+</xsd:schema>

classes/production/spring-context/org/springframework/context/config/spring-context.xsd

@@ -0,0 +1,547 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<xsd:schema xmlns="http://www.springframework.org/schema/context"
+		xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+		xmlns:beans="http://www.springframework.org/schema/beans"
+		xmlns:tool="http://www.springframework.org/schema/tool"
+		targetNamespace="http://www.springframework.org/schema/context"
+		elementFormDefault="qualified"
+		attributeFormDefault="unqualified">
+
+	<xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd"/>
+
+	<xsd:annotation>
+		<xsd:documentation><![CDATA[
+	Defines the configuration elements for the Spring Framework's application
+	context support. Effects the activation of various configuration styles
+	for the containing Spring ApplicationContext.
+		]]></xsd:documentation>
+	</xsd:annotation>
+
+	<xsd:complexType name="propertyLoading">
+		<xsd:attribute name="location" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The location of the properties file to resolve placeholders against, as a Spring
+	resource location: a URL, a "classpath:" pseudo URL, or a relative file path.
+	Multiple locations may be specified, separated by commas. If neither location nor
+	properties-ref is specified, placeholders will be resolved against system properties.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="properties-ref" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:java.util.Properties"><![CDATA[
+	The bean name of a Properties object that will be used for property substitution.
+	If neither location nor properties-ref is specified, placeholders will be resolved
+	against system properties.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="file-encoding" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Specifies the encoding to use for parsing properties files. Default is none,
+	using the java.util.Properties default encoding. Only applies to classic
+	properties files, not to XML files.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="order" type="xsd:token">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Specifies the order for this placeholder configurer. If more than one is present
+	in a context, the order can be important since the first one to be match a
+	placeholder will win.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="ignore-resource-not-found" type="xsd:boolean" default="false">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Specifies if failure to find the property resource location should be ignored.
+	Default is "false", meaning that if there is no file in the location specified
+	an exception will be raised at runtime.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="ignore-unresolvable" type="xsd:boolean" default="false">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Specifies if failure to find the property value to replace a key should be ignored.
+	Default is "false", meaning that this placeholder configurer will raise an exception
+	if it cannot resolve a key. Set to "true" to allow the configurer to pass on the key
+	to any others in the context that have not yet visited the key in question.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="local-override" type="xsd:boolean" default="false">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Specifies whether local properties override properties from files.
+	Default is "false": Properties from files override local defaults.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:element name="property-placeholder">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Activates replacement of ${...} placeholders by registering a
+	PropertySourcesPlaceholderConfigurer within the application context. Properties will
+	be resolved against the specified properties file or Properties object -- so called
+	"local properties", if any, and against the Spring Environment's current set of
+	PropertySources.
+
+	Note that as of Spring 3.1 the system-properties-mode attribute has been removed in
+	favor of the more flexible PropertySources mechanism. However, applications may
+	continue to use the 3.0 (and older) versions of the spring-context schema in order
+	to preserve system-properties-mode behavior. In this case, the traditional
+	PropertyPlaceholderConfigurer component will be registered instead of the newer
+	PropertySourcesPlaceholderConfigurer.
+
+	See ConfigurableEnvironment javadoc for more information on usage.
+			]]></xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="org.springframework.context.support.PropertySourcesPlaceholderConfigurer"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="propertyLoading">
+					<xsd:attribute name="system-properties-mode" default="ENVIRONMENT">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	Controls how to resolve placeholders against system properties. As of Spring 3.1, this
+	attribute value defaults to "ENVIRONMENT", indicating that resolution of placeholders
+	against system properties is handled via PropertySourcesPlaceholderConfigurer and its
+	delegation to the current Spring Environment object.
+
+	For maximum backward compatibility, this attribute is preserved going forward with the
+	3.1 version of the context schema, and any values other than the default "ENVIRONMENT"
+	will cause a traditional PropertyPlaceholderConfigurer to be registered instead of the
+	newer PropertySourcesPlaceholderConfigurer variant. In this case, the Spring Environment
+	and its property sources are not interrogated when resolving placeholders. Users are
+	encouraged to consider this attribute deprecated, and to take advantage of the
+	Environment and PropertySource mechanisms. See ConfigurableEnvironment javadoc for examples.
+
+	"ENVIRONMENT" indicates placeholders should be resolved against the current Environment and against any local properties;
+	"NEVER" indicates placeholders should be resolved only against local properties and never against system properties;
+	"FALLBACK" indicates placeholders should be resolved against any local properties and then against system properties;
+	"OVERRIDE" indicates placeholders should be resolved first against system properties and then against any local properties;
+							]]></xsd:documentation>
+						</xsd:annotation>
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:enumeration value="ENVIRONMENT"/>
+								<xsd:enumeration value="NEVER"/>
+								<xsd:enumeration value="FALLBACK"/>
+								<xsd:enumeration value="OVERRIDE"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:attribute>
+					<xsd:attribute name="value-separator" default=":">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The separating character between the placeholder variable and the associated
+	default value: by default, a ':' symbol.
+				]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="trim-values">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	Whether to trim resolved values before applying them, removing superfluous
+	whitespace (in particular tab characters) from the beginning and end.
+				]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="null-value">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	A value that should be treated as 'null' when resolved as a placeholder value:
+	e.g. "" (empty String) or "null". By default, no such null value is defined.
+				]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="property-override">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Activates pushing of override values into bean properties, based on configuration
+	lines of the following format: beanName.property=value
+			]]></xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="org.springframework.beans.factory.config.PropertyOverrideConfigurer"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="propertyLoading"/>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="annotation-config">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Activates various annotations to be detected in bean classes: Spring's @Required and
+	@Autowired, as well as JSR 250's @PostConstruct, @PreDestroy and @Resource (if available),
+	JAX-WS's @WebServiceRef (if available), EJB 3's @EJB (if available), and JPA's
+	@PersistenceContext and @PersistenceUnit (if available). Alternatively, you may
+	choose to activate the individual BeanPostProcessors for those annotations.
+
+	Note: This tag does not activate processing of Spring's @Transactional or EJB 3's
+	@TransactionAttribute annotation. Consider the use of the <tx:annotation-driven>
+	tag for that purpose.
+
+	See javadoc for org.springframework.context.annotation.AnnotationConfigApplicationContext
+	for information on code-based alternatives to bootstrapping annotation-driven support.
+			]]></xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+
+	<xsd:element name="component-scan">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Scans the classpath for annotated components that will be auto-registered as
+	Spring beans. By default, the Spring-provided @Component, @Repository, @Service,
+	@Controller, @RestController, @ControllerAdvice, and @Configuration stereotypes
+	will be detected.
+
+	Note: This tag implies the effects of the 'annotation-config' tag, activating @Required,
+	@Autowired, @PostConstruct, @PreDestroy, @Resource, @PersistenceContext and @PersistenceUnit
+	annotations in the component classes, which is usually desired for autodetected components
+	(without external configuration). Turn off the 'annotation-config' attribute to deactivate
+	this default behavior, for example in order to use custom BeanPostProcessor definitions
+	for handling those annotations.
+
+	Note: You may use placeholders in package paths, but only resolved against system
+	properties (analogous to resource paths). A component scan results in new bean definitions
+	being registered; Spring's PropertySourcesPlaceholderConfigurer will apply to those bean
+	definitions just like to regular bean definitions, but it won't apply to the component
+	scan settings themselves.
+
+	See javadoc for org.springframework.context.annotation.ComponentScan for information
+	on code-based alternatives to bootstrapping component-scanning.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:sequence>
+				<xsd:element name="include-filter" type="filterType"
+					minOccurs="0" maxOccurs="unbounded">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	Controls which eligible types to include for component scanning.
+	Note that these filters will be applied in addition to the default filters, if specified.
+	Any type under the specified base packages which matches a given filter will be included,
+	even if it does not match the default filters (i.e. is not annotated with @Component).
+							]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+				<xsd:element name="exclude-filter" type="filterType"
+					minOccurs="0" maxOccurs="unbounded">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	Controls which eligible types to exclude for component scanning.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+			</xsd:sequence>
+			<xsd:attribute name="base-package" type="xsd:string"
+				use="required">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The comma/semicolon/space/tab/linefeed-separated list of packages to scan for annotated components.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="resource-pattern" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Controls the class files eligible for component detection. Defaults to "**/*.class", the recommended value.
+	Consider use of the include-filter and exclude-filter elements for a more fine-grained approach.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="use-default-filters" type="xsd:boolean"
+				default="true">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Indicates whether automatic detection of classes annotated with @Component, @Repository, @Service,
+	or @Controller should be enabled. Default is "true".
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="annotation-config" type="xsd:boolean"
+				default="true">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Indicates whether the implicit annotation post-processors should be enabled. Default is "true".
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="name-generator" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The fully-qualified class name of the BeanNameGenerator to be used for naming detected components.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation>
+							<tool:expected-type type="java.lang.Class"/>
+							<tool:assignable-to type="org.springframework.beans.factory.support.BeanNameGenerator"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="scope-resolver" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The fully-qualified class name of the ScopeMetadataResolver to be used for resolving the scope of
+	detected components.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation>
+							<tool:expected-type type="java.lang.Class"/>
+							<tool:assignable-to type="org.springframework.context.annotation.ScopeMetadataResolver"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="scoped-proxy">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Indicates whether proxies should be generated for detected components, which may be necessary
+	when using scopes in a proxy-style fashion. Default is to generate no such proxies.
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="no"/>
+						<xsd:enumeration value="interfaces"/>
+						<xsd:enumeration value="targetClass"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="load-time-weaver">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Activates a Spring LoadTimeWeaver for this application context, available as
+	a bean with the name "loadTimeWeaver". Any bean that implements the
+	LoadTimeWeaverAware interface will then receive the LoadTimeWeaver reference
+	automatically; for example, Spring's JPA bootstrap support.
+
+	The default weaver is determined automatically: see DefaultContextLoadTimeWeaver's
+	javadoc for details.
+
+	The activation of AspectJ load-time weaving is specified via a simple flag
+	(the 'aspectj-weaving' attribute), with the AspectJ class transformer
+	registered through Spring's LoadTimeWeaver. AspectJ weaving will be activated
+	by default if a "META-INF/aop.xml" resource is present in the classpath.
+
+	This also activates the current application context for applying dependency
+	injection to non-managed classes that are instantiated outside of the Spring
+	bean factory (typically classes annotated with the @Configurable annotation).
+	This will only happen if the AnnotationBeanConfigurerAspect is on the classpath
+	(i.e. spring-aspects.jar), effectively activating "spring-configured" by default.
+
+	See javadoc for org.springframework.context.annotation.EnableLoadTimeWeaving
+	for information on code-based alternatives to bootstrapping load-time weaving support.
+			]]></xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="org.springframework.instrument.classloading.LoadTimeWeaver"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:attribute name="weaver-class" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The fully-qualified classname of the LoadTimeWeaver that is to be activated.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation>
+							<tool:expected-type type="java.lang.Class"/>
+							<tool:assignable-to type="org.springframework.instrument.classloading.LoadTimeWeaver"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="aspectj-weaving" default="autodetect">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="on">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+	Switches Spring-based AspectJ load-time weaving on.
+								]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="off">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+	Switches Spring-based AspectJ load-time weaving off.
+								]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="autodetect">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+	Switches AspectJ load-time weaving on if a "META-INF/aop.xml" resource
+	is present in the classpath. If there is no such resource, then AspectJ
+	load-time weaving will be switched off.
+								]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:enumeration>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="spring-configured">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect"><![CDATA[
+	Signals the current application context to apply dependency injection
+	to non-managed classes that are instantiated outside of the Spring bean
+	factory (typically classes annotated with the @Configurable annotation).
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:simpleType>
+			<xsd:restriction base="xsd:string"/>
+		</xsd:simpleType>
+	</xsd:element>
+
+	<xsd:element name="mbean-export">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.jmx.export.annotation.AnnotationMBeanExporter"><![CDATA[
+	Activates default exporting of MBeans by detecting standard MBeans in the Spring
+	context as well as @ManagedResource annotations on Spring-defined beans.
+
+	The resulting MBeanExporter bean is defined under the name "mbeanExporter".
+	Alternatively, consider defining a custom AnnotationMBeanExporter bean explicitly.
+			]]></xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="org.springframework.jmx.export.annotation.AnnotationMBeanExporter"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:attribute name="default-domain" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The default domain to use when generating JMX ObjectNames.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="server" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The bean name of the MBeanServer to which MBeans should be exported.
+	Default is to use the platform's default MBeanServer (autodetecting
+	WebLogic, WebSphere and the JVM's platform MBeanServer).
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="registration">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The registration behavior, indicating how to deal with existing MBeans
+	of the same name: fail with an exception, ignore and keep the existing
+	MBean, or replace the existing one with the new MBean.
+
+	Default is to fail with an exception.
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:NMTOKEN">
+						<xsd:enumeration value="failOnExisting"/>
+						<xsd:enumeration value="ignoreExisting"/>
+						<xsd:enumeration value="replaceExisting"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="mbean-server">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.jmx.support.MBeanServerFactoryBean"><![CDATA[
+	Exposes a default MBeanServer for the current platform.
+	Autodetects WebLogic, WebSphere and the JVM's platform MBeanServer.
+
+	The default bean name for the exposed MBeanServer is "mbeanServer".
+	This may be customized through specifying the "id" attribute.
+			]]></xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="javax.management.MBeanServer"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="beans:identifiedType">
+					<xsd:attribute name="agent-id" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The agent id of the target MBeanServer, if any.
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:complexType name="filterType">
+		<xsd:attribute name="type" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+    Controls the type of filtering to apply to the expression.
+
+    "annotation" indicates an annotation to be present at the type level in target components;
+    "assignable" indicates a class (or interface) that the target components are assignable to (extend/implement);
+    "aspectj" indicates an AspectJ type pattern expression to be matched by the target components;
+    "regex" indicates a regex pattern to be matched by the target components' class names;
+    "custom" indicates a custom implementation of the org.springframework.core.type.TypeFilter interface.
+
+    Note: This attribute will not be inherited by child bean definitions.
+    Hence, it needs to be specified per concrete bean definition.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+			<xsd:simpleType>
+				<xsd:restriction base="xsd:string">
+					<xsd:enumeration value="annotation"/>
+					<xsd:enumeration value="assignable"/>
+					<xsd:enumeration value="aspectj"/>
+					<xsd:enumeration value="regex"/>
+					<xsd:enumeration value="custom"/>
+				</xsd:restriction>
+			</xsd:simpleType>
+		</xsd:attribute>
+		<xsd:attribute name="expression" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+    Indicates the filter expression, the type of which is indicated by "type".
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+</xsd:schema>

classes/production/spring-context/org/springframework/ejb/config/spring-jee.xsd

@@ -0,0 +1,267 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+
+<xsd:schema xmlns="http://www.springframework.org/schema/jee"
+		xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+		xmlns:beans="http://www.springframework.org/schema/beans"
+		xmlns:tool="http://www.springframework.org/schema/tool"
+		targetNamespace="http://www.springframework.org/schema/jee"
+		elementFormDefault="qualified"
+		attributeFormDefault="unqualified">
+
+	<xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd"/>
+
+	<xsd:annotation>
+		<xsd:documentation><![CDATA[
+	Defines configuration elements for access to traditional Java EE components
+	such as JNDI resources and EJB session beans.
+		]]></xsd:documentation>
+	</xsd:annotation>
+
+	<xsd:element name="jndi-lookup">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.jndi.JndiObjectFactoryBean"><![CDATA[
+	Exposes an object reference via a JNDI lookup.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="jndiLocatingType">
+					<xsd:attribute name="cache" type="xsd:boolean" default="true">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	Controls whether the object returned from the JNDI lookup is cached
+	after the first lookup.
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="expected-type" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation source="java:java.lang.Class"><![CDATA[
+	The type that the located JNDI object is supposed to be assignable
+	to, if indeed any.
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="lookup-on-startup" type="xsd:boolean" default="true">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	Controls whether the JNDI lookup is performed immediately on startup
+	(if true, the default), or on first access (if false).
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="proxy-interface" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation source="java:java.lang.Class"><![CDATA[
+	The proxy interface to use for the JNDI object.
+
+	Needs to be specified because the actual JNDI object type is not
+	known in advance in case of a lazy lookup.
+
+	Typically used in conjunction with "lookupOnStartup"=false and/or
+	"cache"=false.
+							]]></xsd:documentation>
+							<xsd:appinfo>
+								<tool:annotation>
+									<tool:expected-type type="java.lang.Class"/>
+								</tool:annotation>
+							</xsd:appinfo>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="default-value" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	Specify a default literal value to fall back to if the JNDI lookup fails.
+	This is typically used for literal values in scenarios where the JNDI environment
+	might define specific config settings but those are not required to be present.
+
+	Default is none. Note: This is only supported for lookup on startup.
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="default-ref" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	Specify a default bean reference to fall back to if the JNDI lookup fails.
+	This might for example point to a local fallback DataSource.
+
+	Default is none. Note: This is only supported for lookup on startup.
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="local-slsb" type="ejbType">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.ejb.access.LocalStatelessSessionProxyFactoryBean"><![CDATA[
+	Exposes a reference to a local EJB Stateless SessionBean.
+			]]></xsd:documentation>
+		</xsd:annotation>
+	</xsd:element>
+
+	<xsd:element name="remote-slsb">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.ejb.access.SimpleRemoteStatelessSessionProxyFactoryBean"><![CDATA[
+	Exposes a reference to a remote EJB Stateless SessionBean.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="ejbType">
+					<xsd:attribute name="home-interface" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation source="java:java.lang.Class"><![CDATA[
+	The home interface that will be narrowed to before performing
+	the parameterless SLSB create() call that returns the actual
+	SLSB proxy.
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="refresh-home-on-connect-failure" type="xsd:boolean" default="false">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	Controls whether to refresh the EJB home on connect failure.
+
+	Can be turned on to allow for hot restart of the EJB server.
+	If a cached EJB home throws an RMI exception that indicates a
+	remote connect failure, a fresh home will be fetched and the
+	invocation will be retried.
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="cache-session-bean" type="xsd:boolean" default="false">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	Controls whether to cache the actual session bean object.
+
+	Off by default for standard EJB compliance. Turn this flag
+	on to optimize session bean access for servers that are
+	known to allow for caching the actual session bean object.
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<!-- base types -->
+	<xsd:complexType name="jndiLocatingType" abstract="true">
+		<xsd:complexContent>
+			<xsd:extension base="beans:identifiedType">
+				<xsd:sequence>
+					<xsd:element name="environment" minOccurs="0" maxOccurs="1">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The newline-separated, key-value pairs for the JNDI environment
+	(in standard Properties format, namely 'key=value' pairs)
+						 ]]></xsd:documentation>
+						</xsd:annotation>
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string"/>
+						</xsd:simpleType>
+					</xsd:element>
+				</xsd:sequence>
+				<xsd:attribute name="environment-ref" type="environmentRefType">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	A reference to JNDI environment properties, indicating the name of a
+	shared bean of type [java.util.Properties}.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="jndi-name" type="xsd:string" use="required">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	The JNDI name to look up. This may be a fully-qualified JNDI path
+	or a local Java EE environment naming context path in which case the
+	prefix "java:comp/env/" will be prepended if applicable.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="resource-ref" type="xsd:boolean" default="true">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	Controls whether the lookup occurs in a Java EE container, i.e. if the
+	prefix "java:comp/env/" needs to be added if the JNDI name doesn't
+	already contain it. Default is "true" (since Spring 2.5).
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="expose-access-context" type="xsd:boolean" default="false">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	Set whether to expose the JNDI environment context for all access to the target
+	EJB, i.e. for all method invocations on the exposed object reference.
+	Default is "false", i.e. to only expose the JNDI context for object lookup.
+
+	Switch this flag to "true" in order to expose the JNDI environment (including
+	the authorization context) for each EJB invocation, as needed by WebLogic
+	for EJBs with authorization requirements.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="lazy-init" default="default" type="beans:defaultable-boolean">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	Indicates whether or not this bean is to be lazily initialized.
+	If false, it will be instantiated on startup by bean factories
+	that perform eager initialization of singletons. The default is
+	"false".
+	
+	Note: This attribute will not be inherited by child bean definitions.
+	Hence, it needs to be specified per concrete bean definition.
+	    				]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+
+	<xsd:complexType name="ejbType">
+		<xsd:complexContent>
+			<xsd:extension base="jndiLocatingType">
+				<xsd:attribute name="lookup-home-on-startup" type="xsd:boolean" default="true">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	Controls whether the lookup of the EJB home object is performed
+	immediately on startup (if true, the default), or on first access
+	(if false).
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="cache-home" type="xsd:boolean" default="true">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	Controls whether the EJB home object is cached once it has been located.
+	On by default; turn this flag off to always reobtain fresh home objects.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="business-interface" type="xsd:string" use="required">
+					<xsd:annotation>
+						<xsd:documentation source="java:java.lang.Class"><![CDATA[
+	The business interface of the EJB being proxied.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+
+	<xsd:simpleType name="environmentRefType">
+		<xsd:annotation>
+			<xsd:appinfo>
+				<tool:annotation kind="ref">
+					<tool:expected-type type="java.util.Properties"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:union memberTypes="xsd:string"/>
+	</xsd:simpleType>
+
+</xsd:schema>

classes/production/spring-context/org/springframework/remoting/rmi/RmiInvocationWrapperRTD.xml

@@ -0,0 +1,11 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!DOCTYPE rmi PUBLIC "-//BEA Systems, Inc.//RMI Runtime DTD 1.0//EN" "rmi.dtd">
+
+<!--
+  - Special WebLogic deployment descriptor for Spring's RMI invoker.
+  - Only applied by WebLogic Server, ignored on other platforms.
+  -->
+<rmi name="org.springframework.remoting.rmi.RmiInvocationWrapper">
+	<cluster clusterable="true"/>
+	<method name="getTargetInterfaceName" idempotent="true"/>
+</rmi>

classes/production/spring-context/org/springframework/scheduling/config/spring-task.xsd

@@ -0,0 +1,309 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+
+<xsd:schema xmlns="http://www.springframework.org/schema/task"
+			xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+			xmlns:tool="http://www.springframework.org/schema/tool"
+			targetNamespace="http://www.springframework.org/schema/task"
+			elementFormDefault="qualified"
+			attributeFormDefault="unqualified">
+
+	<xsd:annotation>
+		<xsd:documentation><![CDATA[
+	Defines the elements used in the Spring Framework's support for task execution and scheduling.
+		]]></xsd:documentation>
+	</xsd:annotation>
+
+	<xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd"/>
+
+	<xsd:element name="annotation-driven">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Enables the detection of @Async and @Scheduled annotations on any Spring-managed
+	object. If present, a proxy will be generated for executing the annotated methods
+	asynchronously.
+
+	See Javadoc for the org.springframework.scheduling.annotation.EnableAsync and
+	org.springframework.scheduling.annotation.EnableScheduling annotations for information
+	on code-based alternatives to this XML element.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:attribute name="executor" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Specifies the java.util.Executor instance to use when invoking asynchronous methods.
+	If not provided, an instance of org.springframework.core.task.SimpleAsyncTaskExecutor
+	will be used by default.
+	Note that as of Spring 3.1.2, individual @Async methods may qualify which executor to
+	use, meaning that the executor specified here acts as a default for all non-qualified
+	@Async methods.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="exception-handler" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Specifies the org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler
+	instance to use when an exception is thrown during an asynchronous method execution
+	and cannot be accessed by the caller. If not provided, an instance of
+	org.springframework.aop.interceptor.SimpleAsyncUncaughtExceptionHandler will be
+	used by default.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="scheduler" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Specifies the org.springframework.scheduling.TaskScheduler or
+	java.util.ScheduledExecutorService instance to use when invoking scheduled
+	methods. If no reference is provided, a TaskScheduler backed by a single
+	thread scheduled executor will be used.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="mode" default="proxy">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Should annotated beans be proxied using Spring's AOP framework,
+	or should they rather be weaved with an AspectJ async execution aspect?
+
+	AspectJ weaving requires spring-aspects.jar on the classpath,
+	as well as load-time weaving (or compile-time weaving) enabled.
+
+	Note: The weaving-based aspect requires the @Async annotation to be
+	defined on the concrete class. Annotations in interfaces will not work
+	in that case (they will rather only work with interface-based proxies)!
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="proxy"/>
+						<xsd:enumeration value="aspectj"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="proxy-target-class" type="xsd:boolean" default="false">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Are class-based (CGLIB) proxies to be created? By default, standard
+	Java interface-based proxies are created.
+
+	Note: Class-based proxies require the @Async annotation to be defined
+	on the concrete class. Annotations in interfaces will not work in
+	that case (they will rather only work with interface-based proxies)!
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="scheduler">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Defines a ThreadPoolTaskScheduler instance with configurable pool size. See Javadoc
+	for the org.springframework.scheduling.annotation.EnableScheduling annotation for
+	information on a code-based alternative to this XML element.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:attribute name="id" type="xsd:string" use="required">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The bean name for the generated ThreadPoolTaskScheduler instance.
+	It will also be used as the default thread name prefix.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="pool-size" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The size of the ScheduledExecutorService's thread pool. The default is 1.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="executor">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Defines a ThreadPoolTaskExecutor instance with configurable pool size,
+	queue-capacity, keep-alive, and rejection-policy values.
+
+	See Javadoc for the org.springframework.scheduling.annotation.EnableAsync annotation
+	for information on code-based alternatives to this XML element.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:attribute name="id" type="xsd:string" use="required">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The bean name for the generated ThreadPoolTaskExecutor instance.
+	This value will also be used as the thread name prefix which is why it is
+	required even when defining the executor as an inner bean: The executor
+	won't be directly accessible then but will nevertheless use the specified
+	id as the thread name prefix of the threads that it manages.
+	In the case of multiple task:executors, as of Spring 3.1.2 this value may be used to
+	qualify which executor should handle a given @Async method, e.g. @Async("executorId").
+	See the Javadoc for the #value attribute of Spring's @Async annotation for details.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="pool-size" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The size of the executor's thread pool as either a single value or a range
+	(e.g. 5-10). If no bounded queue-capacity value is provided, then a max value
+	has no effect unless the range is specified as 0-n. In that case, the core pool
+	will have a size of n, but the 'allowCoreThreadTimeout' flag will be set to true.
+	If a queue-capacity is provided, then the lower bound of a range will map to the
+	core size and the upper bound will map to the max size. If this attribute is not
+	provided, the default core size will be 1, and the default max size will be
+	Integer.MAX_VALUE (i.e. unbounded).
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="queue-capacity" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Queue capacity for the ThreadPoolTaskExecutor. If not specified, the default will
+	be Integer.MAX_VALUE (i.e. unbounded).
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="keep-alive" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Keep-alive time in seconds. Inactive threads that have been created beyond the
+	core size will timeout after the specified number of seconds elapse. If the
+	executor has an unbounded queue capacity and a size range represented as 0-n,
+	then the core threads will also be configured to timeout when inactive.
+	Otherwise, core threads will not ever timeout.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="rejection-policy" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The RejectedExecutionHandler type. When a bounded queue cannot accept any
+	additional tasks, this determines the behavior. While the default is ABORT,
+	consider using CALLER_RUNS to throttle inbound tasks. In other words, by forcing
+	the caller to run the task itself, it will not be able to provide another task
+	until after it completes the task at hand. In the meantime, one or more tasks
+	may be removed from the queue. Alternatively, if it is not critical to run every
+	task, consider using DISCARD to drop the current task or DISCARD_OLDEST to drop
+	the task at the head of the queue.
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="ABORT"/>
+						<xsd:enumeration value="CALLER_RUNS"/>
+						<xsd:enumeration value="DISCARD"/>
+						<xsd:enumeration value="DISCARD_OLDEST"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="scheduled-tasks">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Top-level element that contains one or more task sub-elements to be
+	managed by a given TaskScheduler.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:sequence>
+				<xsd:element name="scheduled" type="scheduledTaskType" minOccurs="1" maxOccurs="unbounded"/>
+			</xsd:sequence>
+			<xsd:attribute name="scheduler" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Reference to an instance of TaskScheduler to manage the provided tasks. If not specified,
+	the default value will be a wrapper for a single-threaded Executor.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.scheduling.TaskScheduler"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:complexType name="scheduledTaskType">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Element defining a scheduled method-invoking task and its corresponding trigger.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:attribute name="cron" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	A cron-based trigger. See the org.springframework.scheduling.support.CronSequenceGenerator
+	JavaDoc for example patterns.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="fixed-delay" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	An interval-based trigger where the interval is measured from the completion time of the
+	previous task. The time unit value is measured in milliseconds.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="fixed-rate" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	An interval-based trigger where the interval is measured from the start time of the
+	previous task. The time unit value is measured in milliseconds.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="trigger" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	A reference to a bean that implements the Trigger interface.
+ 				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="initial-delay" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Number of milliseconds to delay before the first execution of a 'fixed-rate' or
+	'fixed-delay' task.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="ref" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Reference to an object that provides a method to be invoked.
+				]]></xsd:documentation>
+				<xsd:appinfo>
+					<tool:annotation kind="ref" />
+				</xsd:appinfo>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="method" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The name of the method to be invoked. The target method must expect no arguments.
+	It will typically have a void return type; if not, the returned value will be
+	ignored when called through the scheduler.
+				]]></xsd:documentation>
+				<xsd:appinfo>
+					<tool:annotation>
+						<tool:expected-method type-ref="@ref"/>
+					</tool:annotation>
+				</xsd:appinfo>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+</xsd:schema>

classes/production/spring-context/org/springframework/scripting/config/spring-lang.xsd

@@ -0,0 +1,240 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+
+<xsd:schema xmlns="http://www.springframework.org/schema/lang"
+			xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+			xmlns:beans="http://www.springframework.org/schema/beans"
+			targetNamespace="http://www.springframework.org/schema/lang"
+			elementFormDefault="qualified"
+			attributeFormDefault="unqualified">
+
+	<xsd:annotation>
+		<xsd:documentation><![CDATA[
+	Defines the elements used in the Spring Framework's dynamic language
+	support, which allows bean definitions that are backed by classes
+	written in a language other than Java.
+		]]></xsd:documentation>
+	</xsd:annotation>
+
+	<xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd"/>
+
+	<xsd:element name="defaults">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Default settings for any scripted beans registered within this context.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:attributeGroup ref="defaultableAttributes"/>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="groovy">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	A Spring bean backed by a Groovy class definition.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="customizableScriptType">
+					<xsd:attributeGroup ref="defaultableAttributes"/>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="bsh">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	A Spring bean backed by a BeanShell script.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="dynamicScriptType">
+					<xsd:attributeGroup ref="vanillaScriptAttributes"/>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="std">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	A Spring bean backed by a standard JSR-223 based script.
+	Supports JavaScript, Groovy, JRuby and other JSR-223 compliant engines.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="dynamicScriptType">
+					<xsd:attribute name="engine" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The name of the script engine (if not inferred from the file extension).
+				]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attributeGroup ref="vanillaScriptAttributes"/>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<!-- Script Types -->
+	<xsd:complexType name="simpleScriptType">
+		<xsd:complexContent>
+			<xsd:extension base="beans:identifiedType">
+				<xsd:sequence>
+					<xsd:element name="inline-script" minOccurs="0" maxOccurs="1">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The source code for the dynamic language-backed bean.
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="property" type="beans:propertyType" minOccurs="0" maxOccurs="unbounded">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	Dynamic language-backed bean definitions can have zero or more properties.
+	Property elements correspond to JavaBean setter methods exposed
+	by the bean classes. Spring supports primitives, references to other
+	beans in the same or related factories, lists, maps and properties.
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+				<xsd:attribute name="script-source" type="xsd:string">
+					<xsd:annotation>
+						<xsd:documentation source="java:org.springframework.core.io.Resource"><![CDATA[
+	The resource containing the script for the dynamic language-backed bean.
+
+	Examples might be '/WEB-INF/scripts/Anais.groovy', 'classpath:Nin.bsh', etc.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="name" type="xsd:string">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	The name of this scripted bean as an alias or replacement for the id.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="scope" type="xsd:string">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	The scope of this scripted bean: typically "singleton" (one shared instance,
+	which will be returned by all calls to getBean with the given id), or
+	"prototype" (independent instance resulting from each call to getBean).
+	Default is "singleton".
+
+	Singletons are most commonly used, and are ideal for multi-threaded
+	service objects. Further scopes, such as "request" or "session", might
+	be supported by extended bean factories (e.g. in a web environment).
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="autowire" default="default">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	The autowire mode for the scripted bean.
+	Analogous to the 'autowire' attribute on a standard bean definition.
+						]]></xsd:documentation>
+					</xsd:annotation>
+					<xsd:simpleType>
+						<xsd:restriction base="xsd:NMTOKEN">
+							<xsd:enumeration value="default"/>
+							<xsd:enumeration value="no"/>
+							<xsd:enumeration value="byName"/>
+							<xsd:enumeration value="byType"/>
+						</xsd:restriction>
+					</xsd:simpleType>
+				</xsd:attribute>
+				<xsd:attribute name="depends-on" type="xsd:string">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	The names of the beans that this bean depends on being initialized.
+	The bean factory will guarantee that these beans get initialized
+	before this bean.
+
+	Note that dependencies are normally expressed through bean properties.
+	This property should just be necessary for other kinds of dependencies
+	like statics (*ugh*) or database preparation on startup.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="init-method" type="xsd:string">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	The name of an initialization method defined on the scripted bean.
+	Analogous to the 'init-method' attribute on a standard bean definition.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="destroy-method" type="xsd:string">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	The name of a destruction method defined on the scripted bean.
+	Analogous to the 'destroy-method' attribute on a standard bean definition.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+
+	<xsd:complexType name="dynamicScriptType">
+		<xsd:complexContent>
+			<xsd:extension base="simpleScriptType">
+				<xsd:attribute name="script-interfaces">
+					<xsd:annotation>
+						<xsd:documentation source="java:java.lang.Class"><![CDATA[
+	The Java interfaces that the dynamic language-backed object is to expose; comma-delimited.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+
+	<xsd:complexType name="customizableScriptType">
+		<xsd:complexContent>
+			<xsd:extension base="simpleScriptType">
+				<xsd:attribute name="customizer-ref">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	Reference to a GroovyObjectCustomizer or similar customizer bean.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+
+	<xsd:attributeGroup name="vanillaScriptAttributes">
+		<xsd:attribute name="refresh-check-delay" type="xsd:long">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The delay (in milliseconds) between checks for updated sources when
+	using the refreshable beans feature.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:attributeGroup>
+
+	<xsd:attributeGroup name="defaultableAttributes">
+		<xsd:attribute name="proxy-target-class" type="xsd:boolean">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Flag to tell the bean factory that if this bean is proxied it should be done using the target class type, 
+	not its interfaces. A refreshable script is normally proxied, so often this is useful in conjunction with
+	refresh-check-delay. Defaults to false requiring no additional library dependencies, but hiding behavior
+	in the bean that is not defined in an interface.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attributeGroup ref="vanillaScriptAttributes"></xsd:attributeGroup>
+	</xsd:attributeGroup>
+
+</xsd:schema>

classes/production/spring-expression/org/springframework/expression/spel/generated/SpringExpressions.g

@@ -0,0 +1,268 @@
+grammar SpringExpressions;
+
+options {
+	language = Java;
+	output=AST;
+	k=2;
+}
+
+tokens {
+	INTEGER_LITERAL;
+	EXPRESSION;
+	QUALIFIED_IDENTIFIER;
+	PROPERTY_OR_FIELD;
+	INDEXER;
+	CONSTRUCTOR;
+	HOLDER;
+	NAMED_ARGUMENT;
+	FUNCTIONREF;
+	TYPEREF;
+	VARIABLEREF;
+	METHOD;
+	ADD;
+	SUBTRACT;
+	NUMBER;
+}
+
+// applies only to the parser: 
+@header {package org.springframework.expression.spel.generated;}
+
+// applies only to the lexer:
+@lexer::header {package org.springframework.expression.spel.generated;}
+
+@members {
+  // For collecting info whilst processing rules that can be used in messages
+  protected Stack<String> paraphrase = new Stack<String>();
+}
+  
+@rulecatch {
+        catch(RecognitionException e) {
+                reportError(e);
+                throw e;
+        }
+}
+
+expr: expression EOF!;
+      
+expression : 
+    logicalOrExpression
+    ( (ASSIGN^ logicalOrExpression) 
+	  | (DEFAULT^ logicalOrExpression) 
+	  | (QMARK^ expression COLON! expression))?;
+
+parenExpr : LPAREN! expression RPAREN!;
+	
+logicalOrExpression 
+: logicalAndExpression (OR^ logicalAndExpression)*;
+                        
+logicalAndExpression 
+: relationalExpression (AND^ relationalExpression)*;
+	
+relationalExpression : sumExpression (relationalOperator^ sumExpression)?;
+
+sumExpression
+	: productExpression ( (PLUS^ | MINUS^) productExpression)*;
+
+productExpression
+	: powerExpr ((STAR^ | DIV^| MOD^) powerExpr)* ;
+
+powerExpr  : unaryExpression (POWER^ unaryExpression)? ;
+
+unaryExpression 
+	:	(PLUS^ | MINUS^ | BANG^) unaryExpression	
+	|	primaryExpression ;
+	
+primaryExpression
+    : startNode (node)? -> ^(EXPRESSION startNode (node)?);
+
+startNode 
+    : 
+    parenExpr
+    | methodOrProperty 
+    | functionOrVar
+    | indexer
+    | literal
+    | type
+    | constructor
+    | projection 
+    | selection 
+    | firstSelection
+    | lastSelection
+    ;
+    
+node
+	: ((DOT dottedNode) | nonDottedNode)+;
+	
+nonDottedNode
+	:	indexer;
+
+dottedNode
+	:	
+	((methodOrProperty 
+	| functionOrVar
+    | projection 
+    | selection 
+    | firstSelection 
+    | lastSelection 
+    ))
+	;
+	
+functionOrVar 
+    : (POUND ID LPAREN) => function
+    | var
+    ;
+    
+function : POUND id=ID methodArgs -> ^(FUNCTIONREF[$id] methodArgs);
+    
+var : POUND id=ID -> ^(VARIABLEREF[$id]); 
+
+
+methodOrProperty
+	:	(ID LPAREN) => id=ID methodArgs -> ^(METHOD[$id] methodArgs)
+	|	property
+	;
+	
+// may have to preserve these commas to make it easier to offer suggestions in the right place
+// mod at 9th feb 19:13 - added the second 'COMMA?' to allow for code completion "foo(A,"
+// TODO need to preserve commas and then check for badly formed call later (optimizing tree walk) to disallow "foo(a,b,c,)"
+methodArgs :  LPAREN! (argument (COMMA! argument)* (COMMA!)?)? RPAREN!;
+
+// If we match ID then create a node called PROPERTY_OR_FIELD and copy the id info into it.
+// this means the propertyOrField.text is what id.text would have been, rather than having to
+// access id as a child of the new node.
+property: id=ID -> ^(PROPERTY_OR_FIELD[$id]);
+
+
+indexer: LBRACKET r1=argument (COMMA r2=argument)* RBRACKET -> ^(INDEXER $r1 ($r2)*);
+	
+// argument;
+	// TODO make expression conditional with ? if want completion for when the RCURLY is missing
+projection: PROJECT^ expression RBRACKET!;
+
+selection: SELECT^ expression RBRACKET!;
+
+firstSelection:	SELECT_FIRST^ expression RBRACKET!;
+
+lastSelection: SELECT_LAST^ expression RBRACKET!;
+
+// TODO cope with array types
+type:	TYPE qualifiedId RPAREN -> ^(TYPEREF qualifiedId);
+//type:   TYPE tn=qualifiedId (LBRACKET RBRACKET)? (COMMA qid=qualifiedId)? RPAREN
+
+
+constructor  
+	:	('new' qualifiedId LPAREN) => 'new' qualifiedId ctorArgs -> ^(CONSTRUCTOR qualifiedId ctorArgs)
+	;
+	
+ctorArgs
+	: LPAREN! (namedArgument (COMMA! namedArgument)*)? RPAREN!;
+
+argument : expression;
+
+namedArgument 
+    : (ID ASSIGN) => id=ID ASSIGN expression 
+                  -> ^(NAMED_ARGUMENT[$id] expression)
+    | argument ;
+  	
+qualifiedId : ID (DOT ID)* -> ^(QUALIFIED_IDENTIFIER ID*);
+
+contextName : ID (DIV ID)* -> ^(QUALIFIED_IDENTIFIER ID*);
+	
+literal
+	: INTEGER_LITERAL 
+	| STRING_LITERAL
+	| DQ_STRING_LITERAL
+	| boolLiteral
+	| NULL_LITERAL
+	| HEXADECIMAL_INTEGER_LITERAL 
+	| REAL_LITERAL
+	;
+	
+boolLiteral: TRUE | FALSE;
+
+INTEGER_LITERAL
+	: (DECIMAL_DIGIT)+ (INTEGER_TYPE_SUFFIX)?;
+
+HEXADECIMAL_INTEGER_LITERAL : ('0x' | '0X') (HEX_DIGIT)+ (INTEGER_TYPE_SUFFIX)?;
+
+relationalOperator
+    :   EQUAL 
+    |   NOT_EQUAL
+    |   LESS_THAN
+    |   LESS_THAN_OR_EQUAL      
+    |   GREATER_THAN            
+    |   GREATER_THAN_OR_EQUAL 
+    |   INSTANCEOF   
+    |   BETWEEN   
+    |   MATCHES
+    ; 
+          
+ASSIGN: '=';
+EQUAL: '==';
+NOT_EQUAL: '!=';
+LESS_THAN: '<';
+LESS_THAN_OR_EQUAL: '<=';
+GREATER_THAN: '>';
+GREATER_THAN_OR_EQUAL: '>=';
+INSTANCEOF:     'instanceof';
+BETWEEN:'between';
+MATCHES:'matches';
+NULL_LITERAL: 'null';
+
+SEMI: ';';
+DOT:    '.';
+COMMA:	',';
+LPAREN: '(';
+RPAREN: ')';
+LCURLY: '{';
+RCURLY: '}';
+LBRACKET: '[';
+RBRACKET: ']';
+PIPE:	'|';
+
+AND:    'and';
+OR:     'or';
+FALSE:  'false';
+TRUE:   'true';
+
+PLUS: '+';
+MINUS: '-';
+DIV: '/';
+STAR: '*';
+MOD: '%';
+POWER: '^';
+BANG: '!';
+POUND: '#';
+QMARK: '?';
+DEFAULT: '??';
+PROJECT: '![';
+SELECT: '?[';
+SELECT_FIRST: '^[';
+SELECT_LAST: '$[';
+TYPE: 'T(';
+
+STRING_LITERAL:	'\''! (APOS|~'\'')* '\''!;
+DQ_STRING_LITERAL:	'"'! (~'"')* '"'!;
+ID:	('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9'|DOT_ESCAPED)*;
+DOT_ESCAPED: '\\.';
+WS: ( ' ' | '\t' | '\n' |'\r')+ { $channel=HIDDEN; } ;
+DOLLAR:	'$';
+AT: '@';
+UPTO: '..';
+COLON: ':';
+
+
+REAL_LITERAL :	
+  ('.' (DECIMAL_DIGIT)+ (EXPONENT_PART)? (REAL_TYPE_SUFFIX)?) |
+	((DECIMAL_DIGIT)+ '.' (DECIMAL_DIGIT)+ (EXPONENT_PART)? (REAL_TYPE_SUFFIX)?) |
+	((DECIMAL_DIGIT)+ (EXPONENT_PART) (REAL_TYPE_SUFFIX)?) |
+	((DECIMAL_DIGIT)+ (REAL_TYPE_SUFFIX));
+
+fragment APOS : '\''! '\'';
+fragment DECIMAL_DIGIT : '0'..'9' ;
+fragment INTEGER_TYPE_SUFFIX : ( 'L' | 'l' );
+fragment HEX_DIGIT : '0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9'|'A'|'B'|'C'|'D'|'E'|'F'|'a'|'b'|'c'|'d'|'e'|'f';		
+	
+fragment EXPONENT_PART : 'e'  (SIGN)*  (DECIMAL_DIGIT)+ | 'E'  (SIGN)*  (DECIMAL_DIGIT)+ ;	
+fragment SIGN :	'+' | '-' ;
+fragment REAL_TYPE_SUFFIX : 'F' | 'f' | 'D' | 'd';

classes/production/spring-jdbc/META-INF/spring.handlers

@@ -0,0 +1 @@
+http\://www.springframework.org/schema/jdbc=org.springframework.jdbc.config.JdbcNamespaceHandler

classes/production/spring-jdbc/META-INF/spring.schemas

@@ -0,0 +1,8 @@
+http\://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd=org/springframework/jdbc/config/spring-jdbc.xsd
+http\://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd=org/springframework/jdbc/config/spring-jdbc.xsd
+http\://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd=org/springframework/jdbc/config/spring-jdbc.xsd
+http\://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd=org/springframework/jdbc/config/spring-jdbc.xsd
+http\://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd=org/springframework/jdbc/config/spring-jdbc.xsd
+http\://www.springframework.org/schema/jdbc/spring-jdbc-4.2.xsd=org/springframework/jdbc/config/spring-jdbc.xsd
+http\://www.springframework.org/schema/jdbc/spring-jdbc-4.3.xsd=org/springframework/jdbc/config/spring-jdbc.xsd
+http\://www.springframework.org/schema/jdbc/spring-jdbc.xsd=org/springframework/jdbc/config/spring-jdbc.xsd

classes/production/spring-jdbc/META-INF/spring.tooling

@@ -0,0 +1,4 @@
+# Tooling related information for the jdbc namespace
+http\://www.springframework.org/schema/jdbc@name=jdbc Namespace
+http\://www.springframework.org/schema/jdbc@prefix=jdbc
+http\://www.springframework.org/schema/jdbc@icon=org/springframework/jdbc/config/spring-jdbc.gif

classes/production/spring-jdbc/org/springframework/jdbc/config/spring-jdbc.xsd

@@ -0,0 +1,223 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+
+<xsd:schema xmlns="http://www.springframework.org/schema/jdbc"
+		xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+		xmlns:beans="http://www.springframework.org/schema/beans"
+		xmlns:tool="http://www.springframework.org/schema/tool"
+		targetNamespace="http://www.springframework.org/schema/jdbc"
+		elementFormDefault="qualified"
+		attributeFormDefault="unqualified">
+
+	<xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd"/>
+
+	<xsd:element name="embedded-database">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseFactoryBean"><![CDATA[
+	Creates an embedded database instance and makes it available to other beans as a javax.sql.DataSource.
+			]]></xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="javax.sql.DataSource"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="beans:identifiedType">
+					<xsd:sequence>
+						<xsd:element name="script" type="scriptType" minOccurs="0" maxOccurs="unbounded">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+			An SQL script to execute to populate, initialize, or clean up an embedded database.
+								]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:element>
+					</xsd:sequence>
+					<xsd:attribute name="database-name" type="xsd:string" default="">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+			The name to assign to the embedded database. Note that this is not the
+			bean name but rather the name of the embedded database as used in the JDBC
+			connection URL for the database. Defaults to "testdb" if an explicit bean
+			'id' has not been provided.
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="generate-name" type="xsd:string" use="optional" default="false">
+						<xsd:annotation>
+							<xsd:documentation>
+			If set to "true", a pseudo-random unique name will be generated for the embedded
+			database, overriding any implicit name provided via the 'id' attribute or any
+			explicit name provided via the 'database-name' attribute.
+			Note that this is not the bean name but rather the name of the embedded database
+			as used in the JDBC connection URL for the database.
+							</xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="separator" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The default statement separator to use (the default is to use ';' if it is present
+	in the script, or '\n' otherwise).
+				]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="type" type="databaseType" default="HSQL">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+			The type of embedded database to create, such as HSQL, H2 or Derby. Defaults to HSQL.
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="initialize-database">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.jdbc.datasource.init.DataSourceInitializer"><![CDATA[
+	Initializes a database instance with SQL scripts provided in nested <script/> elements.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:sequence>
+				<xsd:element name="script" type="scriptType" minOccurs="1" maxOccurs="unbounded">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+			An SQL script to execute to populate, initialize, or clean up a database.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+			</xsd:sequence>
+			<xsd:attribute name="data-source" type="xsd:string" default="dataSource">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+			A reference to a data source that should be initialized. Defaults to "dataSource".
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref"/>
+						<tool:expected-type type="javax.sql.DataSource"/>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="enabled" type="xsd:string" use="optional" default="true">
+				<xsd:annotation>
+					<xsd:documentation>
+			Is this bean "enabled", meaning the scripts will be executed?
+			Defaults to true but can be used to switch on and off script execution
+			depending on the environment.
+					</xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="ignore-failures" use="optional" default="NONE">
+				<xsd:annotation>
+					<xsd:documentation>
+						Should failed SQL statements be ignored during execution?
+					</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="NONE">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+						Do not ignore failures (the default)
+								]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="DROPS">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+						Ignore failed DROP statements
+								]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:enumeration>
+						<xsd:enumeration value="ALL">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+						Ignore all failures
+								]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:enumeration>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="separator" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The default statement separator to use (the default is to use ';' if it is present
+	in the script, or '\n' otherwise).
+				]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:complexType name="scriptType">
+		<xsd:attribute name="location" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The resource location of an SQL script to execute. Can be a single script location
+	or a pattern (e.g. classpath:/com/foo/sql/*-data.sql).
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="encoding" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The encoding for SQL scripts, if different from the platform encoding.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="separator" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The statement separator in the script (the default is to use ';' if it is present
+	in the script, or '\n' otherwise).
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="execution">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Indicate the execution phase of this script. Use INIT to execute on startup (as a
+	bean initialization) or DESTROY to execute on shutdown (as a bean destruction callback).
+				]]></xsd:documentation>
+			</xsd:annotation>
+			<xsd:simpleType>
+				<xsd:restriction base="xsd:string">
+					<xsd:enumeration value="INIT"/>
+					<xsd:enumeration value="DESTROY"/>
+				</xsd:restriction>
+			</xsd:simpleType>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:simpleType name="databaseType">
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="HSQL">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+			HyperSQL DataBase Engine
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="H2">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+			H2 Database Engine
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="DERBY">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+			Apache Derby Database Engine
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+
+</xsd:schema>

classes/production/spring-jdbc/org/springframework/jdbc/support/sql-error-codes.xml

@@ -0,0 +1,294 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
+
+<!--
+	- Default SQL error codes for well-known databases.
+	- Can be overridden by definitions in a "sql-error-codes.xml" file
+	- in the root of the class path.
+	-
+	- If the Database Product Name contains characters that are invalid
+	- to use in the id attribute (like a space) then we need to add a property
+	- named "databaseProductName"/"databaseProductNames" that holds this value.
+	- If this property is present, then it will be used instead of the id for
+	- looking up the error codes based on the current database.
+	-->
+<beans>
+
+	<bean id="DB2" class="org.springframework.jdbc.support.SQLErrorCodes">
+		<property name="databaseProductName">
+			<value>DB2*</value>
+		</property>
+		<property name="badSqlGrammarCodes">
+			<value>-007,-029,-097,-104,-109,-115,-128,-199,-204,-206,-301,-408,-441,-491</value>
+		</property>
+		<property name="duplicateKeyCodes">
+			<value>-803</value>
+		</property>
+		<property name="dataIntegrityViolationCodes">
+			<value>-407,-530,-531,-532,-543,-544,-545,-603,-667</value>
+		</property>
+		<property name="dataAccessResourceFailureCodes">
+			<value>-904,-971</value>
+		</property>
+		<property name="transientDataAccessResourceCodes">
+			<value>-1035,-1218,-30080,-30081</value>
+		</property>
+		<property name="deadlockLoserCodes">
+			<value>-911,-913</value>
+		</property>
+	</bean>
+
+	<bean id="Derby" class="org.springframework.jdbc.support.SQLErrorCodes">
+		<property name="databaseProductName">
+			<value>Apache Derby</value>
+		</property>
+		<property name="useSqlStateForTranslation">
+			<value>true</value>
+		</property>
+		<property name="badSqlGrammarCodes">
+			<value>42802,42821,42X01,42X02,42X03,42X04,42X05,42X06,42X07,42X08</value>
+		</property>
+		<property name="duplicateKeyCodes">
+			<value>23505</value>
+		</property>
+		<property name="dataIntegrityViolationCodes">
+			<value>22001,22005,23502,23503,23513,X0Y32</value>
+		</property>
+		<property name="dataAccessResourceFailureCodes">
+			<value>04501,08004,42Y07</value>
+		</property>
+		<property name="cannotAcquireLockCodes">
+			<value>40XL1</value>
+		</property>
+		<property name="deadlockLoserCodes">
+			<value>40001</value>
+		</property>
+	</bean>
+
+	<bean id="H2" class="org.springframework.jdbc.support.SQLErrorCodes">
+		<property name="badSqlGrammarCodes">
+			<value>42000,42001,42101,42102,42111,42112,42121,42122,42132</value>
+		</property>
+		<property name="duplicateKeyCodes">
+			<value>23001,23505</value>
+		</property>
+		<property name="dataIntegrityViolationCodes">
+			<value>22001,22003,22012,22018,22025,23000,23002,23003,23502,23503,23506,23507,23513</value>
+		</property>
+		<property name="dataAccessResourceFailureCodes">
+			<value>90046,90100,90117,90121,90126</value>
+		</property>
+		<property name="cannotAcquireLockCodes">
+			<value>50200</value>
+		</property>
+	</bean>
+
+	<bean id="HSQL" class="org.springframework.jdbc.support.SQLErrorCodes">
+		<property name="databaseProductName">
+			<value>HSQL Database Engine</value>
+		</property>
+		<property name="badSqlGrammarCodes">
+			<value>-22,-28</value>
+		</property>
+		<property name="duplicateKeyCodes">
+			<value>-104</value>
+		</property>
+		<property name="dataIntegrityViolationCodes">
+			<value>-9</value>
+		</property>
+		<property name="dataAccessResourceFailureCodes">
+			<value>-80</value>
+		</property>
+	</bean>
+
+	<bean id="Informix" class="org.springframework.jdbc.support.SQLErrorCodes">
+		<property name="databaseProductName">
+			<value>Informix Dynamic Server</value>
+		</property>
+		<property name="badSqlGrammarCodes">
+			<value>-201,-217,-696</value>
+		</property>
+		<property name="duplicateKeyCodes">
+			<value>-239,-268,-6017</value>
+		</property>
+		<property name="dataIntegrityViolationCodes">
+			<value>-692,-11030</value>
+		</property>
+	</bean>
+
+	<bean id="MS-SQL" class="org.springframework.jdbc.support.SQLErrorCodes">
+		<property name="databaseProductName">
+			<value>Microsoft SQL Server</value>
+		</property>
+		<property name="badSqlGrammarCodes">
+			<value>156,170,207,208,209</value>
+		</property>
+		<property name="permissionDeniedCodes">
+			<value>229</value>
+		</property>
+		<property name="duplicateKeyCodes">
+			<value>2601,2627</value>
+		</property>
+		<property name="dataIntegrityViolationCodes">
+			<value>544,8114,8115</value>
+		</property>
+		<property name="dataAccessResourceFailureCodes">
+			<value>4060</value>
+		</property>
+		<property name="cannotAcquireLockCodes">
+			<value>1222</value>
+		</property>
+		<property name="deadlockLoserCodes">
+			<value>1205</value>
+		</property>
+	</bean>
+
+	<bean id="MySQL" class="org.springframework.jdbc.support.SQLErrorCodes">
+		<property name="badSqlGrammarCodes">
+			<value>1054,1064,1146</value>
+		</property>
+		<property name="duplicateKeyCodes">
+			<value>1062</value>
+		</property>
+		<property name="dataIntegrityViolationCodes">
+			<value>630,839,840,893,1169,1215,1216,1217,1364,1451,1452,1557</value>
+		</property>
+		<property name="dataAccessResourceFailureCodes">
+			<value>1</value>
+		</property>
+		<property name="cannotAcquireLockCodes">
+			<value>1205</value>
+		</property>
+		<property name="deadlockLoserCodes">
+			<value>1213</value>
+		</property>
+	</bean>
+
+	<bean id="Oracle" class="org.springframework.jdbc.support.SQLErrorCodes">
+		<property name="badSqlGrammarCodes">
+			<value>900,903,904,917,936,942,17006,6550</value>
+		</property>
+		<property name="invalidResultSetAccessCodes">
+			<value>17003</value>
+		</property>
+		<property name="duplicateKeyCodes">
+			<value>1</value>
+		</property>
+		<property name="dataIntegrityViolationCodes">
+			<value>1400,1722,2291,2292</value>
+		</property>
+		<property name="dataAccessResourceFailureCodes">
+			<value>17002,17447</value>
+		</property>
+		<property name="cannotAcquireLockCodes">
+			<value>54,30006</value>
+		</property>
+		<property name="cannotSerializeTransactionCodes">
+			<value>8177</value>
+		</property>
+		<property name="deadlockLoserCodes">
+			<value>60</value>
+		</property>
+	</bean>
+
+	<bean id="PostgreSQL" class="org.springframework.jdbc.support.SQLErrorCodes">
+		<property name="useSqlStateForTranslation">
+			<value>true</value>
+		</property>
+		<property name="badSqlGrammarCodes">
+			<value>03000,42000,42601,42602,42622,42804,42P01</value>
+		</property>
+		<property name="duplicateKeyCodes">
+			<value>23505</value>
+		</property>
+		<property name="dataIntegrityViolationCodes">
+			<value>23000,23502,23503,23514</value>
+		</property>
+		<property name="dataAccessResourceFailureCodes">
+			<value>53000,53100,53200,53300</value>
+		</property>
+		<property name="cannotAcquireLockCodes">
+			<value>55P03</value>
+		</property>
+		<property name="cannotSerializeTransactionCodes">
+			<value>40001</value>
+		</property>
+		<property name="deadlockLoserCodes">
+			<value>40P01</value>
+		</property>
+	</bean>
+
+	<bean id="Sybase" class="org.springframework.jdbc.support.SQLErrorCodes">
+		<property name="databaseProductNames">
+			<list>
+				<value>Sybase SQL Server</value>
+				<value>SQL Server</value>
+				<value>Adaptive Server Enterprise</value>
+				<value>ASE</value> <!-- name as returned by jTDS driver -->
+				<value>sql server</value> <!-- name as returned by jTDS driver -->
+			</list>
+		</property>
+		<property name="badSqlGrammarCodes">
+			<value>101,102,103,104,105,106,107,108,109,110,111,112,113,116,120,121,123,207,208,213,257,512</value>
+		</property>
+		<property name="duplicateKeyCodes">
+			<value>2601,2615,2626</value>
+		</property>
+		<property name="dataIntegrityViolationCodes">
+			<value>233,511,515,530,546,547,2615,2714</value>
+		</property>
+		<property name="transientDataAccessResourceCodes">
+			<value>921,1105</value>
+		</property>
+		<property name="cannotAcquireLockCodes">
+			<value>12205</value>
+		</property>
+		<property name="deadlockLoserCodes">
+			<value>1205</value>
+		</property>
+	</bean>
+
+	<!-- http://help.sap.com/saphelp_hanaplatform/helpdata/en/20/a78d3275191014b41bae7c4a46d835/content.htm -->
+	<bean id="Hana" class="org.springframework.jdbc.support.SQLErrorCodes">
+		<property name="databaseProductNames">
+			<list>
+				<value>SAP DB</value>
+				<value>HDB</value>
+			</list>
+		</property>
+		<property name="badSqlGrammarCodes">
+			<value>
+				257,259,260,261,262,263,264,267,268,269,270,271,272,273,275,276,277,278,
+				278,279,280,281,282,283,284,285,286,288,289,290,294,295,296,297,299,308,309,
+				313,315,316,318,319,320,321,322,323,324,328,329,330,333,335,336,337,338,340,
+				343,350,351,352,362,368
+			</value>
+		</property>
+		<property name="permissionDeniedCodes">
+			<value>10,258</value>
+		</property>
+		<property name="duplicateKeyCodes">
+			<value>301</value>
+		</property>
+		<property name="dataIntegrityViolationCodes">
+			<value>461,462</value>
+		</property>
+		<property name="dataAccessResourceFailureCodes">
+			<value>-813,-709,-708,1024,1025,1026,1027,1029,1030,1031</value>
+		</property>
+		<property name="invalidResultSetAccessCodes">
+			<value>-11210,582,587,588,594</value>
+		</property>
+		<property name="cannotAcquireLockCodes">
+			<value>131</value>
+		</property>
+		<property name="cannotSerializeTransactionCodes">
+			<value>138,143</value>
+		</property>
+		<property name="deadlockLoserCodes">
+			<value>133</value>
+		</property>
+	</bean>
+
+
+</beans>

classes/production/spring-jms/META-INF/spring.handlers

@@ -0,0 +1 @@
+http\://www.springframework.org/schema/jms=org.springframework.jms.config.JmsNamespaceHandler

classes/production/spring-jms/META-INF/spring.schemas

@@ -0,0 +1,9 @@
+http\://www.springframework.org/schema/jms/spring-jms-2.5.xsd=org/springframework/jms/config/spring-jms.xsd
+http\://www.springframework.org/schema/jms/spring-jms-3.0.xsd=org/springframework/jms/config/spring-jms.xsd
+http\://www.springframework.org/schema/jms/spring-jms-3.1.xsd=org/springframework/jms/config/spring-jms.xsd
+http\://www.springframework.org/schema/jms/spring-jms-3.2.xsd=org/springframework/jms/config/spring-jms.xsd
+http\://www.springframework.org/schema/jms/spring-jms-4.0.xsd=org/springframework/jms/config/spring-jms.xsd
+http\://www.springframework.org/schema/jms/spring-jms-4.1.xsd=org/springframework/jms/config/spring-jms.xsd
+http\://www.springframework.org/schema/jms/spring-jms-4.2.xsd=org/springframework/jms/config/spring-jms.xsd
+http\://www.springframework.org/schema/jms/spring-jms-4.3.xsd=org/springframework/jms/config/spring-jms.xsd
+http\://www.springframework.org/schema/jms/spring-jms.xsd=org/springframework/jms/config/spring-jms.xsd

classes/production/spring-jms/META-INF/spring.tooling

@@ -0,0 +1,4 @@
+# Tooling related information for the jms namespace
+http\://www.springframework.org/schema/jms@name=jms Namespace
+http\://www.springframework.org/schema/jms@prefix=jms
+http\://www.springframework.org/schema/jms@icon=org/springframework/jms/config/spring-jms.gif

classes/production/spring-jms/org/springframework/jms/config/spring-jms.xsd

@@ -0,0 +1,638 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<xsd:schema xmlns="http://www.springframework.org/schema/jms"
+		xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+		xmlns:tool="http://www.springframework.org/schema/tool"
+		targetNamespace="http://www.springframework.org/schema/jms"
+		elementFormDefault="qualified"
+		attributeFormDefault="unqualified">
+
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd"/>
+
+	<xsd:annotation>
+		<xsd:documentation><![CDATA[
+	Defines the configuration elements for the Spring Framework's JMS support.
+	Allows for configuring JMS listener containers in XML 'shortcut' style as
+	well as through annotation.
+		]]></xsd:documentation>
+	</xsd:annotation>
+
+	<xsd:element name="annotation-driven">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Enables the detection of @JmsListener annotation on any Spring-managed object. If
+	present, a message listener container will be created to receive the relevant
+	messages and invoke the annotated method accordingly.
+
+	See Javadoc for the org.springframework.jms.annotation.EnableJms annotation for
+	information	on code-based alternatives to this XML element.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:attribute name="registry" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Specifies the org.springframework.jms.config.JmsListenerEndpointRegistry instance to
+	use to register annotated jms listener endpoints. If not provided, a default instance
+	will be used by default.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.jms.config.JmsListenerEndpointRegistry"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="container-factory" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Specifies the org.springframework.jms.config.JmsListenerContainerFactory instance to
+	use to create the container for a jms listener endpoint that does not define a specific
+	factory. This permits in practice to omit the "containerFactory" attribute of the JmsListener
+	annotation. This attribute is not required as each endpoint may define the factory to use and,
+	as a convenience, the JmsListenerContainerFactory with name 'jmsListenerContainerFactory' is
+	looked up by default.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.jms.config.JmsListenerContainerFactory"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="handler-method-factory" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Specifies a custom org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory
+	instance to	use to configure the message listener responsible to serve an endpoint detected by this
+	processor. By default, DefaultMessageHandlerMethodFactory is used and it can be configured
+	further to support additional method arguments or to customize conversion and validation
+	support. See org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory
+	Javadoc for more details.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+
+
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="listener-container">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Each listener child element will be hosted by a container whose configuration
+	is determined by this parent element. This variant builds standard JMS
+	listener containers, operating against a specified JMS ConnectionFactory. When
+	a factory-id attribute is present, the configuration defined by this element is
+	exposed as a org.springframework.jms.config.JmsListenerContainerFactory. It is
+	therefore possible to only define this element without any child to just expose
+	a container factory.
+			]]></xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="org.springframework.jms.listener.AbstractMessageListenerContainer"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:sequence>
+				<xsd:element name="listener" type="listenerType" minOccurs="0" maxOccurs="unbounded"/>
+			</xsd:sequence>
+			<xsd:attribute name="factory-id" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Expose the settings defined by this element as a org.springframework.jms.config.JmsListenerContainerFactory
+	so that they can be reused with other endpoints.
+				]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="container-type" default="default">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The type of this listener container: "default" or "simple", choosing
+	between DefaultMessageListenerContainer and SimpleMessageListenerContainer.
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="default"/>
+						<xsd:enumeration value="simple"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="container-class" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A custom listener container implementation class as fully qualified class name.
+	Default is Spring's standard DefaultMessageListenerContainer or
+	SimpleMessageListenerContainer, according to the "container-type" attribute.
+	Note that a custom container class will typically be a subclass of either of
+	those two Spring-provided standard container classes: Nake sure that the
+	"container-type" attribute matches the actual base type that the custom class
+	derives from ("default" will usually be fine anyway, since most custom classes
+	will derive from DefaultMessageListenerContainer).
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation>
+							<tool:expected-type type="java.lang.Class"/>
+							<tool:assignable-to type="org.springframework.jms.listener.AbstractMessageListenerContainer"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="connection-factory" type="xsd:string" default="connectionFactory">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A reference to the JMS ConnectionFactory bean.
+	Default is "connectionFactory".
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="javax.jms.ConnectionFactory"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="task-executor" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A reference to a Spring TaskExecutor (or standard JDK 1.5 Executor) for executing
+	JMS listener invokers. Default is a SimpleAsyncTaskExecutor in case of a
+	DefaultMessageListenerContainer, using internally managed threads. For a
+	SimpleMessageListenerContainer, listeners will always get invoked within the
+	JMS provider's receive thread by default.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="java.util.concurrent.Executor"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="destination-resolver" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A reference to the DestinationResolver strategy for resolving destination names.
+	Default is a DynamicDestinationResolver, using the JMS provider's queue/topic
+	name resolution. Alternatively, specify a reference to a JndiDestinationResolver
+	(typically in a Java EE environment).
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.jms.support.destination.DestinationResolver"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="message-converter" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A reference to the MessageConverter strategy for converting JMS Messages to
+	listener method arguments. Default is a SimpleMessageConverter.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.jms.support.converter.MessageConverter"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="error-handler" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A reference to an ErrorHandler strategy for handling any uncaught Exceptions
+	that may occur during the execution of the MessageListener.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.util.ErrorHandler"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="destination-type" default="queue">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The JMS destination type for this listener: "queue", "topic", "durableTopic",
+	"sharedTopic", "sharedDurableTopic". This enables potentially the "pubSubDomain",
+	"subscriptionDurable" and "subscriptionShared" properties of the container. The
+	default is "queue" (i.e. disabling those 3 properties).
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="queue"/>
+						<xsd:enumeration value="topic"/>
+						<xsd:enumeration value="durableTopic"/>
+						<xsd:enumeration value="sharedTopic"/>
+						<xsd:enumeration value="sharedDurableTopic"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="response-destination-type" default="queue">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The JMS destination type for responses: "queue", "topic". Default
+	is the value of the "destination-type" attribute.
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="queue"/>
+						<xsd:enumeration value="topic"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="client-id" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The JMS client id for this listener container.
+	Needs to be specified when using subscriptions.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="cache" default="auto">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The cache level for JMS resources: "none", "connection", "session", "consumer"
+	or "auto". By default ("auto"), the cache level will effectively be "consumer",
+	unless an external transaction manager has been specified - in which case the
+	effective default will be "none" (assuming Java EE-style transaction management
+	where the given ConnectionFactory is an XA-aware pool).
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="none"/>
+						<xsd:enumeration value="connection"/>
+						<xsd:enumeration value="session"/>
+						<xsd:enumeration value="consumer"/>
+						<xsd:enumeration value="auto"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="acknowledge" default="auto">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The native JMS acknowledge mode: "auto", "client", "dups-ok" or "transacted".
+	A value of "transacted" effectively activates a locally transacted Session;
+	as alternative, specify an external "transaction-manager" via the corresponding
+	attribute. Default is "auto".
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="auto"/>
+						<xsd:enumeration value="client"/>
+						<xsd:enumeration value="dups-ok"/>
+						<xsd:enumeration value="transacted"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="transaction-manager" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A reference to an external PlatformTransactionManager (typically an
+	XA-based transaction coordinator, e.g. Spring's JtaTransactionManager).
+	If not specified, native acknowledging will be used (see "acknowledge" attribute).
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.transaction.PlatformTransactionManager"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="concurrency" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The number of concurrent sessions/consumers to start for each listener.
+	Can either be a simple number indicating the maximum number (e.g. "5")
+	or a range indicating the lower as well as the upper limit (e.g. "3-5").
+	Note that a specified minimum is just a hint and might be ignored at runtime.
+	Default is 1; keep concurrency limited to 1 in case of a topic listener
+	or if message ordering is important; consider raising it for general queues.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="prefetch" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The maximum number of messages to load into a single session.
+	Note that raising this number might lead to starvation of concurrent consumers!
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="receive-timeout" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The timeout to use for receive calls (in milliseconds).
+	The default is 1000 ms (1 sec); -1 indicates no timeout at all.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="back-off" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	 Specify the BackOff instance to use to compute the interval between recovery
+	 attempts. If the BackOff implementation returns "BackOffExecution#STOP", the listener
+	 container will not further attempt to recover. The recovery-interval value is
+	 ignored when this property is set. The default is a FixedBackOff with an
+	 interval of 5000 ms, that is 5 seconds.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.util.backoff.BackOff"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="recovery-interval" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Specify the interval between recovery attempts, in milliseconds. Convenience
+	way to create a FixedBackOff with the specified interval. For more recovery
+	options, consider specifying a BackOff instance instead. The default is
+	5000 ms, that is 5 seconds.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="phase" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The lifecycle phase within which this container should start and stop. The lower
+	the value the earlier this container will start and the later it will stop. The
+	default is Integer.MAX_VALUE meaning the container will start as late as possible
+	and stop as soon as possible.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="jca-listener-container">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Each listener child element will be hosted by a container whose configuration
+	is determined by this parent element. This variant builds standard JCA-based
+	listener containers, operating against a specified JCA ResourceAdapter
+	(which needs to be provided by the JMS message broker, e.g. ActiveMQ). When
+	a factory-id attribute is present, the configuration defined by this element is
+	exposed as a org.springframework.jms.config.JmsListenerContainerFactory. It is
+	therefore possible to only define this element without any child to just expose
+	a container factory.
+			]]></xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="org.springframework.jms.listener.endpoint.JmsMessageEndpointManager"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:sequence>
+				<xsd:element name="listener" type="listenerType" minOccurs="0" maxOccurs="unbounded"/>
+			</xsd:sequence>
+			<xsd:attribute name="factory-id" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Expose the settings defined by this element as a org.springframework.jms.config.JmsListenerContainerFactory
+	so that they can be reused with other endpoints.
+				]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="resource-adapter" type="xsd:string" default="resourceAdapter">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A reference to the JCA ResourceAdapter bean for the JMS provider.
+	Default is "resourceAdapter".
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="javax.resource.spi.ResourceAdapter"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="activation-spec-factory" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A reference to the JmsActivationSpecFactory.
+	Default is to autodetect the JMS provider and its ActivationSpec class
+	(see DefaultJmsActivationSpecFactory).
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.jms.listener.endpoint.JmsActivationSpecFactory"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="destination-resolver" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A reference to the DestinationResolver strategy for resolving destination names.
+	Default is to pass in the destination name Strings into the JCA ActivationSpec as-is.
+	Alternatively, specify a reference to a JndiDestinationResolver (typically in a Java EE
+	environment, in particular if the server insists on receiving Destination objects).
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.jms.support.destination.DestinationResolver"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="message-converter" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A reference to the MessageConverter strategy for converting JMS Messages to
+	listener method arguments. Default is a SimpleMessageConverter.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.jms.support.converter.MessageConverter"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="destination-type" default="queue">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The JMS destination type for this listener: "queue", "topic" or "durableTopic".
+	Default is "queue".
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="queue"/>
+						<xsd:enumeration value="topic"/>
+						<xsd:enumeration value="durableTopic"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="response-destination-type" default="queue">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The JMS destination type for responses: "queue", "topic". Default
+	is the value of the "destination-type" attribute.
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="queue"/>
+						<xsd:enumeration value="topic"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="client-id" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The JMS client id for this listener container.
+	Needs to be specified when using durable subscriptions.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="acknowledge" default="auto">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The native JMS acknowledge mode: "auto", "client", "dups-ok" or "transacted".
+	A value of "transacted" effectively activates a locally transacted Session;
+	as alternative, specify an external "transaction-manager" via the corresponding
+	attribute. Default is "auto".
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="auto"/>
+						<xsd:enumeration value="client"/>
+						<xsd:enumeration value="dups-ok"/>
+						<xsd:enumeration value="transacted"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="transaction-manager" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A reference to the Spring JtaTransactionManager or [javax.transaction.TransactionManager],
+	for kicking off an XA transaction for each incoming message.
+	If not specified, native acknowledging will be used (see "acknowledge" attribute).
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref"/>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="concurrency" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The number of concurrent sessions/consumers to start for each listener.
+	Can either be a simple number indicating the maximum number (e.g. "5")
+	or a range indicating the lower as well as the upper limit (e.g. "3-5").
+	Note that a specified minimum is just a hint and will typically be ignored
+	at runtime when using a JCA listener container. Default is 1.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="prefetch" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The maximum number of messages to load into a single session.
+	Note that raising this number might lead to starvation of concurrent consumers!
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="phase" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The lifecycle phase within which this container should start and stop. The lower
+	the value the earlier this container will start and the later it will stop. The
+	default is Integer.MAX_VALUE meaning the container will start as late as possible
+	and stop as soon as possible.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:complexType name="listenerType">
+		<xsd:attribute name="id" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The unique identifier for a listener.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="destination" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The destination name for this listener, resolved through the
+	container-wide DestinationResolver strategy (if any). Required.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="subscription" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The name for the durable subscription, if any.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="selector" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The JMS message selector for this listener.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="ref" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The bean name of the listener object, implementing
+	the MessageListener/SessionAwareMessageListener interface
+	or defining the specified listener method. Required.
+				]]></xsd:documentation>
+				<xsd:appinfo>
+					<tool:annotation kind="ref"/>
+				</xsd:appinfo>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="method" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The name of the listener method to invoke. If not specified,
+	the target bean is supposed to implement the MessageListener
+	or SessionAwareMessageListener interface.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="response-destination" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The name of the default response destination to send response messages to.
+	This will be applied in case of a request message that does not carry
+	a "JMSReplyTo" field. The type of this destination will be determined
+	by the listener-container's "response-destination-type" attribute.
+	Note: This only applies to a listener method with a return value,
+	for which each result object will be converted into a response message.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="concurrency" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The number of concurrent sessions/consumers to start for this listener.
+	Can either be a simple number indicating the maximum number (e.g. "5")
+	or a range indicating the lower as well as the upper limit (e.g. "3-5").
+	Note that a specified minimum is just a hint and might be ignored at runtime.
+	Default is the value provided by the container.
+					]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+</xsd:schema>

classes/production/spring-oxm/META-INF/spring.handlers

@@ -0,0 +1 @@
+http\://www.springframework.org/schema/oxm=org.springframework.oxm.config.OxmNamespaceHandler

classes/production/spring-oxm/META-INF/spring.schemas

@@ -0,0 +1,8 @@
+http\://www.springframework.org/schema/oxm/spring-oxm-3.0.xsd=org/springframework/oxm/config/spring-oxm.xsd
+http\://www.springframework.org/schema/oxm/spring-oxm-3.1.xsd=org/springframework/oxm/config/spring-oxm.xsd
+http\://www.springframework.org/schema/oxm/spring-oxm-3.2.xsd=org/springframework/oxm/config/spring-oxm.xsd
+http\://www.springframework.org/schema/oxm/spring-oxm-4.0.xsd=org/springframework/oxm/config/spring-oxm.xsd
+http\://www.springframework.org/schema/oxm/spring-oxm-4.1.xsd=org/springframework/oxm/config/spring-oxm.xsd
+http\://www.springframework.org/schema/oxm/spring-oxm-4.2.xsd=org/springframework/oxm/config/spring-oxm.xsd
+http\://www.springframework.org/schema/oxm/spring-oxm-4.3.xsd=org/springframework/oxm/config/spring-oxm.xsd
+http\://www.springframework.org/schema/oxm/spring-oxm.xsd=org/springframework/oxm/config/spring-oxm.xsd

classes/production/spring-oxm/META-INF/spring.tooling

@@ -0,0 +1,4 @@
+# Tooling related information for the oxm namespace
+http\://www.springframework.org/schema/oxm@name=oxm Namespace
+http\://www.springframework.org/schema/oxm@prefix=oxm
+http\://www.springframework.org/schema/oxm@icon=org/springframework/oxm/config/spring-oxm.gif

classes/production/spring-oxm/org/springframework/oxm/config/spring-oxm.xsd

@@ -0,0 +1,136 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<xsd:schema xmlns="http://www.springframework.org/schema/oxm" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+		xmlns:beans="http://www.springframework.org/schema/beans"
+		xmlns:tool="http://www.springframework.org/schema/tool"
+		targetNamespace="http://www.springframework.org/schema/oxm"
+		elementFormDefault="qualified"
+		attributeFormDefault="unqualified">
+
+	<xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd"/>
+
+	<xsd:annotation>
+		<xsd:documentation>
+			Defines the elements used in Spring's Object/XML Mapping integration.
+		</xsd:documentation>
+	</xsd:annotation>
+
+	<xsd:element name="jaxb2-marshaller">
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.oxm.jaxb.Jaxb2Marshaller">
+					Defines a JAXB2 Marshaller.
+				</xsd:documentation>
+				<xsd:appinfo>
+					<tool:annotation>
+						<tool:exports type="org.springframework.oxm.jaxb.Jaxb2Marshaller"/>
+					</tool:annotation>
+				</xsd:appinfo>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="beans:identifiedType">
+					<xsd:sequence>
+						<xsd:element name="class-to-be-bound" minOccurs="0" maxOccurs="unbounded">
+							<xsd:complexType>
+								<xsd:attribute name="name" type="classType" use="required"/>
+							</xsd:complexType>
+						</xsd:element>
+					</xsd:sequence>
+					<xsd:attribute name="context-path" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation>The JAXB context path.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="jibx-marshaller">
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.oxm.jibx.JibxMarshaller">
+					Defines a JiBX Marshaller.
+				</xsd:documentation>
+				<xsd:appinfo>
+					<tool:annotation>
+						<tool:exports type="org.springframework.oxm.jibx.JibxMarshaller"/>
+					</tool:annotation>
+				</xsd:appinfo>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="beans:identifiedType">
+					<xsd:attribute name="target-class" type="classType">
+						<xsd:annotation>
+							<xsd:documentation>The target class to be bound with JiBX.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="target-package" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation>The target package for the JiBX binding.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="binding-name" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation>The binding name used by this marshaller.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="castor-marshaller">
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation
+					source="java:org.springframework.oxm.castor.CastorMarshaller">
+					Defines a Castor Marshaller.
+				</xsd:documentation>
+				<xsd:appinfo>
+					<tool:annotation>
+						<tool:exports type="org.springframework.oxm.castor.CastorMarshaller" />
+					</tool:annotation>
+				</xsd:appinfo>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="beans:identifiedType">
+					<xsd:attribute name="encoding" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation>The encoding to use for stream reading.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="target-class" type="classType">
+						<xsd:annotation>
+							<xsd:documentation>The target class to be bound with the Castor marshaller.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="target-package" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation>The target package that contains Castor descriptor classes.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="mapping-location" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation>The path to the Castor mapping file.</xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:simpleType name="classType">
+		<xsd:annotation>
+			<xsd:documentation source="java:java.lang.Class">A class supported by a marshaller.</xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation kind="direct">
+					<tool:expected-type type="java.lang.Class"/>
+					<tool:assignable-to restriction="class-only"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:union memberTypes="xsd:string"/>
+	</xsd:simpleType>
+
+</xsd:schema>

classes/production/spring-test/META-INF/spring.factories

@@ -0,0 +1,14 @@
+# Default TestExecutionListeners for the Spring TestContext Framework
+#
+org.springframework.test.context.TestExecutionListener = \
+	org.springframework.test.context.web.ServletTestExecutionListener,\
+	org.springframework.test.context.support.DirtiesContextBeforeModesTestExecutionListener,\
+	org.springframework.test.context.support.DependencyInjectionTestExecutionListener,\
+	org.springframework.test.context.support.DirtiesContextTestExecutionListener,\
+	org.springframework.test.context.transaction.TransactionalTestExecutionListener,\
+	org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener
+
+# Default ContextCustomizerFactory implementations for the Spring TestContext Framework
+#
+org.springframework.test.context.ContextCustomizerFactory = \
+	org.springframework.test.context.web.socket.MockServerContainerContextCustomizerFactory

classes/production/spring-tx/META-INF/spring.handlers

@@ -0,0 +1 @@
+http\://www.springframework.org/schema/tx=org.springframework.transaction.config.TxNamespaceHandler

classes/production/spring-tx/META-INF/spring.schemas

@@ -0,0 +1,10 @@
+http\://www.springframework.org/schema/tx/spring-tx-2.0.xsd=org/springframework/transaction/config/spring-tx.xsd
+http\://www.springframework.org/schema/tx/spring-tx-2.5.xsd=org/springframework/transaction/config/spring-tx.xsd
+http\://www.springframework.org/schema/tx/spring-tx-3.0.xsd=org/springframework/transaction/config/spring-tx.xsd
+http\://www.springframework.org/schema/tx/spring-tx-3.1.xsd=org/springframework/transaction/config/spring-tx.xsd
+http\://www.springframework.org/schema/tx/spring-tx-3.2.xsd=org/springframework/transaction/config/spring-tx.xsd
+http\://www.springframework.org/schema/tx/spring-tx-4.0.xsd=org/springframework/transaction/config/spring-tx.xsd
+http\://www.springframework.org/schema/tx/spring-tx-4.1.xsd=org/springframework/transaction/config/spring-tx.xsd
+http\://www.springframework.org/schema/tx/spring-tx-4.2.xsd=org/springframework/transaction/config/spring-tx.xsd
+http\://www.springframework.org/schema/tx/spring-tx-4.3.xsd=org/springframework/transaction/config/spring-tx.xsd
+http\://www.springframework.org/schema/tx/spring-tx.xsd=org/springframework/transaction/config/spring-tx.xsd

classes/production/spring-tx/META-INF/spring.tooling

@@ -0,0 +1,4 @@
+# Tooling related information for the tx namespace
+http\://www.springframework.org/schema/tx@name=tx Namespace
+http\://www.springframework.org/schema/tx@prefix=tx
+http\://www.springframework.org/schema/tx@icon=org/springframework/transaction/config/spring-tx.gif

classes/production/spring-tx/org/springframework/jca/context/ra.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<connector xmlns="http://java.sun.com/xml/ns/j2ee"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/connector_1_5.xsd"
+		version="1.5">
+	<vendor-name>Spring Framework</vendor-name>
+	<eis-type>Spring Connector</eis-type>
+	<resourceadapter-version>1.0</resourceadapter-version>
+	<resourceadapter>
+		<resourceadapter-class>org.springframework.jca.context.SpringContextResourceAdapter</resourceadapter-class>
+		<config-property>
+			<config-property-name>ContextConfigLocation</config-property-name>
+			<config-property-type>java.lang.String</config-property-type>
+			<config-property-value>META-INF/applicationContext.xml</config-property-value>
+		</config-property>
+	</resourceadapter>
+</connector>

classes/production/spring-tx/org/springframework/transaction/config/spring-tx.xsd

@@ -0,0 +1,247 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+
+<xsd:schema xmlns="http://www.springframework.org/schema/tx"
+		xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+		xmlns:beans="http://www.springframework.org/schema/beans"
+		xmlns:tool="http://www.springframework.org/schema/tool"
+		targetNamespace="http://www.springframework.org/schema/tx"
+		elementFormDefault="qualified"
+		attributeFormDefault="unqualified">
+
+	<xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd"/>
+
+	<xsd:annotation>
+		<xsd:documentation><![CDATA[
+	Defines the elements used in the Spring Framework's declarative
+	transaction management infrastructure.
+		]]></xsd:documentation>
+	</xsd:annotation>
+
+	<xsd:element name="advice">
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.transaction.interceptor.TransactionInterceptor"><![CDATA[
+	Defines the transactional semantics of the AOP advice that is to be
+	executed.
+
+	That is, this advice element is where the transactional semantics of
+	any	number of methods are defined (where transactional semantics
+	includes the propagation settings, the isolation level, the rollback
+	rules, and suchlike).
+				]]></xsd:documentation>
+				<xsd:appinfo>
+					<tool:annotation>
+						<tool:exports type="org.springframework.transaction.interceptor.TransactionInterceptor"/>
+					</tool:annotation>
+				</xsd:appinfo>
+			</xsd:annotation>
+			<xsd:complexContent>
+				<xsd:extension base="beans:identifiedType">
+					<xsd:sequence>
+						<xsd:element name="attributes" type="attributesType" minOccurs="0" maxOccurs="1"/>
+					</xsd:sequence>
+					<xsd:attribute name="transaction-manager" type="xsd:string" default="transactionManager">
+						<xsd:annotation>
+							<xsd:documentation source="java:org.springframework.transaction.PlatformTransactionManager"><![CDATA[
+	The bean name of the PlatformTransactionManager that is to be used
+	to drive transactions.
+
+	This attribute is not required, and only needs to be specified
+	explicitly if the bean name of the desired PlatformTransactionManager
+	is not 'transactionManager'.
+							]]></xsd:documentation>
+							<xsd:appinfo>
+								<tool:annotation kind="ref">
+									<tool:expected-type type="org.springframework.transaction.PlatformTransactionManager"/>
+								</tool:annotation>
+							</xsd:appinfo>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="annotation-driven">
+		<xsd:complexType>
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.transaction.annotation.AnnotationTransactionAttributeSource"><![CDATA[
+	Indicates that transaction configuration is defined by Java 5
+	annotations on bean classes, and that proxies are automatically
+	to be created for the relevant annotated beans.
+
+	The default annotations supported are Spring's @Transactional
+	and EJB3's @TransactionAttribute (if available).
+
+	Transaction semantics such as propagation settings, the isolation level,
+	the rollback rules, etc are all defined in the annotation metadata.
+
+	See org.springframework.transaction.annotation.EnableTransactionManagement Javadoc
+	for information on code-based alternatives to this XML element.
+				]]></xsd:documentation>
+			</xsd:annotation>
+			<xsd:attribute name="transaction-manager" type="xsd:string" default="transactionManager">
+				<xsd:annotation>
+					<xsd:documentation source="java:org.springframework.transaction.PlatformTransactionManager"><![CDATA[
+	The bean name of the PlatformTransactionManager that is to be used
+	to drive transactions.
+
+	This attribute is not required, and only needs to be specified
+	explicitly if the bean name of the desired PlatformTransactionManager
+	is not 'transactionManager'.
+					]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="org.springframework.transaction.PlatformTransactionManager"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="mode" default="proxy">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Should annotated beans be proxied using Spring's AOP framework,
+	or should they rather be weaved with an AspectJ transaction aspect?
+
+	AspectJ weaving requires spring-aspects.jar on the classpath,
+	as well as load-time weaving (or compile-time weaving) enabled.
+
+	Note: The weaving-based aspect requires the @Transactional annotation to be
+	defined on the concrete class. Annotations in interfaces will not work
+	in that case (they will rather only work with interface-based proxies)!
+					]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="proxy"/>
+						<xsd:enumeration value="aspectj"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="proxy-target-class" type="xsd:boolean" default="false">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Are class-based (CGLIB) proxies to be created? By default, standard
+	Java interface-based proxies are created.
+
+	Note: Class-based proxies require the @Transactional annotation to be
+	defined on the concrete class. Annotations in interfaces will not work
+	in that case (they will rather only work with interface-based proxies)!
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="order" type="xsd:token">
+				<xsd:annotation>
+					<xsd:documentation source="java:org.springframework.core.Ordered"><![CDATA[
+	Controls the ordering of the execution of the transaction advisor
+	when multiple advice executes at a specific joinpoint.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="jta-transaction-manager">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Creates a default JtaTransactionManager bean with name "transactionManager",
+	matching the default bean name expected by the "annotation-driven" tag.
+	Automatically detects WebLogic and WebSphere: creating a WebLogicJtaTransactionManager
+	or WebSphereUowTransactionManager, respectively.
+
+	For customization needs, consider defining a JtaTransactionManager bean as a regular
+	Spring bean definition with name "transactionManager", replacing this element.
+			]]></xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="org.springframework.transaction.jta.JtaTransactionManager"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+	</xsd:element>
+
+	<xsd:complexType name="attributesType">
+		<xsd:sequence>
+			<xsd:element name="method" minOccurs="1" maxOccurs="unbounded">
+				<xsd:complexType>
+					<xsd:attribute name="name" type="xsd:string" use="required">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The method name(s) with which the transaction attributes are to be
+	associated. The wildcard (*) character can be used to associate the
+	same transaction attribute settings with a number of methods; for
+	example, 'get*', 'handle*', '*Order', 'on*Event', etc.
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="propagation" default="REQUIRED">
+						<xsd:annotation>
+							<xsd:documentation source="java:org.springframework.transaction.annotation.Propagation"><![CDATA[
+	The transaction propagation behavior.
+							]]></xsd:documentation>
+						</xsd:annotation>
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:enumeration value="REQUIRED"/>
+								<xsd:enumeration value="SUPPORTS"/>
+								<xsd:enumeration value="MANDATORY"/>
+								<xsd:enumeration value="REQUIRES_NEW"/>
+								<xsd:enumeration value="NOT_SUPPORTED"/>
+								<xsd:enumeration value="NEVER"/>
+								<xsd:enumeration value="NESTED"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:attribute>
+					<xsd:attribute name="isolation" default="DEFAULT">
+						<xsd:annotation>
+							<xsd:documentation source="java:org.springframework.transaction.annotation.Isolation"><![CDATA[
+	The transaction isolation level.
+							]]></xsd:documentation>
+						</xsd:annotation>
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:enumeration value="DEFAULT"/>
+								<xsd:enumeration value="READ_UNCOMMITTED"/>
+								<xsd:enumeration value="READ_COMMITTED"/>
+								<xsd:enumeration value="REPEATABLE_READ"/>
+								<xsd:enumeration value="SERIALIZABLE"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:attribute>
+					<xsd:attribute name="timeout" type="xsd:int" default="-1">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The transaction timeout value (in seconds).
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="read-only" type="xsd:boolean" default="false">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	Is this transaction read-only?
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="rollback-for" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The Exception(s) that will trigger rollback; comma-delimited.
+	For example, 'com.foo.MyBusinessException,ServletException'
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="no-rollback-for" type="xsd:string">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The Exception(s) that will *not* trigger rollback; comma-delimited.
+	For example, 'com.foo.MyBusinessException,ServletException'
+							]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:complexType>
+			</xsd:element>
+		</xsd:sequence>
+	</xsd:complexType>
+
+</xsd:schema>

classes/production/spring-web/META-INF/services/javax.servlet.ServletContainerInitializer

@@ -0,0 +1 @@
+org.springframework.web.SpringServletContainerInitializer

classes/production/spring-web/META-INF/web-fragment.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<web-fragment xmlns="http://java.sun.com/xml/ns/javaee"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-fragment_3_0.xsd"
+	version="3.0" metadata-complete="true">
+
+	<name>spring_web</name>
+	<distributable/>
+
+</web-fragment>

classes/production/spring-web/org/springframework/web/context/ContextLoader.properties

@@ -0,0 +1,5 @@
+# Default WebApplicationContext implementation class for ContextLoader.
+# Used as fallback when no explicit context implementation has been specified as context-param.
+# Not meant to be customized by application developers.
+
+org.springframework.web.context.WebApplicationContext=org.springframework.web.context.support.XmlWebApplicationContext

classes/production/spring-web/org/springframework/web/util/HtmlCharacterEntityReferences.properties

@@ -0,0 +1,265 @@
+# Character Entity References defined by the HTML 4.0 standard.
+# A complete description of the HTML 4.0 character set can be found at:
+# http://www.w3.org/TR/html4/charset.html
+
+# Character entity references for ISO 8859-1 characters
+
+160 = nbsp
+161 = iexcl
+162 = cent
+163 = pound
+164 = curren
+165 = yen
+166 = brvbar
+167 = sect
+168 = uml
+169 = copy
+170 = ordf
+171 = laquo
+172 = not
+173 = shy
+174 = reg
+175 = macr
+176 = deg
+177 = plusmn
+178 = sup2
+179 = sup3
+180 = acute
+181 = micro
+182 = para
+183 = middot
+184 = cedil
+185 = sup1
+186 = ordm
+187 = raquo
+188 = frac14
+189 = frac12
+190 = frac34
+191 = iquest
+192 = Agrave
+193 = Aacute
+194 = Acirc
+195 = Atilde
+196 = Auml
+197 = Aring
+198 = AElig
+199 = Ccedil
+200 = Egrave
+201 = Eacute
+202 = Ecirc
+203 = Euml
+204 = Igrave
+205 = Iacute
+206 = Icirc
+207 = Iuml
+208 = ETH
+209 = Ntilde
+210 = Ograve
+211 = Oacute
+212 = Ocirc
+213 = Otilde
+214 = Ouml
+215 = times
+216 = Oslash
+217 = Ugrave
+218 = Uacute
+219 = Ucirc
+220 = Uuml
+221 = Yacute
+222 = THORN
+223 = szlig
+224 = agrave
+225 = aacute
+226 = acirc
+227 = atilde
+228 = auml
+229 = aring
+230 = aelig
+231 = ccedil
+232 = egrave
+233 = eacute
+234 = ecirc
+235 = euml
+236 = igrave
+237 = iacute
+238 = icirc
+239 = iuml
+240 = eth
+241 = ntilde
+242 = ograve
+243 = oacute
+244 = ocirc
+245 = otilde
+246 = ouml
+247 = divide
+248 = oslash
+249 = ugrave
+250 = uacute
+251 = ucirc
+252 = uuml
+253 = yacute
+254 = thorn
+255 = yuml
+
+# Character entity references for symbols, mathematical symbols, and Greek letters
+
+402 = fnof
+913 = Alpha
+914 = Beta
+915 = Gamma
+916 = Delta
+917 = Epsilon
+918 = Zeta
+919 = Eta
+920 = Theta
+921 = Iota
+922 = Kappa
+923 = Lambda
+924 = Mu
+925 = Nu
+926 = Xi
+927 = Omicron
+928 = Pi
+929 = Rho
+931 = Sigma
+932 = Tau
+933 = Upsilon
+934 = Phi
+935 = Chi
+936 = Psi
+937 = Omega
+945 = alpha
+946 = beta
+947 = gamma
+948 = delta
+949 = epsilon
+950 = zeta
+951 = eta
+952 = theta
+953 = iota
+954 = kappa
+955 = lambda
+956 = mu
+957 = nu
+958 = xi
+959 = omicron
+960 = pi
+961 = rho
+962 = sigmaf
+963 = sigma
+964 = tau
+965 = upsilon
+966 = phi
+967 = chi
+968 = psi
+969 = omega
+977 = thetasym
+978 = upsih
+982 = piv
+8226 = bull
+8230 = hellip
+8242 = prime
+8243 = Prime
+8254 = oline
+8260 = frasl
+8472 = weierp
+8465 = image
+8476 = real
+8482 = trade
+8501 = alefsym
+8592 = larr
+8593 = uarr
+8594 = rarr
+8595 = darr
+8596 = harr
+8629 = crarr
+8656 = lArr
+8657 = uArr
+8658 = rArr
+8659 = dArr
+8660 = hArr
+8704 = forall
+8706 = part
+8707 = exist
+8709 = empty
+8711 = nabla
+8712 = isin
+8713 = notin
+8715 = ni
+8719 = prod
+8721 = sum
+8722 = minus
+8727 = lowast
+8730 = radic
+8733 = prop
+8734 = infin
+8736 = ang
+8743 = and
+8744 = or
+8745 = cap
+8746 = cup
+8747 = int
+8756 = there4
+8764 = sim
+8773 = cong
+8776 = asymp
+8800 = ne
+8801 = equiv
+8804 = le
+8805 = ge
+8834 = sub
+8835 = sup
+8836 = nsub
+8838 = sube
+8839 = supe
+8853 = oplus
+8855 = otimes
+8869 = perp
+8901 = sdot
+8968 = lceil
+8969 = rceil
+8970 = lfloor
+8971 = rfloor
+9001 = lang
+9002 = rang
+9674 = loz
+9824 = spades
+9827 = clubs
+9829 = hearts
+9830 = diams
+
+# Character entity references for markup-significant and internationalization characters
+
+34 = quot
+38 = amp
+39 = #39
+60 = lt
+62 = gt
+338 = OElig
+339 = oelig
+352 = Scaron
+353 = scaron
+376 = Yuml
+710 = circ
+732 = tilde
+8194 = ensp
+8195 = emsp
+8201 = thinsp
+8204 = zwnj
+8205 = zwj
+8206 = lrm
+8207 = rlm
+8211 = ndash
+8212 = mdash
+8216 = lsquo
+8217 = rsquo
+8218 = sbquo
+8220 = ldquo
+8221 = rdquo
+8222 = bdquo
+8224 = dagger
+8225 = Dagger
+8240 = permil
+8249 = lsaquo
+8250 = rsaquo
+8364 = euro

classes/production/spring-webmvc/META-INF/spring.handlers

@@ -0,0 +1 @@
+http\://www.springframework.org/schema/mvc=org.springframework.web.servlet.config.MvcNamespaceHandler

classes/production/spring-webmvc/META-INF/spring.schemas

@@ -0,0 +1,8 @@
+http\://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd=org/springframework/web/servlet/config/spring-mvc.xsd
+http\://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd=org/springframework/web/servlet/config/spring-mvc.xsd
+http\://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd=org/springframework/web/servlet/config/spring-mvc.xsd
+http\://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd=org/springframework/web/servlet/config/spring-mvc.xsd
+http\://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd=org/springframework/web/servlet/config/spring-mvc.xsd
+http\://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd=org/springframework/web/servlet/config/spring-mvc.xsd
+http\://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd=org/springframework/web/servlet/config/spring-mvc.xsd
+http\://www.springframework.org/schema/mvc/spring-mvc.xsd=org/springframework/web/servlet/config/spring-mvc.xsd

classes/production/spring-webmvc/META-INF/spring.tld

@@ -0,0 +1,467 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
+		version="2.0">
+
+	<description>Spring Framework JSP Tag Library</description>
+	<tlib-version>4.0</tlib-version>
+	<short-name>spring</short-name>
+	<uri>http://www.springframework.org/tags</uri>
+
+	<tag>
+		<description>Sets default HTML escape value for the current page.
+		Overrides a "defaultHtmlEscape" context-param in web.xml, if any.</description>
+		<name>htmlEscape</name>
+		<tag-class>org.springframework.web.servlet.tags.HtmlEscapeTag</tag-class>
+		<body-content>JSP</body-content>
+		<attribute>
+			<description>Set the default value for HTML escaping, to be put
+			into the current PageContext.</description>
+			<name>defaultHtmlEscape</name>
+			<required>true</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+	</tag>
+
+	<tag>
+		<description>Escapes its enclosed body content, applying HTML escaping and/or JavaScript
+		escaping. The HTML escaping flag participates in a page-wide or application-wide setting
+		(i.e. by HtmlEscapeTag or a "defaultHtmlEscape" context-param in web.xml).</description>
+		<name>escapeBody</name>
+		<tag-class>org.springframework.web.servlet.tags.EscapeBodyTag</tag-class>
+		<body-content>JSP</body-content>
+		<attribute>
+			<description>Set HTML escaping for this tag, as boolean value. Overrides the
+			default HTML escaping setting for the current page.</description>
+			<name>htmlEscape</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set JavaScript escaping for this tag, as boolean value.
+			Default is 'false'.</description>
+			<name>javaScriptEscape</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+	</tag>
+
+	<tag>
+		<description>Retrieves the message with the given code, or text if code isn't resolvable.
+		The HTML escaping flag participates in a page-wide or application-wide setting
+		(i.e. by HtmlEscapeTag or a "defaultHtmlEscape" context-param in web.xml).</description>
+		<name>message</name>
+		<tag-class>org.springframework.web.servlet.tags.MessageTag</tag-class>
+		<body-content>JSP</body-content>
+		<attribute>
+			<description>A MessageSourceResolvable argument (direct or through JSP EL).
+			Fits nicely when used in conjunction with Spring's own validation error classes
+			which all implement the MessageSourceResolvable interface. For example, this
+			allows you to iterate over all of the errors in a form, passing each error
+			(using a runtime expression) as the value of this 'message' attribute, thus
+			effecting the easy display of such error messages.</description>
+			<name>message</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The code (key) to use when looking up the message.
+			If code is not provided, the text attribute will be used.</description>
+			<name>code</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set optional message arguments for this tag, as a (comma-)
+			delimited String (each String argument can contain JSP EL), an Object array
+			(used as argument array), or a single Object (used as single argument).
+			You can additionally use nested spring:argument tags.</description>
+			<name>arguments</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The separator character to be used for splitting the
+			arguments string value; defaults to a 'comma' (',').</description>
+			<name>argumentSeparator</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Default text to output when a message for the given code
+			could not be found. If both text and code are not set, the tag will
+			output null.</description>
+			<name>text</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The string to use when binding the result to the page,
+			request, session or application scope. If not specified, the result
+			gets outputted to the writer (i.e. typically directly to the JSP).</description>
+			<name>var</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The scope to use when exporting the result to a variable.
+			This attribute is only used when var is also set. Possible values are
+			page, request, session and application.</description>
+			<name>scope</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set HTML escaping for this tag, as boolean value.
+			Overrides the default HTML escaping setting for the current page.</description>
+			<name>htmlEscape</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set JavaScript escaping for this tag, as boolean value.
+			Default is 'false'.</description>
+			<name>javaScriptEscape</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+	</tag>
+
+	<tag>
+		<description>Retrieves the theme message with the given code, or text if code isn't
+		resolvable. The HTML escaping flag participates in a page-wide or application-wide setting
+		(i.e. by HtmlEscapeTag or a "defaultHtmlEscape" context-param in web.xml).</description>
+		<name>theme</name>
+		<tag-class>org.springframework.web.servlet.tags.ThemeTag</tag-class>
+		<body-content>JSP</body-content>
+		<attribute>
+			<description>A MessageSourceResolvable argument (direct or through JSP EL).</description>
+			<name>message</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The code (key) to use when looking up the message.
+			If code is not provided, the text attribute will be used.</description>
+			<name>code</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set optional message arguments for this tag, as a (comma-)
+			delimited String (each String argument can contain JSP EL), an Object array
+			(used as argument array), or a single Object (used as single argument).
+			You can additionally use nested spring:argument tags.</description>
+			<name>arguments</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The separator character to be used for splitting the
+			arguments string value; defaults to a 'comma' (',').</description>
+			<name>argumentSeparator</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Default text to output when a message for the given code
+			could not be found. If both text and code are not set, the tag will
+			output null.</description>
+			<name>text</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The string to use when binding the result to the page,
+			request, session or application scope. If not specified, the result
+			gets outputted to the writer (i.e. typically directly to the JSP).</description>
+			<name>var</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The scope to use when exporting the result to a variable.
+			This attribute is only used when var is also set. Possible values are
+			page, request, session and application.</description>
+			<name>scope</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set HTML escaping for this tag, as boolean value.
+			Overrides the default HTML escaping setting for the current page.</description>
+			<name>htmlEscape</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set JavaScript escaping for this tag, as boolean value.
+			Default is 'false'.</description>
+			<name>javaScriptEscape</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+	</tag>
+
+	<tag>
+		<description>Argument tag based on the JSTL fmt:param tag. The purpose is to
+		support arguments inside the spring:message and spring:theme tags.</description>
+		<name>argument</name>
+		<tag-class>org.springframework.web.servlet.tags.ArgumentTag</tag-class>
+		<body-content>JSP</body-content>
+		<attribute>
+			<description>The value of the argument.</description>
+			<name>value</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+			<type>java.lang.Object</type>
+		</attribute>
+	</tag>
+
+	<tag>
+		<description>Provides Errors instance in case of bind errors. The HTML escaping
+		flag participates in a page-wide or application-wide setting (i.e. by HtmlEscapeTag
+		or a "defaultHtmlEscape" context-param in web.xml).</description>
+		<name>hasBindErrors</name>
+		<tag-class>org.springframework.web.servlet.tags.BindErrorsTag</tag-class>
+		<body-content>JSP</body-content>
+		<variable>
+			<name-given>errors</name-given>
+			<variable-class>org.springframework.validation.Errors</variable-class>
+		</variable>
+		<attribute>
+			<description>The name of the bean in the request, that needs to be
+			inspected for errors. If errors are available for this bean, they
+			will be bound under the 'errors' key.</description>
+			<name>name</name>
+			<required>true</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set HTML escaping for this tag, as boolean value.
+			Overrides the default HTML escaping setting for the current page.</description>
+			<name>htmlEscape</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+	</tag>
+
+	<tag>
+		<description>Sets a nested path to be used by the bind tag's path.</description>
+		<name>nestedPath</name>
+		<tag-class>org.springframework.web.servlet.tags.NestedPathTag</tag-class>
+		<body-content>JSP</body-content>
+		<variable>
+			<name-given>nestedPath</name-given>
+			<variable-class>java.lang.String</variable-class>
+		</variable>
+		<attribute>
+			<description>Set the path that this tag should apply. E.g. 'customer'
+			to allow bind paths like 'address.street' rather than
+			'customer.address.street'.</description>
+			<name>path</name>
+			<required>true</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+	</tag>
+
+	<tag>
+		<description>Provides BindStatus object for the given bind path. The HTML escaping
+		flag participates in a page-wide or application-wide setting (i.e. by HtmlEscapeTag
+		or a "defaultHtmlEscape" context-param in web.xml).</description>
+		<name>bind</name>
+		<tag-class>org.springframework.web.servlet.tags.BindTag</tag-class>
+		<body-content>JSP</body-content>
+		<variable>
+			<name-given>status</name-given>
+			<variable-class>org.springframework.web.servlet.support.BindStatus</variable-class>
+		</variable>
+		<attribute>
+			<description>The path to the bean or bean property to bind status
+			information for. For instance account.name, company.address.zipCode
+			or just employee. The status object will exported to the page scope,
+			specifically for this bean or bean property.</description>
+			<name>path</name>
+			<required>true</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set whether to ignore a nested path, if any.
+			Default is to not ignore.</description>
+			<name>ignoreNestedPath</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set HTML escaping for this tag, as boolean value. Overrides
+			the default HTML escaping setting for the current page.</description>
+			<name>htmlEscape</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+	</tag>
+
+	<tag>
+		<description>Provides transformation of variables to Strings, using an appropriate
+		custom PropertyEditor from BindTag (can only be used inside BindTag). The HTML
+		escaping flag participates in a page-wide or application-wide setting (i.e. by
+		HtmlEscapeTag or a 'defaultHtmlEscape' context-param in web.xml).</description>
+		<name>transform</name>
+		<tag-class>org.springframework.web.servlet.tags.TransformTag</tag-class>
+		<body-content>JSP</body-content>
+		<attribute>
+			<description>The value to transform. This is the actual object you want
+			to have transformed (for instance a Date). Using the PropertyEditor that
+			is currently in use by the 'spring:bind' tag.</description>
+			<name>value</name>
+			<required>true</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The string to use when binding the result to the page,
+			request, session or application scope. If not specified, the result gets
+			outputted to the writer (i.e. typically directly to the JSP).</description>
+			<name>var</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The scope to use when exported the result to a variable.
+			This attribute is only used when var is also set. Possible values are
+			page, request, session and application.</description>
+			<name>scope</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set HTML escaping for this tag, as boolean value. Overrides
+			the default HTML escaping setting for the current page.</description>
+			<name>htmlEscape</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+	</tag>
+
+	<tag>
+		<description>URL tag based on the JSTL c:url tag. This variant is fully
+		backwards compatible with the standard tag. Enhancements include support
+		for URL template parameters.</description>
+		<name>url</name>
+		<tag-class>org.springframework.web.servlet.tags.UrlTag</tag-class>
+		<body-content>JSP</body-content>
+		<attribute>
+			<description>The URL to build. This value can include template place holders
+			that are replaced with the URL encoded value of the named parameter. Parameters
+			must be defined using the param tag inside the body of this tag.</description>
+			<name>value</name>
+			<required>true</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Specifies a remote application context path. The default is the
+			current application context path.</description>
+			<name>context</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The name of the variable to export the URL value to.</description>
+			<name>var</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The scope for the var. 'application', 'session', 'request' and
+			'page' scopes are supported. Defaults to page scope. This attribute has no
+			effect unless the var attribute is also defined.</description>
+			<name>scope</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set HTML escaping for this tag, as a boolean value. Overrides the
+			default HTML escaping setting for the current page.</description>
+			<name>htmlEscape</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set JavaScript escaping for this tag, as a boolean value.
+			Default is 'false'.</description>
+			<name>javaScriptEscape</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+	</tag>
+
+	<tag>
+		<description>Parameter tag based on the JSTL c:param tag. The sole purpose is to
+		support params inside the spring:url tag.</description>
+		<name>param</name>
+		<tag-class>org.springframework.web.servlet.tags.ParamTag</tag-class>
+		<body-content>JSP</body-content>
+		<attribute>
+			<description>The name of the parameter.</description>
+			<name>name</name>
+			<required>true</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The value of the parameter.</description>
+			<name>value</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+	</tag>
+
+	<tag>
+		<description>Evaluates a Spring expression (SpEL) and either prints the result
+		or assigns it to a variable.</description>
+		<name>eval</name>
+		<tag-class>org.springframework.web.servlet.tags.EvalTag</tag-class>
+		<body-content>JSP</body-content>
+		<attribute>
+			<description>The expression to evaluate.</description>
+			<name>expression</name>
+			<required>true</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The name of the variable to export the evaluation result to.</description>
+			<name>var</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>The scope for the var. 'application', 'session', 'request' and
+			'page' scopes are supported. Defaults to page scope. This attribute has no
+			effect unless the var attribute is also defined.</description>
+			<name>scope</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set HTML escaping for this tag, as a boolean value. Overrides the
+			default HTML escaping setting for the current page.</description>
+			<name>htmlEscape</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+		<attribute>
+			<description>Set JavaScript escaping for this tag, as a boolean value.
+			Default is 'false'.</description>
+			<name>javaScriptEscape</name>
+			<required>false</required>
+			<rtexprvalue>true</rtexprvalue>
+		</attribute>
+	</tag>
+
+    <function>
+        <description>Helps to prepare a URL to a Spring MVC controller method.</description>
+        <name>mvcUrl</name>
+        <function-class>org.springframework.web.servlet.mvc.method.annotation.MvcUriComponentsBuilder</function-class>
+        <function-signature>org.springframework.web.servlet.mvc.method.annotation.MvcUriComponentsBuilder.MethodArgumentBuilder fromMappingName(java.lang.String)</function-signature>
+    </function>
+
+</taglib>

classes/production/spring-webmvc/META-INF/spring.tooling

@@ -0,0 +1,4 @@
+# Tooling related information for the mvc namespace
+http\://www.springframework.org/schema/mvc@name=mvc Namespace
+http\://www.springframework.org/schema/mvc@prefix=mvc
+http\://www.springframework.org/schema/mvc@icon=org/springframework/web/servlet/config/spring-mvc.gif

classes/production/spring-webmvc/org/springframework/web/servlet/DispatcherServlet.properties

@@ -0,0 +1,24 @@
+# Default implementation classes for DispatcherServlet's strategy interfaces.
+# Used as fallback when no matching beans are found in the DispatcherServlet context.
+# Not meant to be customized by application developers.
+
+org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
+
+org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
+
+org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
+	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping
+
+org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
+	org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
+	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter
+
+org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
+	org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
+	org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
+
+org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
+
+org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
+
+org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

classes/production/spring-webmvc/org/springframework/web/servlet/view/freemarker/spring.ftl

@@ -0,0 +1,384 @@
+<#ftl strip_whitespace=true>
+<#--
+ * spring.ftl
+ *
+ * This file consists of a collection of FreeMarker macros aimed at easing
+ * some of the common requirements of web applications - in particular
+ * handling of forms.
+ *
+ * Spring's FreeMarker support will automatically make this file and therefore
+ * all macros within it available to any application using Spring's
+ * FreeMarkerConfigurer.
+ *
+ * To take advantage of these macros, the "exposeSpringMacroHelpers" property
+ * of the FreeMarker class needs to be set to "true". This will expose a
+ * RequestContext under the name "springMacroRequestContext", as needed by
+ * the macros in this library.
+ *
+ * @author Darren Davison
+ * @author Juergen Hoeller
+ * @since 1.1
+ -->
+
+<#--
+ * message
+ *
+ * Macro to translate a message code into a message.
+ -->
+<#macro message code>${springMacroRequestContext.getMessage(code)}</#macro>
+
+<#--
+ * messageText
+ *
+ * Macro to translate a message code into a message,
+ * using the given default text if no message found.
+ -->
+<#macro messageText code, text>${springMacroRequestContext.getMessage(code, text)}</#macro>
+
+<#--
+ * messageArgs
+ *
+ * Macro to translate a message code with arguments into a message.
+ -->
+<#macro messageArgs code, args>${springMacroRequestContext.getMessage(code, args)}</#macro>
+
+<#--
+ * messageArgsText
+ *
+ * Macro to translate a message code with arguments into a message,
+ * using the given default text if no message found.
+ -->
+<#macro messageArgsText code, args, text>${springMacroRequestContext.getMessage(code, args, text)}</#macro>
+
+<#--
+ * theme
+ *
+ * Macro to translate a theme message code into a message.
+ -->
+<#macro theme code>${springMacroRequestContext.getThemeMessage(code)}</#macro>
+
+<#--
+ * themeText
+ *
+ * Macro to translate a theme message code into a message,
+ * using the given default text if no message found.
+ -->
+<#macro themeText code, text>${springMacroRequestContext.getThemeMessage(code, text)}</#macro>
+
+<#--
+ * themeArgs
+ *
+ * Macro to translate a theme message code with arguments into a message.
+ -->
+<#macro themeArgs code, args>${springMacroRequestContext.getThemeMessage(code, args)}</#macro>
+
+<#--
+ * themeArgsText
+ *
+ * Macro to translate a theme message code with arguments into a message,
+ * using the given default text if no message found.
+ -->
+<#macro themeArgsText code, args, text>${springMacroRequestContext.getThemeMessage(code, args, text)}</#macro>
+
+<#--
+ * url
+ *
+ * Takes a relative URL and makes it absolute from the server root by
+ * adding the context root for the web application.
+ -->
+<#macro url relativeUrl extra...><#if extra?? && extra?size!=0>${springMacroRequestContext.getContextUrl(relativeUrl,extra)}<#else>${springMacroRequestContext.getContextUrl(relativeUrl)}</#if></#macro>
+
+<#--
+ * bind
+ *
+ * Exposes a BindStatus object for the given bind path, which can be
+ * a bean (e.g. "person") to get global errors, or a bean property
+ * (e.g. "person.name") to get field errors. Can be called multiple times
+ * within a form to bind to multiple command objects and/or field names.
+ *
+ * This macro will participate in the default HTML escape setting for the given
+ * RequestContext. This can be customized by calling "setDefaultHtmlEscape"
+ * on the "springMacroRequestContext" context variable, or via the
+ * "defaultHtmlEscape" context-param in web.xml (same as for the JSP bind tag).
+ * Also regards a "htmlEscape" variable in the namespace of this library.
+ *
+ * Producing no output, the following context variable will be available
+ * each time this macro is referenced (assuming you import this library in
+ * your templates with the namespace 'spring'):
+ *
+ *   spring.status : a BindStatus instance holding the command object name,
+ *   expression, value, and error messages and codes for the path supplied
+ *
+ * @param path : the path (string value) of the value required to bind to.
+ *   Spring defaults to a command name of "command" but this can be overridden
+ *   by user config.
+ -->
+<#macro bind path>
+    <#if htmlEscape?exists>
+        <#assign status = springMacroRequestContext.getBindStatus(path, htmlEscape)>
+    <#else>
+        <#assign status = springMacroRequestContext.getBindStatus(path)>
+    </#if>
+    <#-- assign a temporary value, forcing a string representation for any
+    kind of variable. This temp value is only used in this macro lib -->
+    <#if status.value?exists && status.value?is_boolean>
+        <#assign stringStatusValue=status.value?string>
+    <#else>
+        <#assign stringStatusValue=status.value?default("")>
+    </#if>
+</#macro>
+
+<#--
+ * bindEscaped
+ *
+ * Similar to spring:bind, but takes an explicit HTML escape flag rather
+ * than relying on the default HTML escape setting.
+ -->
+<#macro bindEscaped path, htmlEscape>
+    <#assign status = springMacroRequestContext.getBindStatus(path, htmlEscape)>
+    <#-- assign a temporary value, forcing a string representation for any
+    kind of variable. This temp value is only used in this macro lib -->
+    <#if status.value?exists && status.value?is_boolean>
+        <#assign stringStatusValue=status.value?string>
+    <#else>
+        <#assign stringStatusValue=status.value?default("")>
+    </#if>
+</#macro>
+
+<#--
+ * formInput
+ *
+ * Display a form input field of type 'text' and bind it to an attribute
+ * of a command or bean.
+ *
+ * @param path the name of the field to bind to
+ * @param attributes any additional attributes for the element (such as class
+ *    or CSS styles or size
+ -->
+<#macro formInput path attributes="" fieldType="text">
+    <@bind path/>
+    <input type="${fieldType}" id="${status.expression?replace('[','')?replace(']','')}" name="${status.expression}" value="<#if fieldType!="password">${stringStatusValue}</#if>" ${attributes}<@closeTag/>
+</#macro>
+
+<#--
+ * formPasswordInput
+ *
+ * Display a form input field of type 'password' and bind it to an attribute
+ * of a command or bean. No value will ever be displayed. This functionality
+ * can also be obtained by calling the formInput macro with a 'type' parameter
+ * of 'password'.
+ *
+ * @param path the name of the field to bind to
+ * @param attributes any additional attributes for the element (such as class
+ *    or CSS styles or size
+ -->
+<#macro formPasswordInput path attributes="">
+    <@formInput path, attributes, "password"/>
+</#macro>
+
+<#--
+ * formHiddenInput
+ *
+ * Generate a form input field of type 'hidden' and bind it to an attribute
+ * of a command or bean. This functionality can also be obtained by calling
+ * the formInput macro with a 'type' parameter of 'hidden'.
+ *
+ * @param path the name of the field to bind to
+ * @param attributes any additional attributes for the element (such as class
+ *    or CSS styles or size
+ -->
+<#macro formHiddenInput path attributes="">
+    <@formInput path, attributes, "hidden"/>
+</#macro>
+
+<#--
+ * formTextarea
+ *
+ * Display a text area and bind it to an attribute of a command or bean.
+ *
+ * @param path the name of the field to bind to
+ * @param attributes any additional attributes for the element (such as class
+ *    or CSS styles or size
+ -->
+<#macro formTextarea path attributes="">
+    <@bind path/>
+    <textarea id="${status.expression?replace('[','')?replace(']','')}" name="${status.expression}" ${attributes}>
+${stringStatusValue}</textarea>
+</#macro>
+
+<#--
+ * formSingleSelect
+ *
+ * Show a selectbox (dropdown) input element allowing a single value to be chosen
+ * from a list of options.
+ *
+ * @param path the name of the field to bind to
+ * @param options a map (value=label) of all the available options
+ * @param attributes any additional attributes for the element (such as class
+ *    or CSS styles or size
+-->
+<#macro formSingleSelect path options attributes="">
+    <@bind path/>
+    <select id="${status.expression?replace('[','')?replace(']','')}" name="${status.expression}" ${attributes}>
+        <#if options?is_hash>
+            <#list options?keys as value>
+            <option value="${value?html}"<@checkSelected value/>>${options[value]?html}</option>
+            </#list>
+        <#else> 
+            <#list options as value>
+            <option value="${value?html}"<@checkSelected value/>>${value?html}</option>
+            </#list>
+        </#if>
+    </select>
+</#macro>
+
+<#--
+ * formMultiSelect
+ *
+ * Show a listbox of options allowing the user to make 0 or more choices from
+ * the list of options.
+ *
+ * @param path the name of the field to bind to
+ * @param options a map (value=label) of all the available options
+ * @param attributes any additional attributes for the element (such as class
+ *    or CSS styles or size
+-->
+<#macro formMultiSelect path options attributes="">
+    <@bind path/>
+    <select multiple="multiple" id="${status.expression?replace('[','')?replace(']','')}" name="${status.expression}" ${attributes}>
+        <#list options?keys as value>
+        <#assign isSelected = contains(status.actualValue?default([""]), value)>
+        <option value="${value?html}"<#if isSelected> selected="selected"</#if>>${options[value]?html}</option>
+        </#list>
+    </select>
+</#macro>
+
+<#--
+ * formRadioButtons
+ *
+ * Show radio buttons.
+ *
+ * @param path the name of the field to bind to
+ * @param options a map (value=label) of all the available options
+ * @param separator the html tag or other character list that should be used to
+ *    separate each option. Typically '&nbsp;' or '<br>'
+ * @param attributes any additional attributes for the element (such as class
+ *    or CSS styles or size
+-->
+<#macro formRadioButtons path options separator attributes="">
+    <@bind path/>
+    <#list options?keys as value>
+    <#assign id="${status.expression?replace('[','')?replace(']','')}${value_index}">
+    <input type="radio" id="${id}" name="${status.expression}" value="${value?html}"<#if stringStatusValue == value> checked="checked"</#if> ${attributes}<@closeTag/>
+    <label for="${id}">${options[value]?html}</label>${separator}
+    </#list>
+</#macro>
+
+<#--
+ * formCheckboxes
+ *
+ * Show checkboxes.
+ *
+ * @param path the name of the field to bind to
+ * @param options a map (value=label) of all the available options
+ * @param separator the html tag or other character list that should be used to
+ *    separate each option. Typically '&nbsp;' or '<br>'
+ * @param attributes any additional attributes for the element (such as class
+ *    or CSS styles or size
+-->
+<#macro formCheckboxes path options separator attributes="">
+    <@bind path/>
+    <#list options?keys as value>
+    <#assign id="${status.expression?replace('[','')?replace(']','')}${value_index}">
+    <#assign isSelected = contains(status.actualValue?default([""]), value)>
+    <input type="checkbox" id="${id}" name="${status.expression}" value="${value?html}"<#if isSelected> checked="checked"</#if> ${attributes}<@closeTag/>
+    <label for="${id}">${options[value]?html}</label>${separator}
+    </#list>
+    <input type="hidden" name="_${status.expression}" value="on"/>
+</#macro>
+
+<#--
+ * formCheckbox
+ *
+ * Show a single checkbox.
+ *
+ * @param path the name of the field to bind to
+ * @param attributes any additional attributes for the element (such as class
+ *    or CSS styles or size
+-->
+<#macro formCheckbox path attributes="">
+	<@bind path />
+    <#assign id="${status.expression?replace('[','')?replace(']','')}">
+    <#assign isSelected = status.value?? && status.value?string=="true">
+	<input type="hidden" name="_${status.expression}" value="on"/>
+	<input type="checkbox" id="${id}" name="${status.expression}"<#if isSelected> checked="checked"</#if> ${attributes}/>
+</#macro>
+
+<#--
+ * showErrors
+ *
+ * Show validation errors for the currently bound field, with
+ * optional style attributes.
+ *
+ * @param separator the html tag or other character list that should be used to
+ *    separate each option. Typically '<br>'.
+ * @param classOrStyle either the name of a CSS class element (which is defined in
+ *    the template or an external CSS file) or an inline style. If the value passed in here
+ *    contains a colon (:) then a 'style=' attribute will be used, else a 'class=' attribute
+ *    will be used.
+-->
+<#macro showErrors separator classOrStyle="">
+    <#list status.errorMessages as error>
+    <#if classOrStyle == "">
+        <b>${error}</b>
+    <#else>
+        <#if classOrStyle?index_of(":") == -1><#assign attr="class"><#else><#assign attr="style"></#if>
+        <span ${attr}="${classOrStyle}">${error}</span>
+    </#if>
+    <#if error_has_next>${separator}</#if>
+    </#list>
+</#macro>
+
+<#--
+ * checkSelected
+ *
+ * Check a value in a list to see if it is the currently selected value.
+ * If so, add the 'selected="selected"' text to the output.
+ * Handles values of numeric and string types.
+ * This function is used internally but can be accessed by user code if required.
+ *
+ * @param value the current value in a list iteration
+-->
+<#macro checkSelected value>
+    <#if stringStatusValue?is_number && stringStatusValue == value?number>selected="selected"</#if>
+    <#if stringStatusValue?is_string && stringStatusValue == value>selected="selected"</#if>
+</#macro>
+
+<#--
+ * contains
+ *
+ * Macro to return true if the list contains the scalar, false if not.
+ * Surprisingly not a FreeMarker builtin.
+ * This function is used internally but can be accessed by user code if required.
+ *
+ * @param list the list to search for the item
+ * @param item the item to search for in the list
+ * @return true if item is found in the list, false otherwise
+-->
+<#function contains list item>
+    <#list list as nextInList>
+    <#if nextInList == item><#return true></#if>
+    </#list>
+    <#return false>
+</#function>
+
+<#--
+ * closeTag
+ *
+ * Simple macro to close an HTML tag that has no body with '>' or '/>',
+ * depending on the value of a 'xhtmlCompliant' variable in the namespace
+ * of this library.
+-->
+<#macro closeTag>
+    <#if xhtmlCompliant?exists && xhtmlCompliant>/><#else>></#if>
+</#macro>

classes/production/spring-websocket/META-INF/spring.handlers

@@ -0,0 +1 @@
+http\://www.springframework.org/schema/websocket=org.springframework.web.socket.config.WebSocketNamespaceHandler

classes/production/spring-websocket/META-INF/spring.schemas

@@ -0,0 +1,5 @@
+http\://www.springframework.org/schema/websocket/spring-websocket-4.0.xsd=org/springframework/web/socket/config/spring-websocket.xsd
+http\://www.springframework.org/schema/websocket/spring-websocket-4.1.xsd=org/springframework/web/socket/config/spring-websocket.xsd
+http\://www.springframework.org/schema/websocket/spring-websocket-4.2.xsd=org/springframework/web/socket/config/spring-websocket.xsd
+http\://www.springframework.org/schema/websocket/spring-websocket-4.3.xsd=org/springframework/web/socket/config/spring-websocket.xsd
+http\://www.springframework.org/schema/websocket/spring-websocket.xsd=org/springframework/web/socket/config/spring-websocket.xsd

classes/production/spring-websocket/META-INF/spring.tooling

@@ -0,0 +1,4 @@
+# Tooling related information for the mvc namespace
+http\://www.springframework.org/schema/websocket@name=websocket Namespace
+http\://www.springframework.org/schema/websocket@prefix=websocket
+http\://www.springframework.org/schema/websocket@icon=org/springframework/web/socket/config/spring-websocket.gif

classes/production/spring-websocket/org/springframework/web/socket/config/spring-websocket.xsd

@@ -0,0 +1,931 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+
+<xsd:schema xmlns="http://www.springframework.org/schema/websocket"
+			xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+			xmlns:beans="http://www.springframework.org/schema/beans"
+			xmlns:tool="http://www.springframework.org/schema/tool"
+			targetNamespace="http://www.springframework.org/schema/websocket"
+			elementFormDefault="qualified"
+			attributeFormDefault="unqualified">
+
+	<xsd:import namespace="http://www.springframework.org/schema/beans" schemaLocation="http://www.springframework.org/schema/beans/spring-beans.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd"/>
+
+	<xsd:complexType name="mapping">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	An entry in the registered HandlerMapping that matches a path with a handler.
+            ]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:attribute name="path" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	A path that maps a particular request to a handler.
+	Exact path mapping URIs (such as "/myPath") are supported as well as Ant-type path patterns (such as /myPath/**).
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="handler" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.web.socket.WebSocketHandler"><![CDATA[
+    The bean name of a WebSocketHandler to use for requests that match the path configuration.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:complexType name="handshake-handler">
+		<xsd:attribute name="ref" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.web.socket.server.HandshakeHandler"><![CDATA[
+    The bean name of a HandshakeHandler to use for processing WebSocket handshake requests.
+    If none specified, a DefaultHandshakeHandler will be configured by default.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:complexType name="handshake-interceptors">
+		<xsd:annotation>
+			<xsd:documentation source="org.springframework.web.socket.server.HandshakeInterceptor"><![CDATA[
+	A list of HandshakeInterceptor beans definition and references.
+	A HandshakeInterceptor can be used to inspect the handshake request and response as well as to pass attributes to the target WebSocketHandler.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:choice maxOccurs="unbounded">
+				<xsd:element ref="beans:bean">
+					<xsd:annotation>
+						<xsd:documentation source="org.springframework.web.socket.server.HandshakeInterceptor"><![CDATA[
+	A HandshakeInterceptor bean definition.
+                        ]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+				<xsd:element ref="beans:ref">
+					<xsd:annotation>
+						<xsd:documentation source="org.springframework.web.socket.server.HandshakeInterceptor"><![CDATA[
+	A reference to a HandshakeInterceptor bean.
+                    ]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+			</xsd:choice>
+		</xsd:sequence>
+	</xsd:complexType>
+
+	<xsd:complexType name="sockjs-service">
+		<xsd:annotation>
+			<xsd:documentation source="org.springframework.web.socket.sockjs.transport.handler.DefaultSockJsService"><![CDATA[
+	Configures a DefaultSockJsService for processing HTTP requests from SockJS clients.
+            ]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:element name="transport-handlers" minOccurs="0" maxOccurs="1">
+				<xsd:annotation>
+					<xsd:documentation source="org.springframework.web.socket.sockjs.transport.TransportHandler"><![CDATA[
+	List of TransportHandler beans to be configured for the current handlers element.
+	One can choose not to register the default TransportHandlers and/or override those using
+	custom TransportHandlers.
+                ]]></xsd:documentation>
+				</xsd:annotation>
+				<xsd:complexType>
+					<xsd:sequence>
+						<xsd:choice maxOccurs="unbounded">
+							<xsd:element ref="beans:bean">
+								<xsd:annotation>
+									<xsd:documentation><![CDATA[
+	A TransportHandler bean definition.
+                        ]]></xsd:documentation>
+								</xsd:annotation>
+							</xsd:element>
+							<xsd:element ref="beans:ref">
+								<xsd:annotation>
+									<xsd:documentation><![CDATA[
+	A reference to a TransportHandler bean.
+                        ]]></xsd:documentation>
+								</xsd:annotation>
+							</xsd:element>
+						</xsd:choice>
+					</xsd:sequence>
+					<xsd:attribute name="register-defaults" type="xsd:boolean" default="true">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	Whether or not default TransportHandlers registrations should be added in addition to the ones provided within this element.
+	Default registrations include XhrPollingTransportHandler, XhrReceivingTransportHandler,
+	JsonpPollingTransportHandler, JsonpReceivingTransportHandler, XhrStreamingTransportHandler,
+	EventSourceTransportHandler, HtmlFileTransportHandler, and WebSocketTransportHandler.
+                        ]]></xsd:documentation>
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:complexType>
+			</xsd:element>
+		</xsd:sequence>
+		<xsd:attribute name="name" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.web.socket.sockjs.support.AbstractSockJsService"><![CDATA[
+	A unique name for the service, mainly for logging purposes.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="client-library-url" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.web.socket.sockjs.support.AbstractSockJsService"><![CDATA[
+	Transports with no native cross-domain communication (e.g. "eventsource",
+	"htmlfile") must get a simple page from the "foreign" domain in an invisible
+	iframe so that code in the iframe can run from  a domain local to the SockJS
+	server. Since the iframe needs to load the SockJS javascript client library,
+	this property allows specifying where to load it from.
+
+	By default this is set to point to
+	"https://d1fxtkz8shb9d2.cloudfront.net/sockjs-0.3.4.min.js". However it can
+	also be set to point to a URL served by the application.
+
+	Note that it's possible to specify a relative URL in which case the URL
+	must be relative to the iframe URL. For example assuming a SockJS endpoint
+	mapped to "/sockjs", and resulting iframe URL "/sockjs/iframe.html", then the
+	The relative URL must start with "../../" to traverse up to the location
+	above the SockJS mapping. In case of a prefix-based Servlet mapping one more
+	traversal may be needed.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="stream-bytes-limit" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.web.socket.sockjs.support.AbstractSockJsService"><![CDATA[
+	Minimum number of bytes that can be send over a single HTTP streaming request before it will be closed.
+	Defaults to 128K (i.e. 128 1024).
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="session-cookie-needed" type="xsd:boolean">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.web.socket.sockjs.support.AbstractSockJsService"><![CDATA[
+	The "cookie_needed" value in the response from the SockJs "/info" endpoint.
+	This property indicates whether the use of a JSESSIONID cookie is required for the application to function correctly,
+	e.g. for load balancing or in Java Servlet containers for the use of an HTTP session.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="heartbeat-time" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.web.socket.sockjs.support.AbstractSockJsService"><![CDATA[
+	The amount of time in milliseconds when the server has not sent any messages and after which the server
+	should send a heartbeat frame to the client in order to keep the connection from breaking.
+	The default value is 25,000 (25 seconds).
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="disconnect-delay" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.web.socket.sockjs.support.AbstractSockJsService"><![CDATA[
+	The amount of time in milliseconds before a client is considered disconnected after not having
+	a receiving connection, i.e. an active connection over which the server can send data to the client.
+	The default value is 5000.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="message-cache-size" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.web.socket.sockjs.support.AbstractSockJsService"><![CDATA[
+	The number of server-to-client messages that a session can cache while waiting for
+	the next HTTP polling request from the client.
+	The default size is 100.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="websocket-enabled" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.web.socket.sockjs.support.AbstractSockJsService"><![CDATA[
+	Some load balancers don't support websockets. Set this option to "false" to disable the WebSocket transport on the server side.
+	The default value is "true".
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="scheduler" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.web.socket.sockjs.support.AbstractSockJsService"><![CDATA[
+	The bean name of a TaskScheduler; a new ThreadPoolTaskScheduler instance will be created if no value is provided.
+	This scheduler instance will be used for scheduling heart-beat messages.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="message-codec" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.web.socket.sockjs.support.AbstractSockJsService"><![CDATA[
+	The bean name of a SockJsMessageCodec to use for encoding and decoding SockJS messages.
+	By default Jackson2SockJsMessageCodec is used requiring the Jackson library to be present on the classpath.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="suppress-cors" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.web.socket.sockjs.support.AbstractSockJsService"><![CDATA[
+	This option can be used to disable automatic addition of CORS headers for SockJS requests.
+	The default value is "false".
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:complexType name="stomp-broker-relay">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.messaging.simp.stomp.StompBrokerRelayMessageHandler"><![CDATA[
+	Configures a MessageHandler that handles messages by forwarding them to a STOMP broker.
+	This MessageHandler also opens a default "system" TCP connection to the message
+	broker that is used for sending messages that originate from the server application (as
+	opposed to from a client).
+	The "login", "password", "heartbeat-send-interval" and "heartbeat-receive-interval" attributes
+	are provided to configure this "system" connection.
+                ]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:attribute name="prefix" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.messaging.simp.stomp.StompBrokerRelayMessageHandler"><![CDATA[
+	Comma-separated list of destination prefixes supported by the broker being configured.
+	Destinations that do not match the given prefix(es) are ignored.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="relay-host" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.messaging.simp.stomp.StompBrokerRelayMessageHandler"><![CDATA[
+	The STOMP message broker host.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="relay-port" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.messaging.simp.stomp.StompBrokerRelayMessageHandler"><![CDATA[
+	The STOMP message broker port.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="client-login" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.messaging.simp.stomp.StompBrokerRelayMessageHandler"><![CDATA[
+	The login to use when creating connections to the STOMP broker on behalf of connected clients.
+	By default this is set to "guest".
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="client-passcode" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.messaging.simp.stomp.StompBrokerRelayMessageHandler"><![CDATA[
+	The passcode to use when creating connections to the STOMP broker on behalf of connected clients.
+	By default this is set to "guest".
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="system-login" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.messaging.simp.stomp.StompBrokerRelayMessageHandler"><![CDATA[
+	The login for the shared "system" connection used to send messages to
+	the STOMP broker from within the application, i.e. messages not associated
+	with a specific client session (e.g. REST/HTTP request handling method).
+	By default this is set to "guest".
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="system-passcode" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.messaging.simp.stomp.StompBrokerRelayMessageHandler"><![CDATA[
+	The passcode for the shared "system" connection used to send messages to
+	the STOMP broker from within the application, i.e. messages not associated
+	with a specific client session (e.g. REST/HTTP request handling method).
+	By default this is set to "guest".
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="heartbeat-send-interval" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.messaging.simp.stomp.StompBrokerRelayMessageHandler"><![CDATA[
+	The interval, in milliseconds, at which the "system" connection will send heartbeats to the STOMP broker.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="heartbeat-receive-interval" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.messaging.simp.stomp.StompBrokerRelayMessageHandler"><![CDATA[
+	The interval, in milliseconds, at which the "system" connection expects to receive heartbeats from the STOMP broker.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="auto-startup" type="xsd:boolean">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.messaging.simp.stomp.StompBrokerRelayMessageHandler"><![CDATA[
+	Whether or not the StompBrokerRelay should be automatically started as part of its SmartLifecycle,
+	i.e. at the time of an application context refresh.
+	Default value is "true".
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="virtual-host" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.messaging.simp.stomp.StompBrokerRelayMessageHandler"><![CDATA[
+	The value of the "host" header to use in STOMP CONNECT frames sent to the STOMP broker.
+	This may be useful for example in a cloud environment where the actual host to which
+	the TCP connection is established is different from the host providing the cloud-based STOMP service.
+	By default this property is not set.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="user-destination-broadcast" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Set a destination to broadcast messages to that remain unresolved because
+	the user is not connected. In a multi-application server scenario this
+	gives other application servers a chance to try.
+	By default this is not set.
+                    ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="user-registry-broadcast" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	Set a destination to broadcast the content of the local user registry to
+	and to listen for such broadcasts from other servers. In a multi-application
+	server scenarios this allows each server's user registry to be aware of
+	users connected to other servers.
+	By default this is not set.
+                    ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:complexType name="simple-broker">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.messaging.simp.broker.SimpleBrokerMessageHandler"><![CDATA[
+	Configures a SimpleBrokerMessageHandler that handles messages as a simple message broker implementation.
+                ]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:attribute name="prefix" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.messaging.simp.stomp.SimpleBrokerMessageHandler"><![CDATA[
+	Comma-separated list of destination prefixes supported by the broker being configured.
+	Destinations that do not match the given prefix(es) are ignored.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="heartbeat" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.messaging.simp.stomp.SimpleBrokerMessageHandler"><![CDATA[
+	Configure the value for the heartbeat settings. The first number represents how often the server will
+	write or send a heartbeat. The second is how often the client should write. 0 means no heartbeats.
+	By default this is set to "0, 0" unless the scheduler attribute is also set in which case the
+	default becomes "10000,10000" (in milliseconds).
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="scheduler" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.messaging.simp.stomp.SimpleBrokerMessageHandler"><![CDATA[
+	The name of a task TaskScheduler to use for heartbeat support. Setting this property also
+	automatically sets the heartbeat attribute to "10000, 10000".
+	By default this attribute is not set.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:complexType name="channel">
+		<xsd:sequence>
+			<xsd:element name="executor" type="channel-executor" minOccurs="0" maxOccurs="1"/>
+			<xsd:element name="interceptors" type="channel-interceptors" minOccurs="0" maxOccurs="1"/>
+		</xsd:sequence>
+	</xsd:complexType>
+
+	<xsd:complexType name="channel-executor">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"><![CDATA[
+	Configuration for the ThreadPoolTaskExecutor that sends messages for the message channel.
+                ]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:attribute name="core-pool-size" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"><![CDATA[
+	Set the core pool size of the ThreadPoolExecutor.
+	NOTE: the core pool size is effectively the max pool size when an unbounded queue-capacity is configured (the default).
+	This is essentially the "Unbounded queues" strategy as explained in java.util.concurrent.ThreadPoolExecutor.
+	When this strategy is used, the max pool size is effectively ignored.
+	By default this is set to twice the value of Runtime.availableProcessors().
+	In an application where tasks do not block frequently,
+	the number should be closer to or equal to the number of available CPUs/cores.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="max-pool-size" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"><![CDATA[
+	 Set the max pool size of the ThreadPoolExecutor.
+	 NOTE: when an unbounded queue-capacity is configured (the default), the max pool size is effectively ignored.
+	 See the "Unbounded queues" strategy in java.util.concurrent.ThreadPoolExecutor for more details.
+	 By default this is set to Integer.MAX_VALUE.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="keep-alive-seconds" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"><![CDATA[
+	 Set the time limit for which threads may remain idle before being terminated.
+	 If there are more than the core number of threads currently in the pool, after waiting this amount of time without
+	 processing a task, excess threads will be terminated.  This overrides any value set in the constructor.
+	 By default this is set to 60.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="queue-capacity" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation source="java:org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"><![CDATA[
+	 Set the queue capacity for the ThreadPoolExecutor.
+	 NOTE: when an unbounded queue-capacity is configured (the default) the core pool size is effectively the max pool size.
+	 This is essentially the "Unbounded queues" strategy as explained in java.util.concurrent.ThreadPoolExecutor.
+	 When this strategy is used, the max pool size is effectively ignored.
+	 By default this is set to Integer.MAX_VALUE.
+                ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+	<xsd:complexType name="channel-interceptors">
+		<xsd:annotation>
+			<xsd:documentation source="java:org.springframework.messaging.support.ChannelInterceptor"><![CDATA[
+	List of ChannelInterceptor beans to be used with this channel.
+	Empty by default.
+                ]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:sequence>
+			<xsd:choice maxOccurs="unbounded">
+				<xsd:element ref="beans:bean">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	A ChannelInterceptor bean definition.
+                        ]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+				<xsd:element ref="beans:ref">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	A reference to a ChannelInterceptor bean.
+                        ]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+			</xsd:choice>
+		</xsd:sequence>
+	</xsd:complexType>
+
+	<!-- Elements definitions -->
+
+	<xsd:element name="handlers">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Configures WebSocket support by registering a SimpleUrlHandlerMapping and mapping
+	paths to registered WebSocketHandlers.
+
+	If a sockjs service is configured within this element, then a
+	SockJsHttpRequestHandler will handle
+	requests mapped to the given path.
+
+	Otherwise a WebSocketHttpRequestHandler
+	will be registered for that purpose.
+
+	See EnableWebSocket Javadoc for
+	information on code-based alternatives to enabling WebSocket support.
+            ]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:sequence>
+				<xsd:element name="mapping" type="mapping" minOccurs="1" maxOccurs="unbounded"/>
+				<xsd:element name="handshake-handler" type="handshake-handler" minOccurs="0" maxOccurs="1"/>
+				<xsd:element name="handshake-interceptors" type="handshake-interceptors" minOccurs="0" maxOccurs="1"/>
+				<xsd:element name="sockjs" type="sockjs-service" minOccurs="0" maxOccurs="1"/>
+			</xsd:sequence>
+			<xsd:attribute name="order" type="xsd:token">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Order value for this SimpleUrlHandlerMapping.
+	Default value is 1.
+                ]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="allowed-origins" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+		Configure allowed {@code Origin} header values. Multiple origins may be specified
+		as a comma-separated list.
+
+		This check is mostly designed for browser clients. There is noting preventing other
+		types of client to modify the Origin header value.
+
+		When SockJS is enabled and allowed origins are restricted, transport types that do not
+		use {@code Origin} headers for cross origin requests (jsonp-polling, iframe-xhr-polling,
+		iframe-eventsource and iframe-htmlfile) are disabled. As a consequence, IE6/IE7 won't be
+		supported anymore and IE8/IE9 will only be supported without cookies.
+
+		By default, all origins are allowed.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="message-broker">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	Configures broker-backed messaging over WebSocket using a higher-level messaging sub-protocol.
+	Registers a SimpleUrlHandlerMapping and maps paths to registered Controllers.
+
+	A StompSubProtocolHandler is registered to handle various versions of the STOMP protocol.
+
+	See EnableWebSocketMessageBroker javadoc for information on code-based alternatives to enabling broker-backed messaging.
+            ]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:sequence>
+				<xsd:element name="transport" minOccurs="0" maxOccurs="1">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	Configure options related to the processing of messages received from and sent to WebSocket clients.
+                        ]]></xsd:documentation>
+					</xsd:annotation>
+					<xsd:complexType>
+						<xsd:sequence>
+							<xsd:element name="decorator-factories" maxOccurs="1" minOccurs="0">
+								<xsd:complexType>
+									<xsd:annotation>
+										<xsd:documentation source="org.springframework.web.socket.handler.WebSocketHandlerDecoratorFactory"><![CDATA[
+	Configure one or more factories to decorate the handler used to process WebSocket
+	messages. This may be useful for some advanced use cases, for example to allow
+	Spring Security to forcibly close the WebSocket session when the corresponding
+	HTTP session expires.
+			]]></xsd:documentation>
+									</xsd:annotation>
+									<xsd:sequence>
+										<xsd:choice minOccurs="1" maxOccurs="unbounded">
+											<xsd:element ref="beans:bean">
+												<xsd:annotation>
+													<xsd:documentation source="org.springframework.web.socket.handler.WebSocketHandlerDecoratorFactory"><![CDATA[
+	A WebSocketHandlerDecoratorFactory bean definition.
+                        ]]></xsd:documentation>
+												</xsd:annotation>
+											</xsd:element>
+											<xsd:element ref="beans:ref">
+												<xsd:annotation>
+													<xsd:documentation source="org.springframework.web.socket.handler.WebSocketHandlerDecoratorFactory"><![CDATA[
+	A reference to a WebSocketHandlerDecoratorFactory bean.
+                    ]]></xsd:documentation>
+												</xsd:annotation>
+											</xsd:element>
+										</xsd:choice>
+									</xsd:sequence>
+								</xsd:complexType>
+							</xsd:element>
+						</xsd:sequence>
+						<xsd:attribute name="message-size" type="xsd:string">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+	Configure the maximum size for an incoming sub-protocol message.
+	For example a STOMP message may be received as multiple WebSocket messages
+	or multiple HTTP POST requests when SockJS fallback options are in use.
+
+	In theory a WebSocket message can be almost unlimited in size.
+	In practice WebSocket servers impose limits on incoming message size.
+	STOMP clients for example tend to split large messages around 16K
+	boundaries. Therefore a server must be able to buffer partial content
+	and decode when enough data is received. Use this property to configure
+	the max size of the buffer to use.
+
+	The default value is 64K (i.e. 64 * 1024).
+
+	NOTE that the current version 1.2 of the STOMP spec
+	does not specifically discuss how to send STOMP messages over WebSocket.
+	Version 2 of the spec will but in the mean time existing client libraries
+	have already established a practice that servers must handle.
+                                ]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:attribute>
+						<xsd:attribute name="send-timeout" type="xsd:string">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+	Configure a time limit (in milliseconds) for the maximum amount of a time
+	allowed when sending messages to a WebSocket session or writing to an
+	HTTP response when SockJS fallback option are in use.
+
+	In general WebSocket servers expect that messages to a single WebSocket
+	session are sent from a single thread at a time. This is automatically
+	guaranteed when using {@code @EnableWebSocketMessageBroker} configuration.
+	If message sending is slow, or at least slower than rate of messages sending,
+	subsequent messages are buffered until either the {@code sendTimeLimit}
+	or the {@code sendBufferSizeLimit} are reached at which point the session
+	state is cleared and an attempt is made to close the session.
+
+	NOTE that the session time limit is checked only
+	on attempts to send additional messages. So if only a single message is
+	sent and it hangs, the session will not time out until another message is
+	sent or the underlying physical socket times out. So this is not a
+	replacement for WebSocket server or HTTP connection timeout but is rather
+	intended to control the extent of buffering of unsent messages.
+
+	NOTE that closing the session may not succeed in
+	actually closing the physical socket and may also hang. This is true
+	especially when using blocking IO such as the BIO connector in Tomcat
+	that is used by default on Tomcat 7. Therefore it is recommended to ensure
+	the server is using non-blocking IO such as Tomcat's NIO connector that
+	is used by default on Tomcat 8. If you must use blocking IO consider
+	customizing OS-level TCP settings, for example
+	{@code /proc/sys/net/ipv4/tcp_retries2} on Linux.
+
+	The default value is 10 seconds (i.e. 10 * 10000).
+                                ]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:attribute>
+						<xsd:attribute name="send-buffer-size" type="xsd:string">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+	Configure the maximum amount of data to buffer when sending messages
+	to a WebSocket session, or an HTTP response when SockJS fallback
+	option are in use.
+
+	In general WebSocket servers expect that messages to a single WebSocket
+	session are sent from a single thread at a time. This is automatically
+	guaranteed when using {@code @EnableWebSocketMessageBroker} configuration.
+	If message sending is slow, or at least slower than rate of messages sending,
+	subsequent messages are buffered until either the {@code sendTimeLimit}
+	or the {@code sendBufferSizeLimit} are reached at which point the session
+	state is cleared and an attempt is made to close the session.
+
+	NOTE that closing the session may not succeed in
+	actually closing the physical socket and may also hang. This is true
+	especially when using blocking IO such as the BIO connector in Tomcat
+	configured by default on Tomcat 7. Therefore it is recommended to ensure
+	the server is using non-blocking IO such as Tomcat's NIO connector used
+	by default on Tomcat 8. If you must use blocking IO consider customizing
+	OS-level TCP settings, for example {@code /proc/sys/net/ipv4/tcp_retries2}
+	on Linux.
+
+	The default value is 512K (i.e. 512 * 1024).
+
+	@param sendBufferSizeLimit the maximum number of bytes to buffer when
+	sending messages; if the value is less than or equal to 0 then buffering
+	is effectively disabled.
+                                ]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:attribute>
+					</xsd:complexType>
+				</xsd:element>
+				<xsd:element name="stomp-endpoint" minOccurs="1" maxOccurs="unbounded">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	Registers STOMP over WebSocket endpoints.
+                        ]]></xsd:documentation>
+					</xsd:annotation>
+					<xsd:complexType>
+						<xsd:sequence>
+							<xsd:element name="handshake-handler" type="handshake-handler" minOccurs="0" maxOccurs="1"/>
+							<xsd:element name="handshake-interceptors" type="handshake-interceptors" minOccurs="0" maxOccurs="1"/>
+							<xsd:element name="sockjs" type="sockjs-service" minOccurs="0" maxOccurs="1"/>
+						</xsd:sequence>
+						<xsd:attribute name="path" type="xsd:string">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+	A path that maps a particular message destination to a handler method.
+	Exact path mapping URIs (such as "/myPath") are supported as well as Ant-stype path patterns (such as /myPath/**).
+                				]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:attribute>
+						<xsd:attribute name="allowed-origins" type="xsd:string">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+		Configure allowed {@code Origin} header values. Multiple origins may be specified
+		as a comma-separated list.
+
+		This check is mostly designed for browser clients. There is noting preventing other
+		types of client to modify the Origin header value.
+
+		When SockJS is enabled and allowed origins are restricted, transport types that do not
+		use {@code Origin} headers for cross origin requests (jsonp-polling, iframe-xhr-polling,
+		iframe-eventsource and iframe-htmlfile) are disabled. As a consequence, IE6/IE7 won't be
+		supported anymore and IE8/IE9 will only be supported without cookies.
+
+		By default, all origins are allowed.
+								]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:attribute>
+					</xsd:complexType>
+				</xsd:element>
+				<xsd:element name="stomp-error-handler" minOccurs="0">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+    Configures a StompSubProtocolErrorHandler to customize or handle STOMP ERROR to clients.
+						]]></xsd:documentation>
+					</xsd:annotation>
+					<xsd:complexType>
+						<xsd:attribute name="ref" type="xsd:string" use="required">
+							<xsd:annotation>
+								<xsd:documentation source="java:org.springframework.web.socket.messaging.StompSubProtocolErrorHandler"><![CDATA[
+    The bean name of a StompSubProtocolErrorHandler.
+                ]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:attribute>
+					</xsd:complexType>
+				</xsd:element>
+				<xsd:choice>
+					<xsd:element name="simple-broker" type="simple-broker"/>
+					<xsd:element name="stomp-broker-relay" type="stomp-broker-relay"/>
+				</xsd:choice>
+				<xsd:element name="argument-resolvers" minOccurs="0">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	Configures HandlerMethodArgumentResolver types to support custom controller method argument types.
+	Using this option does not override the built-in support for resolving handler method arguments.
+	To customize the built-in support for argument resolution configure WebSocketAnnotationMethodMessageHandler directly.
+						]]></xsd:documentation>
+					</xsd:annotation>
+					<xsd:complexType>
+						<xsd:choice minOccurs="1" maxOccurs="unbounded">
+							<xsd:element ref="beans:bean" minOccurs="0" maxOccurs="unbounded">
+								<xsd:annotation>
+									<xsd:documentation><![CDATA[
+	The HandlerMethodArgumentResolver (or WebArgumentResolver for backwards compatibility) bean definition.
+									]]></xsd:documentation>
+								</xsd:annotation>
+							</xsd:element>
+							<xsd:element ref="beans:ref" minOccurs="0" maxOccurs="unbounded">
+								<xsd:annotation>
+									<xsd:documentation><![CDATA[
+	A reference to a HandlerMethodArgumentResolver bean definition.
+									]]></xsd:documentation>
+									<xsd:appinfo>
+										<tool:annotation kind="ref">
+											<tool:expected-type type="java:org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolver"/>
+										</tool:annotation>
+									</xsd:appinfo>
+								</xsd:annotation>
+							</xsd:element>
+						</xsd:choice>
+					</xsd:complexType>
+				</xsd:element>
+				<xsd:element name="return-value-handlers" minOccurs="0">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	Configures HandlerMethodReturnValueHandler types to support custom controller method return value handling.
+	Using this option does not override the built-in support for handling return values.
+	To customize the built-in support for handling return values configure WebSocketAnnotationMethodMessageHandler directly.
+						]]></xsd:documentation>
+					</xsd:annotation>
+					<xsd:complexType>
+						<xsd:choice minOccurs="1" maxOccurs="unbounded">
+							<xsd:element ref="beans:bean" minOccurs="0" maxOccurs="unbounded">
+								<xsd:annotation>
+									<xsd:documentation><![CDATA[
+	The HandlerMethodReturnValueHandler bean definition.
+									]]></xsd:documentation>
+								</xsd:annotation>
+							</xsd:element>
+							<xsd:element ref="beans:ref" minOccurs="0" maxOccurs="unbounded">
+								<xsd:annotation>
+									<xsd:documentation><![CDATA[
+	A reference to a HandlerMethodReturnValueHandler bean definition.
+									]]></xsd:documentation>
+									<xsd:appinfo>
+										<tool:annotation kind="ref">
+											<tool:expected-type type="java:org.springframework.messaging.handler.invocation.HandlerMethodReturnValueHandler"/>
+										</tool:annotation>
+									</xsd:appinfo>
+								</xsd:annotation>
+							</xsd:element>
+						</xsd:choice>
+					</xsd:complexType>
+				</xsd:element>
+				<xsd:element name="message-converters" minOccurs="0">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	Configure the message converters to use when extracting the payload of messages in annotated methods
+	and when sending messages (e.g. through the "broker" SimpMessagingTemplate.
+	MessageConverter registrations provided here will take precedence over MessageConverter types registered by default.
+	Also see the register-defaults attribute if you want to turn off default registrations entirely.
+						]]></xsd:documentation>
+					</xsd:annotation>
+					<xsd:complexType>
+						<xsd:sequence>
+							<xsd:choice maxOccurs="unbounded">
+								<xsd:element ref="beans:bean">
+									<xsd:annotation>
+										<xsd:documentation><![CDATA[
+	A MessageConverter bean definition.
+										]]></xsd:documentation>
+									</xsd:annotation>
+								</xsd:element>
+								<xsd:element ref="beans:ref">
+									<xsd:annotation>
+										<xsd:documentation><![CDATA[
+	A reference to an HttpMessageConverter bean.
+										]]></xsd:documentation>
+									</xsd:annotation>
+								</xsd:element>
+							</xsd:choice>
+						</xsd:sequence>
+						<xsd:attribute name="register-defaults" type="xsd:boolean" default="true">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
+	Whether or not default MessageConverter registrations should be added in addition to the ones provided within this element.
+								]]></xsd:documentation>
+							</xsd:annotation>
+						</xsd:attribute>
+					</xsd:complexType>
+				</xsd:element>
+				<xsd:element name="client-inbound-channel" type="channel" minOccurs="0" maxOccurs="1">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	The channel for receiving messages from clients (e.g. WebSocket clients).
+                ]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+				<xsd:element name="client-outbound-channel" type="channel" minOccurs="0" maxOccurs="1">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	The channel for sending messages to clients (e.g. WebSocket clients).
+                ]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+				<xsd:element name="broker-channel" type="channel" minOccurs="0" maxOccurs="1">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+	The channel for sending messages with translated user destinations.
+                ]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+			</xsd:sequence>
+			<xsd:attribute name="application-destination-prefix" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Comma-separated list of prefixes to match to the destinations of handled messages.
+	Messages whose destination does not start with one of the configured prefixes are ignored.
+
+	Prefix is removed from the destination part and then messages are delegated to
+	@SubscribeMapping and @MessageMapping}annotated methods.
+
+	Prefixes without a trailing slash will have one appended automatically.
+	By default the list of prefixes is empty in which case all destinations match.
+                    ]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="user-destination-prefix" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The prefix used to identify user destinations.
+	Any destinations that do not start with the given prefix are not be resolved.
+	The default value is "/user/".
+                    ]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="path-matcher" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	A reference to the PathMatcher to use to match the destinations of incoming
+	messages to @MessageMapping and @SubscribeMapping methods.
+
+	By default AntPathMatcher is configured.
+	However applications may provide an AntPathMatcher instance
+	customized to use "." (commonly used in messaging) instead of "/" as path
+	separator or provide a completely different PathMatcher implementation.
+
+	Note that the configured PathMatcher is only used for matching the
+	portion of the destination after the configured prefix. For example given
+	application destination prefix "/app" and destination "/app/price.stock.**",
+	the message might be mapped to a controller with "price" and "stock.**"
+	as its type and method-level mappings respectively.
+
+	When the simple broker is enabled, the PathMatcher configured here is
+	also used to match message destinations when brokering messages.
+                    ]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="java:org.springframework.util.PathMatcher"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="order" type="xsd:token">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	Order value for this SimpleUrlHandlerMapping.
+	Default value is 1.
+                ]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="path-helper" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+	The bean name of the UrlPathHelper to use for the HandlerMapping used to map handshake requests.
+					]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="validator" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+	The bean name of the Validator instance used for validating @Payload arguments.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+</xsd:schema>

classes/test/spring-aop/log4j2-test.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="WARN">
+	<Appenders>
+		<Console name="Console" target="SYSTEM_OUT">
+			<PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
+		</Console>
+	</Appenders>
+	<Loggers>
+		<Logger name="org.springframework.aop" level="warn" />
+		<Root level="error">
+			<AppenderRef ref="Console" />
+		</Root>
+	</Loggers>
+</Configuration>

classes/test/spring-aop/org/springframework/aop/config/AopNamespaceHandlerEventTests-context.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:aop="http://www.springframework.org/schema/aop"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
+
+	<aop:config>
+		<aop:aspect id="countAgeCalls" ref="countingAdvice">
+			<aop:pointcut id="pc" expression="execution(* getAge())"/>
+			<aop:before pointcut-ref="pc" method="myBeforeAdvice" />
+			<aop:after pointcut-ref="pc" method="myAfterAdvice" />
+			<aop:after-returning pointcut-ref="pc" method="myAfterReturningAdvice" returning="age"/>
+			<aop:after-throwing pointcut-ref="pc" method="myAfterThrowingAdvice" throwing="ex"/>
+			<aop:around pointcut-ref="pc" method="myAroundAdvice"/>
+		</aop:aspect>
+	</aop:config>
+
+	<bean id="getNameCounter" class="org.springframework.aop.framework.CountingBeforeAdvice"/>
+
+	<bean id="getAgeCounter" class="org.springframework.aop.framework.CountingBeforeAdvice"/>
+
+	<bean id="testBean" class="org.springframework.tests.sample.beans.TestBean"/>
+
+	<bean id="countingAdvice" class="org.springframework.aop.config.CountingAspectJAdvice"/>
+
+</beans>

classes/test/spring-aop/org/springframework/aop/config/AopNamespaceHandlerEventTests-directPointcutEvents.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:aop="http://www.springframework.org/schema/aop"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
+
+	<aop:config>
+		<aop:advisor advice-ref="countingAdvice" pointcut="within(org.springframework..*)"/>
+	</aop:config>
+
+	<bean id="countingAdvice" class="org.springframework.aop.framework.CountingBeforeAdvice"/>
+
+</beans>

classes/test/spring-aop/org/springframework/aop/config/AopNamespaceHandlerEventTests-pointcutEvents.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:aop="http://www.springframework.org/schema/aop"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
+
+	<aop:config>
+		<aop:pointcut id="myPointcut" expression="within(org.springframework..*)"/>
+	</aop:config>
+
+</beans>

classes/test/spring-aop/org/springframework/aop/config/AopNamespaceHandlerEventTests-pointcutRefEvents.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:aop="http://www.springframework.org/schema/aop"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
+
+	<aop:config>
+		<aop:pointcut id="pc" expression="within(org.springframework..*)"/>
+		<aop:advisor advice-ref="countingAdvice" pointcut-ref="pc"/>
+	</aop:config>
+
+	<bean id="countingAdvice" class="org.springframework.aop.framework.CountingBeforeAdvice"/>
+
+</beans>

classes/test/spring-aop/org/springframework/aop/config/AopNamespaceHandlerPointcutErrorTests-pointcutDuplication.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:aop="http://www.springframework.org/schema/aop"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
+
+	<aop:config>
+		<aop:aspect id="countAgeCalls" ref="countingAdvice">
+			<aop:pointcut id="pc" expression="execution(* getAge())"/>
+			<aop:before pointcut-ref="pc" pointcut="execution(* getAge())" method="myBeforeAdvice"/>
+		</aop:aspect>
+	</aop:config>
+
+	<bean id="getAgeCounter" class="org.springframework.aop.framework.CountingBeforeAdvice"/>
+
+	<bean id="testBean" class="org.springframework.tests.sample.beans.TestBean"/>
+
+	<bean id="countingAdvice" class="org.springframework.aop.config.CountingAspectJAdvice"/>
+
+</beans>

classes/test/spring-aop/org/springframework/aop/config/AopNamespaceHandlerPointcutErrorTests-pointcutMissing.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:aop="http://www.springframework.org/schema/aop"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
+
+	<aop:config>
+		<aop:aspect id="countAgeCalls" ref="countingAdvice">
+			<aop:pointcut id="pc" expression="execution(* getAge())"/>
+			<aop:before method="myBeforeAdvice" />
+		</aop:aspect>
+	</aop:config>
+
+	<bean id="getAgeCounter" class="org.springframework.aop.framework.CountingBeforeAdvice"/>
+
+	<bean id="testBean" class="org.springframework.tests.sample.beans.TestBean"/>
+
+	<bean id="countingAdvice" class="org.springframework.aop.config.CountingAspectJAdvice"/>
+
+</beans>

classes/test/spring-aop/org/springframework/aop/config/TopLevelAopTagTests-context.xml

@@ -0,0 +1,12 @@
+<config xmlns="http://www.springframework.org/schema/aop"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
+
+	<pointcut id="testPointcut" expression="execution(* foo(..)) and within(springbank.dao.AccountDao+)"/>
+	<pointcut id="testPointcut1" expression="execution(* springbank.dao.AccountDao.foo(..))"/>
+
+	<aspect ref="myAspect">
+		<after method="foo" pointcut-ref="testPointcut"/>
+	</aspect>
+
+</config>

classes/test/spring-aop/org/springframework/aop/framework/PrototypeTargetTests-context.xml

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
+
+<beans>
+
+	<bean id="testBeanTarget" class="org.springframework.aop.framework.PrototypeTargetTests$TestBeanImpl"
+		  scope="prototype"/>
+
+	<bean id="testInterceptor" class="org.springframework.aop.framework.PrototypeTargetTests$TestInterceptor"
+			scope="singleton"/>
+
+	<bean id="testBeanPrototype" class="org.springframework.aop.framework.ProxyFactoryBean">
+		<property name="proxyInterfaces">
+			<value>org.springframework.aop.framework.PrototypeTargetTests$TestBean</value>
+		</property>
+		<property name="singleton">
+			<value>false</value>
+		</property>
+		<property name="interceptorNames">
+			<list>
+				<value>testInterceptor</value>
+				<value>testBeanTarget</value>
+			</list>
+		</property>
+	</bean>
+
+	<bean id="testBeanSingleton" class="org.springframework.aop.framework.ProxyFactoryBean">
+		<property name="proxyInterfaces">
+			<value>org.springframework.aop.framework.PrototypeTargetTests$TestBean</value>
+		</property>
+		<property name="singleton">
+			<value>true</value>
+		</property>
+		<property name="interceptorNames">
+			<list>
+				<value>testInterceptor</value>
+				<value>testBeanTarget</value>
+			</list>
+		</property>
+	</bean>
+
+</beans>

classes/test/spring-aop/org/springframework/aop/interceptor/ExposeInvocationInterceptorTests-context.xml

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
+
+<!--
+	Tests for throws advice.
+-->
+<beans>
+
+	<bean id="nopInterceptor" class="org.springframework.tests.aop.interceptor.NopInterceptor"/>
+
+	<bean id="exposeInvocation" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">
+		<property name="targetClass">
+			<value>org.springframework.aop.interceptor.ExposeInvocationInterceptor</value>
+		</property>
+		<property name="targetField"><value>INSTANCE</value></property>
+	</bean>
+
+	<bean id="countingBeforeAdvice" class="org.springframework.tests.aop.advice.CountingBeforeAdvice"/>
+
+	<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
+		<property name="target">
+			<bean class="org.springframework.aop.interceptor.InvocationCheckExposedInvocationTestBean" />
+		</property>
+		<property name="interceptorNames">
+			<value>exposeInvocation,countingBeforeAdvice,nopInterceptor</value>
+		</property>
+	</bean>
+
+</beans>

classes/test/spring-aop/org/springframework/aop/scope/ScopedProxyAutowireTests-scopedAutowireFalse.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:aop="http://www.springframework.org/schema/aop"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
+			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
+
+	<bean id="scoped" class="org.springframework.aop.scope.ScopedProxyAutowireTests$TestBean" scope="prototype" autowire-candidate="false">
+		<aop:scoped-proxy/>
+	</bean>
+
+	<bean id="unscoped" class="org.springframework.aop.scope.ScopedProxyAutowireTests$TestBean" autowire-candidate="true"/>
+
+	<bean id="autowired" class="org.springframework.aop.scope.ScopedProxyAutowireTests$TestBean" autowire="byType"/>
+
+</beans>

classes/test/spring-aop/org/springframework/aop/scope/ScopedProxyAutowireTests-scopedAutowireTrue.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:aop="http://www.springframework.org/schema/aop"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
+			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
+
+	<bean id="scoped" class="org.springframework.aop.scope.ScopedProxyAutowireTests$TestBean" scope="singleton" autowire-candidate="true">
+		<aop:scoped-proxy/>
+	</bean>
+
+	<bean id="unscoped" class="org.springframework.aop.scope.ScopedProxyAutowireTests$TestBean" autowire-candidate="false"/>
+
+	<bean id="autowired" class="org.springframework.aop.scope.ScopedProxyAutowireTests$TestBean" autowire="byType"/>
+
+</beans>

classes/test/spring-aop/org/springframework/aop/support/RegexpMethodPointcutAdvisorIntegrationTests-context.xml

@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
+
+<beans>
+
+	<!-- Simple target -->
+	<bean id="test" class="org.springframework.tests.sample.beans.TestBean">
+		<property name="name"><value>custom</value></property>
+		<property name="age"><value>666</value></property>
+	</bean>
+
+	<bean id="nopInterceptor" class="org.springframework.tests.aop.interceptor.SerializableNopInterceptor"/>
+
+	<bean id="settersAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
+		<property name="advice"><ref bean="nopInterceptor"/></property>
+		<property name="pattern">
+			<value>
+				.*set.*
+			</value>
+		</property>
+	</bean>
+
+	<bean id="settersAdvised" class="org.springframework.aop.framework.ProxyFactoryBean">
+		<property name="proxyInterfaces"><value>org.springframework.tests.sample.beans.ITestBean</value></property>
+		<property name="target"><ref bean="test"/></property>
+		<property name="interceptorNames"><value>settersAdvisor</value></property>
+	</bean>
+
+	<bean id="serializableSettersAdvised" class="org.springframework.aop.framework.ProxyFactoryBean">
+		<property name="proxyInterfaces"><value>org.springframework.tests.sample.beans.Person</value></property>
+		<property name="target">
+			<bean class="org.springframework.tests.sample.beans.SerializablePerson">
+				<property name="name"><value>serializableSettersAdvised</value></property>
+			</bean>
+		</property>
+		<property name="interceptorNames"><value>settersAdvisor</value></property>
+	</bean>
+
+	<!-- Illustrates use of multiple patterns -->
+	<bean id="settersAndAbsquatulateAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
+		<property name="advice"><ref bean="nopInterceptor"/></property>
+		<property name="patterns">
+			<list>
+				<value>.*get.*</value>
+				<value>.*absquatulate</value>
+			</list>
+		</property>
+	</bean>
+
+	<bean id="settersAndAbsquatulateAdvised" class="org.springframework.aop.framework.ProxyFactoryBean">
+		<property name="proxyInterfaces"><value>org.springframework.tests.sample.beans.ITestBean</value></property>
+		<!-- Force CGLIB so we can cast to TestBean -->
+		<property name="proxyTargetClass"><value>true</value></property>
+		<property name="target"><ref bean="test"/></property>
+		<property name="interceptorNames"><value>settersAndAbsquatulateAdvisor</value></property>
+	</bean>
+
+</beans>

classes/test/spring-aspects/log4j2-test.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="WARN">
+	<Appenders>
+		<Console name="Console" target="SYSTEM_OUT">
+			<PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
+		</Console>
+	</Appenders>
+	<Loggers>
+		<Logger name="org.springframework.beans" level="warn" />
+		<Root level="error">
+			<AppenderRef ref="Console" />
+		</Root>
+	</Loggers>
+</Configuration>

classes/test/spring-aspects/org/springframework/aop/aspectj/autoproxy/ajcAutoproxyTests.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:aop="http://www.springframework.org/schema/aop"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
+
+	<aop:aspectj-autoproxy/>
+
+	<bean id="myAspect" class="org.springframework.aop.aspectj.autoproxy.CodeStyleAspect"
+			factory-method="aspectOf">
+		<property name="foo" value="bar"/>
+	</bean>
+
+	<bean id="otherBean" class="java.lang.Object"/>
+
+</beans>

classes/test/spring-aspects/org/springframework/beans/factory/aspectj/beanConfigurerTests-beans.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
+
+	<bean id="configuredBean" class="org.springframework.beans.factory.aspectj.ShouldBeConfiguredBySpring" lazy-init="true">
+		<property name="name" value="Rod"/>
+	</bean>
+
+</beans>

classes/test/spring-aspects/org/springframework/beans/factory/aspectj/beanConfigurerTests.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:context="http://www.springframework.org/schema/context"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
+
+	<context:spring-configured/>
+
+	<context:annotation-config/>
+
+	<import resource="beanConfigurerTests-beans.xml"/>
+
+</beans>

classes/test/spring-aspects/org/springframework/beans/factory/aspectj/springConfigured.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:aop="http://www.springframework.org/schema/aop"
+		xmlns:context="http://www.springframework.org/schema/context"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
+				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
+
+	<context:spring-configured/>
+
+	<aop:aspectj-autoproxy/>
+
+</beans>

classes/test/spring-aspects/org/springframework/cache/config/annotation-cache-aspectj.xml

@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:cache="http://www.springframework.org/schema/cache"
+	xsi:schemaLocation="
+		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+		http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">
+
+
+	<!--
+	<aop:config>
+		<aop:advisor advice-ref="debugInterceptor" pointcut="execution(* *..CacheableService.*(..))" order="1"/>
+	</aop:config>
+
+	<bean id="cacheAspect" class="org.springframework.cache.aspectj.AnnotationCacheAspect" factory-method="aspectOf">
+		<property name="cacheManager" ref="cacheManager"/>
+		<property name="cacheOperationSources" ref="annotationSource"/>
+	</bean>
+
+	<bean id="annotationSource" class="org.springframework.cache.annotation.AnnotationCacheOperationSource"/>
+	-->
+
+	<cache:annotation-driven mode="aspectj" key-generator="keyGenerator"/>
+
+	<bean id="keyGenerator" class="org.springframework.cache.config.SomeKeyGenerator" />
+
+	<bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
+		<property name="caches">
+			<set>
+				<bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
+					<property name="name" value="testCache"/>
+				</bean>
+				<bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
+					<property name="name" value="primary"/>
+				</bean>
+				<bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
+					<property name="name" value="secondary"/>
+				</bean>
+			</set>
+		</property>
+	</bean>
+
+	<bean id="customKeyGenerator" class="org.springframework.cache.config.SomeCustomKeyGenerator" />
+
+	<bean id="customCacheManager" class="org.springframework.cache.support.SimpleCacheManager">
+		<property name="caches">
+			<set>
+				<bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
+					<property name="name" value="testCache"/>
+				</bean>
+			</set>
+		</property>
+	</bean>
+
+	<bean id="debugInterceptor" class="org.springframework.aop.interceptor.DebugInterceptor"/>
+
+	<bean id="service" class="org.springframework.cache.config.DefaultCacheableService"/>
+	<bean id="classService" class="org.springframework.cache.config.AnnotatedClassCacheableService"/>
+
+</beans>

classes/test/spring-aspects/org/springframework/cache/config/annotation-jcache-aspectj.xml

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	   xmlns:cache="http://www.springframework.org/schema/cache"
+	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+		http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">
+
+	<cache:annotation-driven mode="aspectj"/>
+
+	<bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
+		<property name="caches">
+			<set>
+				<ref bean="defaultCache"/>
+				<bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
+					<property name="name" value="primary"/>
+				</bean>
+				<bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
+					<property name="name" value="secondary"/>
+				</bean>
+				<bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
+					<property name="name" value="exception"/>
+				</bean>
+			</set>
+		</property>
+	</bean>
+
+	<bean id="defaultCache"
+		  class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
+		<property name="name" value="default"/>
+	</bean>
+
+	<bean id="cacheableService" class="org.springframework.cache.config.AnnotatedJCacheableService">
+		<constructor-arg ref="defaultCache"/>
+	</bean>
+
+</beans>