JSR-223 based StandardScriptFactory (including <lang:std> support)

This commit also completes 4.2 schema variants in spring-context.

Issue: SPR-5215

spring-context/src/main/java/org/springframework/scripting/ScriptCompilationException.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2015 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.
@@ -41,8 +41,7 @@ public class ScriptCompilationException extends NestedRuntimeException {
 	/**
 	 * Constructor for ScriptCompilationException.
 	 * @param msg the detail message
-	 * @param cause the root cause (usually from using an underlying
+	 * @param cause the root cause (usually from using an underlying script compiler API)
-	 * script compiler API)
 	 */
 	public ScriptCompilationException(String msg, Throwable cause) {
 		super(msg, cause);
@@ -51,23 +50,32 @@ public class ScriptCompilationException extends NestedRuntimeException {
 	/**
 	 * Constructor for ScriptCompilationException.
 	 * @param scriptSource the source for the offending script
-	 * @param cause the root cause (usually from using an underlying
+	 * @param msg the detail message
-	 * script compiler API)
+	 * @since 4.2
 	 */
-	public ScriptCompilationException(ScriptSource scriptSource, Throwable cause) {
+	public ScriptCompilationException(ScriptSource scriptSource, String msg) {
-		super("Could not compile script", cause);
+		super("Could not compile " + scriptSource + ": " + msg);
 		this.scriptSource = scriptSource;
 	}
 
 	/**
 	 * Constructor for ScriptCompilationException.
-	 * @param msg the detail message
 	 * @param scriptSource the source for the offending script
-	 * @param cause the root cause (usually from using an underlying
+	 * @param cause the root cause (usually from using an underlying script compiler API)
-	 * script compiler API)
+	 */
+	public ScriptCompilationException(ScriptSource scriptSource, Throwable cause) {
+		super("Could not compile " + scriptSource, cause);
+		this.scriptSource = scriptSource;
+	}
+
+	/**
+	 * Constructor for ScriptCompilationException.
+	 * @param scriptSource the source for the offending script
+	 * @param msg the detail message
+	 * @param cause the root cause (usually from using an underlying script compiler API)
 	 */
 	public ScriptCompilationException(ScriptSource scriptSource, String msg, Throwable cause) {
-		super("Could not compile script [" + scriptSource + "]: " + msg, cause);
+		super("Could not compile " + scriptSource + ": " + msg, cause);
 		this.scriptSource = scriptSource;
 	}
 

spring-context/src/main/java/org/springframework/scripting/config/LangNamespaceHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2015 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.
@@ -44,6 +44,7 @@ public class LangNamespaceHandler extends NamespaceHandlerSupport {
 		registerScriptBeanDefinitionParser("groovy", "org.springframework.scripting.groovy.GroovyScriptFactory");
 		registerScriptBeanDefinitionParser("jruby", "org.springframework.scripting.jruby.JRubyScriptFactory");
 		registerScriptBeanDefinitionParser("bsh", "org.springframework.scripting.bsh.BshScriptFactory");
+		registerScriptBeanDefinitionParser("std", "org.springframework.scripting.support.StandardScriptFactory");
 		registerBeanDefinitionParser("defaults", new ScriptingDefaultsParser());
 	}
 

spring-context/src/main/java/org/springframework/scripting/config/ScriptBeanDefinitionParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2015 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.
@@ -55,6 +55,8 @@ import org.springframework.util.xml.DomUtils;
  */
 class ScriptBeanDefinitionParser extends AbstractBeanDefinitionParser {
 
+	private static final String ENGINE_ATTRIBUTE = "engine";
+
 	private static final String SCRIPT_SOURCE_ATTRIBUTE = "script-source";
 
 	private static final String INLINE_SCRIPT_ELEMENT = "inline-script";
@@ -104,6 +106,9 @@ class ScriptBeanDefinitionParser extends AbstractBeanDefinitionParser {
 	@Override
 	@SuppressWarnings("deprecation")
 	protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
+		// Engine attribute only supported for <lang:std>
+		String engine = element.getAttribute(ENGINE_ATTRIBUTE);
+
 		// Resolve the script source.
 		String value = resolveScriptSource(element, parserContext.getReaderContext());
 		if (value == null) {
@@ -184,9 +189,13 @@ class ScriptBeanDefinitionParser extends AbstractBeanDefinitionParser {
 		// Add constructor arguments.
 		ConstructorArgumentValues cav = bd.getConstructorArgumentValues();
 		int constructorArgNum = 0;
+		if (StringUtils.hasLength(engine)) {
+			cav.addIndexedArgumentValue(constructorArgNum++, engine);
+		}
 		cav.addIndexedArgumentValue(constructorArgNum++, value);
 		if (element.hasAttribute(SCRIPT_INTERFACES_ATTRIBUTE)) {
-			cav.addIndexedArgumentValue(constructorArgNum++, element.getAttribute(SCRIPT_INTERFACES_ATTRIBUTE));
+			cav.addIndexedArgumentValue(
+					constructorArgNum++, element.getAttribute(SCRIPT_INTERFACES_ATTRIBUTE), "java.lang.Class[]");
 		}
 
 		// This is used for Groovy. It's a bean reference to a customizer bean.

spring-context/src/main/java/org/springframework/scripting/support/StandardScriptFactory.java

@@ -0,0 +1,248 @@
+/*
+ * Copyright 2002-2015 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.
+ */
+
+package org.springframework.scripting.support;
+
+import java.io.IOException;
+import javax.script.Invocable;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.BeanClassLoaderAware;
+import org.springframework.scripting.ScriptCompilationException;
+import org.springframework.scripting.ScriptFactory;
+import org.springframework.scripting.ScriptSource;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.ObjectUtils;
+import org.springframework.util.StringUtils;
+
+/**
+ * {@link org.springframework.scripting.ScriptFactory} implementation based
+ * on the JSR-223 script engine abstraction (as included in Java 6+).
+ * Supports JavaScript, Groovy, JRuby and other JSR-223 compliant engines.
+ *
+ * <p>Typically used in combination with a
+ * {@link org.springframework.scripting.support.ScriptFactoryPostProcessor};
+ * see the latter's javadoc for a configuration example.
+ *
+ * @author Juergen Hoeller
+ * @since 4.2
+ * @see ScriptFactoryPostProcessor
+ */
+public class StandardScriptFactory implements ScriptFactory, BeanClassLoaderAware {
+
+	private final String scriptEngineName;
+
+	private final String scriptSourceLocator;
+
+	private final Class<?>[] scriptInterfaces;
+
+	private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();
+
+	private volatile ScriptEngine scriptEngine;
+
+
+	/**
+	 * Create a new StandardScriptFactory for the given script source.
+	 * @param scriptSourceLocator a locator that points to the source of the script.
+	 * Interpreted by the post-processor that actually creates the script.
+	 */
+	public StandardScriptFactory(String scriptSourceLocator) {
+		this(null, scriptSourceLocator, (Class<?>[]) null);
+	}
+
+	/**
+	 * Create a new StandardScriptFactory for the given script source.
+	 * @param scriptSourceLocator a locator that points to the source of the script.
+	 * Interpreted by the post-processor that actually creates the script.
+	 * @param scriptInterfaces the Java interfaces that the scripted object
+	 * is supposed to implement
+	 */
+	public StandardScriptFactory(String scriptSourceLocator, Class<?>... scriptInterfaces) {
+		this(null, scriptSourceLocator, scriptInterfaces);
+	}
+
+	/**
+	 * Create a new StandardScriptFactory for the given script source.
+	 * @param scriptEngineName the name of the JSR-223 ScriptEngine to use
+	 * (explicitly given instead of inferred from the script source)
+	 * @param scriptSourceLocator a locator that points to the source of the script.
+	 * Interpreted by the post-processor that actually creates the script.
+	 */
+	public StandardScriptFactory(String scriptEngineName, String scriptSourceLocator) {
+		this(scriptEngineName, scriptSourceLocator, (Class<?>[]) null);
+	}
+
+	/**
+	 * Create a new StandardScriptFactory for the given script source.
+	 * @param scriptEngineName the name of the JSR-223 ScriptEngine to use
+	 * (explicitly given instead of inferred from the script source)
+	 * @param scriptSourceLocator a locator that points to the source of the script.
+	 * Interpreted by the post-processor that actually creates the script.
+	 * @param scriptInterfaces the Java interfaces that the scripted object
+	 * is supposed to implement
+	 */
+	public StandardScriptFactory(String scriptEngineName, String scriptSourceLocator, Class<?>... scriptInterfaces) {
+		Assert.hasText(scriptSourceLocator, "'scriptSourceLocator' must not be empty");
+		this.scriptEngineName = scriptEngineName;
+		this.scriptSourceLocator = scriptSourceLocator;
+		this.scriptInterfaces = scriptInterfaces;
+	}
+
+
+	@Override
+	public void setBeanClassLoader(ClassLoader classLoader) {
+		this.beanClassLoader = classLoader;
+	}
+
+	protected ScriptEngine retrieveScriptEngine(ScriptSource scriptSource) {
+		ScriptEngineManager scriptEngineManager = new ScriptEngineManager(this.beanClassLoader);
+		if (this.scriptEngineName != null) {
+			ScriptEngine engine = scriptEngineManager.getEngineByName(this.scriptEngineName);
+			if (engine == null) {
+				throw new IllegalStateException("Script engine named '" + this.scriptEngineName + "' not found");
+			}
+			return engine;
+		}
+		if (scriptSource instanceof ResourceScriptSource) {
+			String filename = ((ResourceScriptSource) scriptSource).getResource().getFilename();
+			if (filename != null) {
+				String extension = StringUtils.getFilenameExtension(filename);
+				if (extension != null) {
+					ScriptEngine engine = scriptEngineManager.getEngineByExtension(extension);
+					if (engine != null) {
+						return engine;
+					}
+				}
+			}
+		}
+		return null;
+	}
+
+
+	@Override
+	public String getScriptSourceLocator() {
+		return this.scriptSourceLocator;
+	}
+
+	@Override
+	public Class<?>[] getScriptInterfaces() {
+		return this.scriptInterfaces;
+	}
+
+	@Override
+	public boolean requiresConfigInterface() {
+		return false;
+	}
+
+
+	/**
+	 * Load and parse the script via JSR-223's ScriptEngine.
+	 */
+	@Override
+	public Object getScriptedObject(ScriptSource scriptSource, Class<?>... actualInterfaces)
+			throws IOException, ScriptCompilationException {
+
+		Object script;
+
+		try {
+			if (this.scriptEngine == null) {
+				this.scriptEngine = retrieveScriptEngine(scriptSource);
+				if (this.scriptEngine == null) {
+					throw new IllegalStateException("Could not determine script engine for " + scriptSource);
+				}
+			}
+			script = this.scriptEngine.eval(scriptSource.getScriptAsString());
+		}
+		catch (Exception ex) {
+			throw new ScriptCompilationException(scriptSource, ex);
+		}
+
+		if (!ObjectUtils.isEmpty(actualInterfaces)) {
+			boolean adaptationRequired = false;
+			for (Class<?> requestedIfc : actualInterfaces) {
+				if (!requestedIfc.isInstance(script)) {
+					adaptationRequired = true;
+				}
+			}
+			if (adaptationRequired) {
+				Class<?> adaptedIfc;
+				if (actualInterfaces.length == 1) {
+					adaptedIfc = actualInterfaces[0];
+				}
+				else {
+					adaptedIfc = ClassUtils.createCompositeInterface(actualInterfaces, this.beanClassLoader);
+				}
+				if (adaptedIfc != null) {
+					if (!(this.scriptEngine instanceof Invocable)) {
+						throw new ScriptCompilationException(scriptSource,
+								"ScriptEngine must implement Invocable in order to adapt it to an interface: " +
+										this.scriptEngine);
+					}
+					Invocable invocable = (Invocable) this.scriptEngine;
+					if (script != null) {
+						script = invocable.getInterface(script, adaptedIfc);
+					}
+					if (script == null) {
+						script = invocable.getInterface(adaptedIfc);
+						if (script == null) {
+							throw new ScriptCompilationException(scriptSource,
+									"Could not adapt script to interface [" + adaptedIfc.getName() + "]");
+						}
+					}
+				}
+			}
+		}
+
+		if (script instanceof Class) {
+			Class<?> scriptClass = (Class<?>) script;
+			try {
+				return scriptClass.newInstance();
+			}
+			catch (InstantiationException ex) {
+				throw new ScriptCompilationException(
+						scriptSource, "Could not instantiate script class: " + scriptClass.getName(), ex);
+			}
+			catch (IllegalAccessException ex) {
+				throw new ScriptCompilationException(
+						scriptSource, "Could not access script constructor: " + scriptClass.getName(), ex);
+			}
+		}
+
+		return script;
+	}
+
+	@Override
+	public Class<?> getScriptedObjectType(ScriptSource scriptSource)
+			throws IOException, ScriptCompilationException {
+
+		return null;
+	}
+
+	@Override
+	public boolean requiresScriptedObjectRefresh(ScriptSource scriptSource) {
+		return scriptSource.isModified();
+	}
+
+
+	@Override
+	public String toString() {
+		return "StandardScriptFactory: script source locator [" + this.scriptSourceLocator + "]";
+	}
+
+}

spring-context/src/main/resources/META-INF/spring.schemas

@@ -4,7 +4,8 @@ http\://www.springframework.org/schema/context/spring-context-3.1.xsd=org/spring
 http\://www.springframework.org/schema/context/spring-context-3.2.xsd=org/springframework/context/config/spring-context-3.2.xsd
 http\://www.springframework.org/schema/context/spring-context-4.0.xsd=org/springframework/context/config/spring-context-4.0.xsd
 http\://www.springframework.org/schema/context/spring-context-4.1.xsd=org/springframework/context/config/spring-context-4.1.xsd
-http\://www.springframework.org/schema/context/spring-context.xsd=org/springframework/context/config/spring-context-4.1.xsd
+http\://www.springframework.org/schema/context/spring-context-4.2.xsd=org/springframework/context/config/spring-context-4.2.xsd
+http\://www.springframework.org/schema/context/spring-context.xsd=org/springframework/context/config/spring-context-4.2.xsd
 http\://www.springframework.org/schema/jee/spring-jee-2.0.xsd=org/springframework/ejb/config/spring-jee-2.0.xsd
 http\://www.springframework.org/schema/jee/spring-jee-2.5.xsd=org/springframework/ejb/config/spring-jee-2.5.xsd
 http\://www.springframework.org/schema/jee/spring-jee-3.0.xsd=org/springframework/ejb/config/spring-jee-3.0.xsd
@@ -12,7 +13,8 @@ http\://www.springframework.org/schema/jee/spring-jee-3.1.xsd=org/springframewor
 http\://www.springframework.org/schema/jee/spring-jee-3.2.xsd=org/springframework/ejb/config/spring-jee-3.2.xsd
 http\://www.springframework.org/schema/jee/spring-jee-4.0.xsd=org/springframework/ejb/config/spring-jee-4.0.xsd
 http\://www.springframework.org/schema/jee/spring-jee-4.1.xsd=org/springframework/ejb/config/spring-jee-4.1.xsd
-http\://www.springframework.org/schema/jee/spring-jee.xsd=org/springframework/ejb/config/spring-jee-4.1.xsd
+http\://www.springframework.org/schema/jee/spring-jee-4.2.xsd=org/springframework/ejb/config/spring-jee-4.2.xsd
+http\://www.springframework.org/schema/jee/spring-jee.xsd=org/springframework/ejb/config/spring-jee-4.2.xsd
 http\://www.springframework.org/schema/lang/spring-lang-2.0.xsd=org/springframework/scripting/config/spring-lang-2.0.xsd
 http\://www.springframework.org/schema/lang/spring-lang-2.5.xsd=org/springframework/scripting/config/spring-lang-2.5.xsd
 http\://www.springframework.org/schema/lang/spring-lang-3.0.xsd=org/springframework/scripting/config/spring-lang-3.0.xsd
@@ -20,15 +22,18 @@ http\://www.springframework.org/schema/lang/spring-lang-3.1.xsd=org/springframew
 http\://www.springframework.org/schema/lang/spring-lang-3.2.xsd=org/springframework/scripting/config/spring-lang-3.2.xsd
 http\://www.springframework.org/schema/lang/spring-lang-4.0.xsd=org/springframework/scripting/config/spring-lang-4.0.xsd
 http\://www.springframework.org/schema/lang/spring-lang-4.1.xsd=org/springframework/scripting/config/spring-lang-4.1.xsd
-http\://www.springframework.org/schema/lang/spring-lang.xsd=org/springframework/scripting/config/spring-lang-4.1.xsd
+http\://www.springframework.org/schema/lang/spring-lang-4.2.xsd=org/springframework/scripting/config/spring-lang-4.2.xsd
+http\://www.springframework.org/schema/lang/spring-lang.xsd=org/springframework/scripting/config/spring-lang-4.2.xsd
 http\://www.springframework.org/schema/task/spring-task-3.0.xsd=org/springframework/scheduling/config/spring-task-3.0.xsd
 http\://www.springframework.org/schema/task/spring-task-3.1.xsd=org/springframework/scheduling/config/spring-task-3.1.xsd
 http\://www.springframework.org/schema/task/spring-task-3.2.xsd=org/springframework/scheduling/config/spring-task-3.2.xsd
 http\://www.springframework.org/schema/task/spring-task-4.0.xsd=org/springframework/scheduling/config/spring-task-4.0.xsd
 http\://www.springframework.org/schema/task/spring-task-4.1.xsd=org/springframework/scheduling/config/spring-task-4.1.xsd
-http\://www.springframework.org/schema/task/spring-task.xsd=org/springframework/scheduling/config/spring-task-4.1.xsd
+http\://www.springframework.org/schema/task/spring-task-4.2.xsd=org/springframework/scheduling/config/spring-task-4.2.xsd
+http\://www.springframework.org/schema/task/spring-task.xsd=org/springframework/scheduling/config/spring-task-4.2.xsd
 http\://www.springframework.org/schema/cache/spring-cache-3.1.xsd=org/springframework/cache/config/spring-cache-3.1.xsd
 http\://www.springframework.org/schema/cache/spring-cache-3.2.xsd=org/springframework/cache/config/spring-cache-3.2.xsd
 http\://www.springframework.org/schema/cache/spring-cache-4.0.xsd=org/springframework/cache/config/spring-cache-4.0.xsd
 http\://www.springframework.org/schema/cache/spring-cache-4.1.xsd=org/springframework/cache/config/spring-cache-4.1.xsd
-http\://www.springframework.org/schema/cache/spring-cache.xsd=org/springframework/cache/config/spring-cache-4.1.xsd
+http\://www.springframework.org/schema/cache/spring-cache-4.2.xsd=org/springframework/cache/config/spring-cache-4.2.xsd
+http\://www.springframework.org/schema/cache/spring-cache.xsd=org/springframework/cache/config/spring-cache-4.2.xsd

spring-context/src/main/resources/org/springframework/cache/config/spring-cache-4.2.xsd

@@ -0,0 +1,310 @@
+<?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-4.1.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool-4.1.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: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>

spring-context/src/main/resources/org/springframework/context/config/spring-context-4.2.xsd

@@ -0,0 +1,520 @@
+<?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-4.1.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool-4.1.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="propertyPlaceholder">
+		<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, Spring 3.1-based
+	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
+	new PropertySourcesPlaceholderConfigurer.
+
+	See ConfigurableEnvironment javadoc for more information on using.
+			]]></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="propertyPlaceholder">
+					<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
+	Environment/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: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="propertyPlaceholder"/>
+			</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), EJB3'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 EJB3'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.
+	from XML.
+			]]></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, and @Controller 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 definition
+	being registered; Spring's PropertyPlaceholderConfigurer 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.
+							]]></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>

spring-context/src/main/resources/org/springframework/ejb/config/spring-jee-4.2.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-4.1.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool-4.1.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>

spring-context/src/main/resources/org/springframework/scheduling/config/spring-task-4.2.xsd

@@ -0,0 +1,307 @@
+<?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-4.1.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool-4.1.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.
+				]]></xsd:documentation>
+				<xsd:appinfo>
+					<tool:annotation>
+						<tool:expected-method type-ref="@ref"/>
+					</tool:annotation>
+				</xsd:appinfo>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+</xsd:schema>

spring-context/src/main/resources/org/springframework/scripting/config/spring-lang-4.2.xsd

@@ -0,0 +1,255 @@
+<?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-4.2.xsd"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool" schemaLocation="http://www.springframework.org/schema/tool/spring-tool-4.2.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="jruby">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+	A Spring bean backed by a JRuby class definition.
+			]]></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="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>

spring-context/src/test/java/org/springframework/scripting/groovy/GroovyScriptFactoryTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2015 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.
@@ -90,6 +90,35 @@ public class GroovyScriptFactoryTests {
 		assertTrue(ctx.getBeansOfType(Messenger.class).values().contains(messenger));
 	}
 
+	@Test
+	public void testStaticScriptUsingJsr223() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("groovyContextWithJsr223.xml", getClass());
+
+		assertTrue(Arrays.asList(ctx.getBeanNamesForType(Calculator.class)).contains("calculator"));
+		assertTrue(Arrays.asList(ctx.getBeanNamesForType(Messenger.class)).contains("messenger"));
+
+		Calculator calc = (Calculator) ctx.getBean("calculator");
+		Messenger messenger = (Messenger) ctx.getBean("messenger");
+
+		assertFalse("Shouldn't get proxy when refresh is disabled", AopUtils.isAopProxy(calc));
+		assertFalse("Shouldn't get proxy when refresh is disabled", AopUtils.isAopProxy(messenger));
+
+		assertFalse("Scripted object should not be instance of Refreshable", calc instanceof Refreshable);
+		assertFalse("Scripted object should not be instance of Refreshable", messenger instanceof Refreshable);
+
+		assertEquals(calc, calc);
+		assertEquals(messenger, messenger);
+		assertTrue(!messenger.equals(calc));
+		assertTrue(messenger.hashCode() != calc.hashCode());
+		assertTrue(!messenger.toString().equals(calc.toString()));
+
+		String desiredMessage = "Hello World!";
+		assertEquals("Message is incorrect", desiredMessage, messenger.getMessage());
+
+		assertTrue(ctx.getBeansOfType(Calculator.class).values().contains(calc));
+		assertTrue(ctx.getBeansOfType(Messenger.class).values().contains(messenger));
+	}
+
 	@Test
 	public void testStaticPrototypeScript() throws Exception {
 		ApplicationContext ctx = new ClassPathXmlApplicationContext("groovyContext.xml", getClass());
@@ -109,6 +138,25 @@ public class GroovyScriptFactoryTests {
 		assertEquals("Byebye World!", messenger2.getMessage());
 	}
 
+	@Test
+	public void testStaticPrototypeScriptUsingJsr223() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("groovyContextWithJsr223.xml", getClass());
+		ConfigurableMessenger messenger = (ConfigurableMessenger) ctx.getBean("messengerPrototype");
+		ConfigurableMessenger messenger2 = (ConfigurableMessenger) ctx.getBean("messengerPrototype");
+
+		assertFalse("Shouldn't get proxy when refresh is disabled", AopUtils.isAopProxy(messenger));
+		assertFalse("Scripted object should not be instance of Refreshable", messenger instanceof Refreshable);
+
+		assertNotSame(messenger, messenger2);
+		assertSame(messenger.getClass(), messenger2.getClass());
+		assertEquals("Hello World!", messenger.getMessage());
+		assertEquals("Hello World!", messenger2.getMessage());
+		messenger.setMessage("Bye World!");
+		messenger2.setMessage("Byebye World!");
+		assertEquals("Bye World!", messenger.getMessage());
+		assertEquals("Byebye World!", messenger2.getMessage());
+	}
+
 	@Test
 	public void testStaticScriptWithInstance() throws Exception {
 		ApplicationContext ctx = new ClassPathXmlApplicationContext("groovyContext.xml", getClass());
@@ -123,6 +171,20 @@ public class GroovyScriptFactoryTests {
 		assertTrue(ctx.getBeansOfType(Messenger.class).values().contains(messenger));
 	}
 
+	@Test
+	public void testStaticScriptWithInstanceUsingJsr223() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("groovyContextWithJsr223.xml", getClass());
+		assertTrue(Arrays.asList(ctx.getBeanNamesForType(Messenger.class)).contains("messengerInstance"));
+		Messenger messenger = (Messenger) ctx.getBean("messengerInstance");
+
+		assertFalse("Shouldn't get proxy when refresh is disabled", AopUtils.isAopProxy(messenger));
+		assertFalse("Scripted object should not be instance of Refreshable", messenger instanceof Refreshable);
+
+		String desiredMessage = "Hello World!";
+		assertEquals("Message is incorrect", desiredMessage, messenger.getMessage());
+		assertTrue(ctx.getBeansOfType(Messenger.class).values().contains(messenger));
+	}
+
 	@Test
 	public void testStaticScriptWithInlineDefinedInstance() throws Exception {
 		ApplicationContext ctx = new ClassPathXmlApplicationContext("groovyContext.xml", getClass());
@@ -137,6 +199,20 @@ public class GroovyScriptFactoryTests {
 		assertTrue(ctx.getBeansOfType(Messenger.class).values().contains(messenger));
 	}
 
+	@Test
+	public void testStaticScriptWithInlineDefinedInstanceUsingJsr223() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("groovyContextWithJsr223.xml", getClass());
+		assertTrue(Arrays.asList(ctx.getBeanNamesForType(Messenger.class)).contains("messengerInstanceInline"));
+		Messenger messenger = (Messenger) ctx.getBean("messengerInstanceInline");
+
+		assertFalse("Shouldn't get proxy when refresh is disabled", AopUtils.isAopProxy(messenger));
+		assertFalse("Scripted object should not be instance of Refreshable", messenger instanceof Refreshable);
+
+		String desiredMessage = "Hello World!";
+		assertEquals("Message is incorrect", desiredMessage, messenger.getMessage());
+		assertTrue(ctx.getBeansOfType(Messenger.class).values().contains(messenger));
+	}
+
 	@Test
 	public void testNonStaticScript() throws Exception {
 		ApplicationContext ctx = new ClassPathXmlApplicationContext("groovyRefreshableContext.xml", getClass());
@@ -311,8 +387,6 @@ public class GroovyScriptFactoryTests {
 		}
 	}
 
-	@Ignore
-	// see http://build.springframework.org/browse/SPR-TRUNKQUICK-908
 	@Test
 	public void testResourceScriptFromTag() throws Exception {
 		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("groovy-with-xsd.xml", getClass());
@@ -409,6 +483,49 @@ public class GroovyScriptFactoryTests {
 		assertEquals(4, beans.size());
 	}
 
+	@Test
+	public void testJsr223FromTag() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("groovy-with-xsd-jsr223.xml", getClass());
+		assertTrue(Arrays.asList(ctx.getBeanNamesForType(Messenger.class)).contains("messenger"));
+		Messenger messenger = (Messenger) ctx.getBean("messenger");
+		assertFalse(AopUtils.isAopProxy(messenger));
+		assertEquals("Hello World!", messenger.getMessage());
+	}
+
+	@Test
+	public void testJsr223FromTagWithInterface() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("groovy-with-xsd-jsr223.xml", getClass());
+		assertTrue(Arrays.asList(ctx.getBeanNamesForType(Messenger.class)).contains("messengerWithInterface"));
+		Messenger messenger = (Messenger) ctx.getBean("messengerWithInterface");
+		assertFalse(AopUtils.isAopProxy(messenger));
+	}
+
+	@Test
+	public void testRefreshableJsr223FromTag() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("groovy-with-xsd-jsr223.xml", getClass());
+		assertTrue(Arrays.asList(ctx.getBeanNamesForType(Messenger.class)).contains("refreshableMessenger"));
+		Messenger messenger = (Messenger) ctx.getBean("refreshableMessenger");
+		assertTrue(AopUtils.isAopProxy(messenger));
+		assertTrue(messenger instanceof Refreshable);
+		assertEquals("Hello World!", messenger.getMessage());
+	}
+
+	@Test
+	public void testInlineJsr223FromTag() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("groovy-with-xsd-jsr223.xml", getClass());
+		assertTrue(Arrays.asList(ctx.getBeanNamesForType(Messenger.class)).contains("inlineMessenger"));
+		Messenger messenger = (Messenger) ctx.getBean("inlineMessenger");
+		assertFalse(AopUtils.isAopProxy(messenger));
+	}
+
+	@Test
+	public void testInlineJsr223FromTagWithInterface() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("groovy-with-xsd-jsr223.xml", getClass());
+		assertTrue(Arrays.asList(ctx.getBeanNamesForType(Messenger.class)).contains("inlineMessengerWithInterface"));
+		Messenger messenger = (Messenger) ctx.getBean("inlineMessengerWithInterface");
+		assertFalse(AopUtils.isAopProxy(messenger));
+	}
+
 	/**
 	 * Tests the SPR-2098 bug whereby no more than 1 property element could be
 	 * passed to a scripted bean :(

spring-context/src/test/java/org/springframework/scripting/jruby/JRubyScriptFactoryTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2015 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.
@@ -64,6 +64,27 @@ public class JRubyScriptFactoryTests {
 		assertNotSame(messenger.hashCode(), calc.hashCode());
 		assertTrue(!messenger.toString().equals(calc.toString()));
 
+		assertEquals(3, calc.add(1, 2));
+		String desiredMessage = "Hello World!";
+		assertEquals("Message is incorrect", desiredMessage, messenger.getMessage());
+	}
+
+	@Test
+	public void testStaticScriptUsingJsr223() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("jrubyContextWithJsr223.xml", getClass());
+		Calculator calc = (Calculator) ctx.getBean("calculator");
+		Messenger messenger = (Messenger) ctx.getBean("messenger");
+
+		assertFalse("Scripted object should not be instance of Refreshable", calc instanceof Refreshable);
+		assertFalse("Scripted object should not be instance of Refreshable", messenger instanceof Refreshable);
+
+		assertEquals(calc, calc);
+		assertEquals(messenger, messenger);
+		assertTrue(!messenger.equals(calc));
+		assertNotSame(messenger.hashCode(), calc.hashCode());
+		assertTrue(!messenger.toString().equals(calc.toString()));
+
+		assertEquals(3, calc.add(1, 2));
 		String desiredMessage = "Hello World!";
 		assertEquals("Message is incorrect", desiredMessage, messenger.getMessage());
 	}
@@ -163,6 +184,15 @@ public class JRubyScriptFactoryTests {
 		assertEquals(testBean, messengerByName.getTestBean());
 	}
 
+	@Test
+	public void testResourceScriptFromTagUsingJsr223() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("jruby-with-xsd-jsr223.xml", getClass());
+
+		Messenger messenger = (Messenger) ctx.getBean("messenger");
+		assertEquals("Hello World!", messenger.getMessage());
+		assertFalse(messenger instanceof Refreshable);
+	}
+
 	@Test
 	public void testPrototypeScriptFromTag() throws Exception {
 		ApplicationContext ctx = new ClassPathXmlApplicationContext("jruby-with-xsd.xml", getClass());
@@ -185,6 +215,16 @@ public class JRubyScriptFactoryTests {
 		Calculator calculator = (Calculator) ctx.getBean("calculator");
 		assertNotNull(calculator);
 		assertFalse(calculator instanceof Refreshable);
+		assertEquals(3, calculator.add(1, 2));
+	}
+
+	@Test
+	public void testInlineScriptFromTagUsingJsr223() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("jruby-with-xsd-jsr223.xml", getClass());
+		Calculator calculator = (Calculator) ctx.getBean("calculator");
+		assertNotNull(calculator);
+		assertFalse(calculator instanceof Refreshable);
+		assertEquals(3, calculator.add(1, 2));
 	}
 
 	@Test
@@ -195,6 +235,15 @@ public class JRubyScriptFactoryTests {
 		assertTrue("Messenger should be Refreshable", messenger instanceof Refreshable);
 	}
 
+	@Test
+	public void testRefreshableFromTagUsingJsr223() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("jruby-with-xsd-jsr223.xml", getClass());
+		Messenger messenger = (Messenger) ctx.getBean("refreshableMessenger");
+		assertEquals("Hello World!", messenger.getMessage());
+		assertTrue("Messenger should be Refreshable", messenger instanceof Refreshable);
+	}
+
+	@Test
 	public void testThatMultipleScriptInterfacesAreSupported() throws Exception {
 		ApplicationContext ctx = new ClassPathXmlApplicationContext("jruby-with-xsd.xml", getClass());
 		Messenger messenger = (Messenger) ctx.getBean("calculatingMessenger");
@@ -214,6 +263,15 @@ public class JRubyScriptFactoryTests {
 		assertEquals(1, printable.count);
 	}
 
+	@Test
+	public void testWithComplexArgUsingJsr223() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("jrubyContextWithJsr223.xml", getClass());
+		Printer printer = (Printer) ctx.getBean("printer");
+		CountingPrintable printable = new CountingPrintable();
+		printer.print(printable);
+		assertEquals(1, printable.count);
+	}
+
 	@Test
 	public void testWithPrimitiveArgsInReturnTypeAndParameters() throws Exception {
 		ApplicationContext ctx = new ClassPathXmlApplicationContext("jrubyContextForPrimitives.xml", getClass());

spring-context/src/test/java/org/springframework/scripting/support/StandardScriptFactoryTests.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2002-2015 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.
+ */
+
+package org.springframework.scripting.support;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+
+import org.springframework.aop.support.AopUtils;
+import org.springframework.aop.target.dynamic.Refreshable;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+import org.springframework.scripting.Messenger;
+
+import static org.junit.Assert.*;
+
+/**
+ * {@link StandardScriptFactory} (lang:std) tests for JavaScript.
+ *
+ * @author Juergen Hoeller
+ * @since 4.2
+ */
+public class StandardScriptFactoryTests {
+
+	@Test
+	public void testJsr223FromTagWithInterface() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("jsr223-with-xsd.xml", getClass());
+		assertTrue(Arrays.asList(ctx.getBeanNamesForType(Messenger.class)).contains("messengerWithInterface"));
+		Messenger messenger = (Messenger) ctx.getBean("messengerWithInterface");
+		assertFalse(AopUtils.isAopProxy(messenger));
+		assertEquals("Hello World!", messenger.getMessage());
+	}
+
+	@Test
+	public void testRefreshableJsr223FromTagWithInterface() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("jsr223-with-xsd.xml", getClass());
+		assertTrue(Arrays.asList(ctx.getBeanNamesForType(Messenger.class)).contains("refreshableMessengerWithInterface"));
+		Messenger messenger = (Messenger) ctx.getBean("refreshableMessengerWithInterface");
+		assertTrue(AopUtils.isAopProxy(messenger));
+		assertTrue(messenger instanceof Refreshable);
+		assertEquals("Hello World!", messenger.getMessage());
+	}
+
+	@Test
+	public void testInlineJsr223FromTagWithInterface() throws Exception {
+		ApplicationContext ctx = new ClassPathXmlApplicationContext("jsr223-with-xsd.xml", getClass());
+		assertTrue(Arrays.asList(ctx.getBeanNamesForType(Messenger.class)).contains("inlineMessengerWithInterface"));
+		Messenger messenger = (Messenger) ctx.getBean("inlineMessengerWithInterface");
+		assertFalse(AopUtils.isAopProxy(messenger));
+		assertEquals("Hello World!", messenger.getMessage());
+	}
+
+}

spring-context/src/test/resources/org/springframework/scripting/groovy/groovy-with-xsd-jsr223.xml

@@ -0,0 +1,42 @@
+<?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:lang="http://www.springframework.org/schema/lang"
+	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-4.2.xsd">
+
+	<lang:std id="messenger" script-source="classpath:org/springframework/scripting/groovy/Messenger.groovy">
+		<lang:property name="message" value="Hello World!"/>
+	</lang:std>
+
+	<lang:std id="messengerWithInterface" script-source="classpath:org/springframework/scripting/groovy/Messenger.groovy"
+			  script-interfaces="org.springframework.scripting.Messenger"/>
+
+	<lang:std id="refreshableMessenger" refresh-check-delay="5000"
+			script-source="classpath:org/springframework/scripting/groovy/Messenger.groovy">
+		<lang:property name="message" value="Hello World!"/>
+	</lang:std>
+
+	<lang:std id="inlineMessenger" engine="Groovy">
+		<lang:inline-script>
+			package org.springframework.scripting.groovy;
+			import org.springframework.scripting.Messenger
+			class GroovyMessenger implements Messenger {
+				def String message;
+			}
+			return new GroovyMessenger();
+		</lang:inline-script>
+	</lang:std>
+
+	<lang:std id="inlineMessengerWithInterface" engine="Groovy" script-interfaces="org.springframework.scripting.Messenger">
+		<lang:inline-script>
+			package org.springframework.scripting.groovy;
+			import org.springframework.scripting.Messenger
+			class GroovyMessenger implements Messenger {
+			def String message;
+			}
+			return new GroovyMessenger();
+		</lang:inline-script>
+	</lang:std>
+
+</beans>

spring-context/src/test/resources/org/springframework/scripting/groovy/groovy-with-xsd-proxy-target-class.xml

@@ -3,12 +3,11 @@
 	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	   xmlns:lang="http://www.springframework.org/schema/lang"
 	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
-
 				http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-3.1.xsd">
 
 	<lang:groovy id="refreshableMessenger" refresh-check-delay="5000" proxy-target-class="true"
-		script-source="classpath:org/springframework/scripting/groovy/Messenger.groovy">
+			script-source="classpath:org/springframework/scripting/groovy/Messenger.groovy">
-		<lang:property name="message" value="Hello World!" />
+		<lang:property name="message" value="Hello World!"/>
 	</lang:groovy>
 
 </beans>

spring-context/src/test/resources/org/springframework/scripting/groovy/groovy-with-xsd.xml

@@ -33,7 +33,7 @@ class GroovyCalculator implements Calculator {
 	   return x + y;
 	}
 }
-		 </lang:inline-script>
+		</lang:inline-script>
 	</lang:groovy>
 
 	<lang:groovy id="customizer">

spring-context/src/test/resources/org/springframework/scripting/groovy/groovyContext.xml

@@ -10,8 +10,7 @@
 
 	<bean class="org.springframework.scripting.support.ScriptFactoryPostProcessor"/>
 
-	<bean id="calculator"
+	<bean id="calculator" class="org.springframework.scripting.groovy.GroovyScriptFactory">
-		  class="org.springframework.scripting.groovy.GroovyScriptFactory">
 		<constructor-arg>
 			<value>inline:
 package org.springframework.scripting.groovy;
@@ -25,28 +24,24 @@ class GroovyCalculator implements Calculator {
 		</constructor-arg>
 	</bean>
 
-	<bean id="messenger"
+	<bean id="messenger" class="org.springframework.scripting.groovy.GroovyScriptFactory">
-		  class="org.springframework.scripting.groovy.GroovyScriptFactory">
 		<constructor-arg value="classpath:org/springframework/scripting/groovy/Messenger.groovy"/>
 		<property name="message" value="Hello World!"/>
 	</bean>
 
-	<bean id="messengerPrototype"
+	<bean id="messengerPrototype" class="org.springframework.scripting.groovy.GroovyScriptFactory"
-		  class="org.springframework.scripting.groovy.GroovyScriptFactory"
 		  scope="prototype">
 		<constructor-arg value="classpath:org/springframework/scripting/groovy/Messenger.groovy"/>
 		<property name="message" value="Hello World!"/>
 	</bean>
 
-	<bean id="messengerInstance"
+	<bean id="messengerInstance" class="org.springframework.scripting.groovy.GroovyScriptFactory">
-		  class="org.springframework.scripting.groovy.GroovyScriptFactory">
 		<constructor-arg value="classpath:org/springframework/scripting/groovy/MessengerInstance.groovy"/>
 		<property name="message" ref="myMessage"/>
 	</bean>
 
-  <bean id="messengerInstanceInline"
+  <bean id="messengerInstanceInline" class="org.springframework.scripting.groovy.GroovyScriptFactory">
-      class="org.springframework.scripting.groovy.GroovyScriptFactory">
+	  <constructor-arg>
-    <constructor-arg>
       <value>inline:
 package org.springframework.scripting.groovy;
 import org.springframework.scripting.Messenger

spring-context/src/test/resources/org/springframework/scripting/groovy/groovyContextWithJsr223.xml

@@ -0,0 +1,61 @@
+<?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:lang="http://www.springframework.org/schema/lang"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans
+				http://www.springframework.org/schema/beans/spring-beans.xsd"
+ 		default-lazy-init="true">
+
+	<bean class="org.springframework.scripting.support.ScriptFactoryPostProcessor"/>
+
+	<bean id="calculator" class="org.springframework.scripting.support.StandardScriptFactory">
+		<constructor-arg value="Groovy"/>
+		<constructor-arg>
+			<value>inline:
+package org.springframework.scripting.groovy;
+import org.springframework.scripting.Calculator
+class GroovyCalculator implements Calculator {
+	int add(int x, int y) {
+	   return x + y;
+	}
+}
+			</value>
+		</constructor-arg>
+	</bean>
+
+	<bean id="messenger" class="org.springframework.scripting.support.StandardScriptFactory">
+		<constructor-arg value="classpath:org/springframework/scripting/groovy/Messenger.groovy"/>
+		<property name="message" value="Hello World!"/>
+	</bean>
+
+	<bean id="messengerPrototype" class="org.springframework.scripting.support.StandardScriptFactory"
+		  scope="prototype">
+		<constructor-arg value="classpath:org/springframework/scripting/groovy/Messenger.groovy"/>
+		<property name="message" value="Hello World!"/>
+	</bean>
+
+	<bean id="messengerInstance" class="org.springframework.scripting.support.StandardScriptFactory">
+		<constructor-arg value="classpath:org/springframework/scripting/groovy/MessengerInstance.groovy"/>
+		<property name="message" ref="myMessage"/>
+	</bean>
+
+  <bean id="messengerInstanceInline" class="org.springframework.scripting.support.StandardScriptFactory">
+	  <constructor-arg value="Groovy"/>
+	  <constructor-arg>
+      <value>inline:
+package org.springframework.scripting.groovy;
+import org.springframework.scripting.Messenger
+class GroovyMessenger implements Messenger {
+  def String message;
+}
+return new GroovyMessenger();
+      </value>
+    </constructor-arg>
+    <property name="message" ref="myMessage"/>
+  </bean>
+
+	<bean id="myMessage" class="java.lang.String">
+		<constructor-arg value="Hello World!"/>
+	</bean>
+
+</beans>

spring-context/src/test/resources/org/springframework/scripting/jruby/MessengerWithInstance.rb

@@ -0,0 +1,25 @@
+require 'java'
+
+class RubyMessenger
+	include org.springframework.scripting.ConfigurableMessenger
+
+	@@message = "Hello World!"
+
+	def setMessage(message)
+		@@message = message
+	end
+
+	def getMessage
+		@@message
+	end
+
+	def setTestBean(testBean)
+		@@testBean = testBean
+	end
+
+	def getTestBean
+		@@testBean
+	end
+end
+
+RubyMessenger.new

spring-context/src/test/resources/org/springframework/scripting/jruby/PrinterWithInstance.rb

@@ -0,0 +1,11 @@
+require 'java'
+
+class RubyPrinter
+	include org.springframework.scripting.jruby.Printer
+
+	def print(obj)
+		puts obj.getContent
+	end
+end
+
+RubyPrinter.new

spring-context/src/test/resources/org/springframework/scripting/jruby/jruby-with-xsd-jsr223.xml

@@ -0,0 +1,32 @@
+<?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:lang="http://www.springframework.org/schema/lang"
+	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
+				http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-4.2.xsd">
+
+	<lang:std id="messenger"
+			  script-source="classpath:org/springframework/scripting/jruby/MessengerWithInstance.rb">
+	</lang:std>
+
+	<lang:std id="calculator" engine="jruby">
+		<lang:inline-script>
+			require 'java'
+
+			class RubyCalculator
+			include org.springframework.scripting.Calculator
+
+			def add(x, y)
+			x + y
+			end
+			end
+
+			RubyCalculator.new
+		</lang:inline-script>
+	</lang:std>
+
+	<lang:std id="refreshableMessenger"
+			  script-source="classpath:org/springframework/scripting/jruby/MessengerWithInstance.rb"
+			  refresh-check-delay="5000">
+	</lang:std>
+
+</beans>

spring-context/src/test/resources/org/springframework/scripting/jruby/jrubyContextWithJsr223.xml

@@ -0,0 +1,40 @@
+<?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 class="org.springframework.scripting.support.ScriptFactoryPostProcessor"/>
+
+	<bean id="calculator" class="org.springframework.scripting.support.StandardScriptFactory">
+		<constructor-arg value="jruby"/>
+		<constructor-arg>
+			<value>inline:
+require 'java'
+
+class RubyCalculator
+	include org.springframework.scripting.Calculator
+
+	def add(x, y)
+		x + y
+	end
+end
+
+RubyCalculator.new
+			</value>
+		</constructor-arg>
+		<constructor-arg value="org.springframework.scripting.Calculator"/>
+	</bean>
+
+	<bean id="messenger" class="org.springframework.scripting.support.StandardScriptFactory">
+		<constructor-arg value="jruby"/>
+		<constructor-arg value="classpath:org/springframework/scripting/jruby/MessengerWithInstance.rb"/>
+		<constructor-arg value="org.springframework.scripting.Messenger"/>
+	</bean>
+
+	<bean id="printer" class="org.springframework.scripting.support.StandardScriptFactory">
+		<constructor-arg value="jruby"/>
+		<constructor-arg value="classpath:org/springframework/scripting/jruby/PrinterWithInstance.rb"/>
+		<constructor-arg value="org.springframework.scripting.jruby.Printer"/>
+	</bean>
+
+</beans>

spring-context/src/test/resources/org/springframework/scripting/support/Messenger.js

@@ -0,0 +1 @@
+function getMessage() { return "Hello World!" }

spring-context/src/test/resources/org/springframework/scripting/support/jsr223-with-xsd.xml

@@ -0,0 +1,23 @@
+<?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:lang="http://www.springframework.org/schema/lang"
+	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-4.2.xsd">
+
+	<lang:std id="messengerWithInterface" script-source="classpath:org/springframework/scripting/support/Messenger.js"
+			  script-interfaces="org.springframework.scripting.Messenger"/>
+
+	<lang:std id="refreshableMessengerWithInterface" refresh-check-delay="5000"
+			  script-source="classpath:org/springframework/scripting/support/Messenger.js"
+			  script-interfaces="org.springframework.scripting.Messenger">
+	</lang:std>
+
+	<lang:std id="inlineMessengerWithInterface" engine="JavaScript"
+			  script-interfaces="org.springframework.scripting.Messenger">
+		<lang:inline-script>
+			function getMessage() { return "Hello World!" }
+		</lang:inline-script>
+	</lang:std>
+
+</beans>