Denial of Service in Spring Framework

@@ -14,40 +14,35 @@ a number of Java EE (and related) technologies.
  
  
  
- 
 [[remoting]]
-== Remoting and web services using Spring
- 
- 
- 
-[[remoting-introduction]]
-=== Introduction
+== Remoting and Web Services with Spring
  
-Spring features integration classes for remoting support using various technologies. The
+Spring features integration classes for remoting support with various technologies. The
 remoting support eases the development of remote-enabled services, implemented by your
 usual (Spring) POJOs. Currently, Spring supports the following remoting technologies:
  
-* __Remote Method Invocation (RMI)__. Through the use of the `RmiProxyFactoryBean` and
-  the `RmiServiceExporter` Spring supports both traditional RMI (with `java.rmi.Remote`
-  interfaces and `java.rmi.RemoteException`) and transparent remoting via RMI invokers
+* *Remote Method Invocation (RMI)*: Through the use of  `RmiProxyFactoryBean` and
+  `RmiServiceExporter`, Spring supports both traditional RMI (with `java.rmi.Remote`
+  interfaces and `java.rmi.RemoteException`) and transparent remoting through RMI invokers
   (with any Java interface).
-* __Spring's HTTP invoker__. Spring provides a special remoting strategy which allows
-  for Java serialization via HTTP, supporting any Java interface (just like the RMI
-  invoker). The corresponding support classes are `HttpInvokerProxyFactoryBean` and
+* *Spring's HTTP invoker*: Spring provides a special remoting strategy that allows
+  for Java serialization though HTTP, supporting any Java interface (as the RMI
+  invoker does). The corresponding support classes are `HttpInvokerProxyFactoryBean` and
   `HttpInvokerServiceExporter`.
-* __Hessian__. By using Spring's `HessianProxyFactoryBean` and the
-  `HessianServiceExporter` you can transparently expose your services using the
+* *Hessian*: By using Spring's `HessianProxyFactoryBean` and the
+  `HessianServiceExporter`, you can transparently expose your services through the
   lightweight binary HTTP-based protocol provided by Caucho.
-* __JAX-WS__. Spring provides remoting support for web services via JAX-WS (the
+* *JAX-WS*: Spring provides remoting support for web services through JAX-WS (the
   successor of JAX-RPC, as introduced in Java EE 5 and Java 6).
-* __JMS__. Remoting using JMS as the underlying protocol is supported via the
+* *JMS*: Remoting by using JMS as the underlying protocol is supported through the
   `JmsInvokerServiceExporter` and `JmsInvokerProxyFactoryBean` classes.
-* __AMQP__. Remoting using AMQP as the underlying protocol is supported by the Spring
+* *AMQP*: Remoting by using AMQP as the underlying protocol is supported by the Spring
   AMQP project.
  
-While discussing the remoting capabilities of Spring, we'll use the following domain
+While discussing the remoting capabilities of Spring, we use the following domain
 model and corresponding services:
  
+====
 [source,java,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -94,34 +89,38 @@ model and corresponding services:
  
 	}
 ----
+====
  
-We will start exposing the service to a remote client by using RMI and talk a bit about
-the drawbacks of using RMI. We'll then continue to show an example using Hessian as the
+This section starts by exposing the service to a remote client by using RMI and talk a bit about
+the drawbacks of using RMI. It then continues with an example that uses Hessian as the
 protocol.
  
  
  
 [[remoting-rmi]]
-=== Exposing services using RMI
+=== Exposing Services by Using RMI
  
-Using Spring's support for RMI, you can transparently expose your services through the
+By using Spring's support for RMI, you can transparently expose your services through the
 RMI infrastructure. After having this set up, you basically have a configuration similar
 to remote EJBs, except for the fact that there is no standard support for security
 context propagation or remote transaction propagation. Spring does provide hooks for
-such additional invocation context when using the RMI invoker, so you can for example
-plug in security frameworks or custom security credentials here.
+such additional invocation context when you use the RMI invoker, so you can, for example,
+plug in security frameworks or custom security credentials.
+ 
  
  
 [[remoting-rmi-server]]
-==== Exporting the service using the RmiServiceExporter
+==== Exporting the Service by Using `RmiServiceExporter`
  
 Using the `RmiServiceExporter`, we can expose the interface of our AccountService object
 as RMI object. The interface can be accessed by using `RmiProxyFactoryBean`, or via
 plain RMI in case of a traditional RMI service. The `RmiServiceExporter` explicitly
 supports the exposing of any non-RMI services via RMI invokers.
  
-Of course, we first have to set up our service in the Spring container:
+We first have to set up our service in the Spring container.
+The following example shows how to do so:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -129,9 +128,12 @@ Of course, we first have to set up our service in the Spring container:
 		<!-- any additional properties, maybe a DAO? -->
 	</bean>
 ----
+====
  
-Next we'll have to expose our service using the `RmiServiceExporter`:
+Next, we have to expose our service by using `RmiServiceExporter`.
+The following example shows how to do so:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -144,25 +146,26 @@ Next we'll have to expose our service using the `RmiServiceExporter`:
 		<property name="registryPort" value="1199"/>
 	</bean>
 ----
+====
  
-As you can see, we're overriding the port for the RMI registry. Often, your application
-server also maintains an RMI registry and it is wise to not interfere with that one.
-Furthermore, the service name is used to bind the service under. So right now, the
-service will be bound at `'rmi://HOST:1199/AccountService'`. We'll use the URL later on
+In the preceding example, we override the port for the RMI registry. Often, your application
+server also maintains an RMI registry, and it is wise to not interfere with that one.
+Furthermore, the service name is used to bind the service. So, in the preceding example, the
+service is bound at `'rmi://HOST:1199/AccountService'`. We use this URL later on
 to link in the service at the client side.
  
-[NOTE]
-====
-The `servicePort` property has been omitted (it defaults to 0). This means that an
-anonymous port will be used to communicate with the service.
-====
+NOTE: The `servicePort` property has been omitted (it defaults to 0). This means that an
+anonymous port is used to communicate with the service.
+ 
  
  
 [[remoting-rmi-client]]
-==== Linking in the service at the client
+==== Linking in the Service at the Client
  
-Our client is a simple object using the `AccountService` to manage accounts:
+Our client is a simple object that uses the `AccountService` to manage accounts,
+as the following example shows:
  
+====
 [source,java,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -178,10 +181,12 @@ Our client is a simple object using the `AccountService` to manage accounts:
  
 	}
 ----
+====
  
-To link in the service on the client, we'll create a separate Spring container,
-containing the simple object and the service linking configuration bits:
+To link in the service on the client, we create a separate Spring container,
+to contain the following simple object and the service linking configuration bits:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -194,28 +199,31 @@ containing the simple object and the service linking configuration bits:
 		<property name="serviceInterface" value="example.AccountService"/>
 	</bean>
 ----
+====
  
-That's all we need to do to support the remote account service on the client. Spring
-will transparently create an invoker and remotely enable the account service through the
-`RmiServiceExporter`. At the client we're linking it in using the `RmiProxyFactoryBean`.
+That is all we need to do to support the remote account service on the client. Spring
+transparently creates an invoker and remotely enables the account service through the
+`RmiServiceExporter`. At the client, we link it in by using the `RmiProxyFactoryBean`.
  
  
  
 [[remoting-caucho-protocols]]
-=== Using Hessian to remotely call services via HTTP
+=== Using Hessian to Remotely Call Services through HTTP
+ 
+Hessian offers a binary HTTP-based remoting protocol. It is developed by Caucho, and you can find more
+information about Hessian itself at http://www.caucho.com[].
  
-Hessian offers a binary HTTP-based remoting protocol. It is developed by Caucho and more
-information about Hessian itself can be found at http://www.caucho.com[].
  
  
 [[remoting-caucho-protocols-hessian]]
-==== Wiring up the DispatcherServlet for Hessian and co.
+==== Wiring up `DispatcherServlet` for Hessian
  
-Hessian communicates via HTTP and does so using a custom servlet. Using Spring's
-`DispatcherServlet` principles, as known from Spring Web MVC usage, you can easily wire
-up such a servlet exposing your services. First we'll have to create a new servlet in
-your application (this is an excerpt from `'web.xml'`):
+Hessian communicates through HTTP and does so by using a custom servlet. By using Spring's
+`DispatcherServlet` principles (see <<webmvc.adoc#mvc-servlet>>), we can wire
+up such a servlet to expose your services. First, we have to create a new servlet in
+our application, as shown in the following excerpt from `web.xml`:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -230,25 +238,28 @@ your application (this is an excerpt from `'web.xml'`):
 		<url-pattern>/remoting/*</url-pattern>
 	</servlet-mapping>
 ----
+====
  
-You're probably familiar with Spring's `DispatcherServlet` principles and if so, you
-know that now you'll have to create a Spring container configuration resource named
-`'remoting-servlet.xml'` (after the name of your servlet) in the `'WEB-INF'` directory.
-The application context will be used in the next section.
+If you are familiar with Spring's `DispatcherServlet` principles, you probably
+know that now you have to create a Spring container configuration resource named
+`remoting-servlet.xml` (after the name of your servlet) in the `WEB-INF` directory.
+The application context is used in the next section.
+ 
+Alternatively, consider the use of Spring's simpler `HttpRequestHandlerServlet`. Doing so
+lets you embed the remote exporter definitions in your root application context (by
+default, in `WEB-INF/applicationContext.xml`), with individual servlet definitions
+pointing to specific exporter beans. In this case, each servlet name needs to match the bean name of
+its target exporter.
  
-Alternatively, consider the use of Spring's simpler `HttpRequestHandlerServlet`. This
-allows you to embed the remote exporter definitions in your root application context (by
-default in `'WEB-INF/applicationContext.xml'`), with individual servlet definitions
-pointing to specific exporter beans. Each servlet name needs to match the bean name of
-its target exporter in this case.
  
  
 [[remoting-caucho-protocols-hessian-server]]
-==== Exposing your beans by using the HessianServiceExporter
+==== Exposing Your Beans by Using `HessianServiceExporter`
  
-In the newly created application context called `remoting-servlet.xml`, we'll create a
-`HessianServiceExporter` exporting your services:
+In the newly created application context called `remoting-servlet.xml`, we create a
+`HessianServiceExporter` to export our services, as the following example shows:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -261,16 +272,18 @@ In the newly created application context called `remoting-servlet.xml`, we'll cr
 		<property name="serviceInterface" value="example.AccountService"/>
 	</bean>
 ----
+====
  
-Now we're ready to link in the service at the client. No explicit handler mapping is
-specified, mapping request URLs onto services, so `BeanNameUrlHandlerMapping` will be
-used: Hence, the service will be exported at the URL indicated through its bean name
-within the containing ``DispatcherServlet``'s mapping (as defined above):
-`'http://HOST:8080/remoting/AccountService'`.
+Now we are ready to link in the service at the client. No explicit handler mapping is
+specified (to map request URLs onto services), so we use `BeanNameUrlHandlerMapping`
+used. Hence, the service is exported at the URL indicated through its bean name
+within the containing `DispatcherServlet` instance's mapping (as defined earlier):
+`http://HOST:8080/remoting/AccountService`.
  
-Alternatively, create a `HessianServiceExporter` in your root application context (e.g.
-in `'WEB-INF/applicationContext.xml'`):
+Alternatively, you can create a `HessianServiceExporter` in your root application context (for example,
+in `WEB-INF/applicationContext.xml`), as the following example shows:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -279,12 +292,14 @@ in `'WEB-INF/applicationContext.xml'`):
 		<property name="serviceInterface" value="example.AccountService"/>
 	</bean>
 ----
+====
  
-In the latter case, define a corresponding servlet for this exporter in `'web.xml'`,
-with the same end result: The exporter getting mapped to the request path
+In the latter case, you should define a corresponding servlet for this exporter in `web.xml`,
+with the same end result: The exporter gets mapped to the request path at
 `/remoting/AccountService`. Note that the servlet name needs to match the bean name of
-the target exporter.
+the target exporter. The following example shows how to do so:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -298,16 +313,19 @@ the target exporter.
 		<url-pattern>/remoting/AccountService</url-pattern>
 	</servlet-mapping>
 ----
+====
+ 
  
  
 [[remoting-caucho-protocols-hessian-client]]
-==== Linking in the service on the client
+==== Linking in the Service on the Client
  
-Using the `HessianProxyFactoryBean` we can link in the service at the client. The same
-principles apply as with the RMI example. We'll create a separate bean factory or
-application context and mention the following beans where the `SimpleObject` is using
-the `AccountService` to manage accounts:
+By using the `HessianProxyFactoryBean`, we can link in the service at the client. The same
+principles apply as with the RMI example. We create a separate bean factory or
+application context and mention the following beans where the `SimpleObject` is by using
+the `AccountService` to manage accounts, as the following example shows:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -320,17 +338,20 @@ the `AccountService` to manage accounts:
 		<property name="serviceInterface" value="example.AccountService"/>
 	</bean>
 ----
+====
+ 
  
  
 [[remoting-caucho-protocols-security]]
-==== Applying HTTP basic authentication to a service exposed through Hessian
+==== Applying HTTP Basic Authentication to a Service Exposed through Hessian
  
 One of the advantages of Hessian is that we can easily apply HTTP basic authentication,
 because both protocols are HTTP-based. Your normal HTTP server security mechanism can
-easily be applied through using the `web.xml` security features, for example. Usually,
-you don't use per-user security credentials here, but rather shared credentials defined
-at the `HessianProxyFactoryBean` level (similar to a JDBC `DataSource`).
+be applied through using the `web.xml` security features, for example. Usually,
+you need not use per-user security credentials here. Rather, you can use shared credentials that you define
+at the `HessianProxyFactoryBean` level (similar to a JDBC `DataSource`), as the following example shows:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -343,64 +364,64 @@ at the `HessianProxyFactoryBean` level (similar to a JDBC `DataSource`).
 		<property name="authorizedRoles" value="administrator,operator"/>
 	</bean>
 ----
+====
  
-This is an example where we explicitly mention the `BeanNameUrlHandlerMapping` and set
-an interceptor allowing only administrators and operators to call the beans mentioned in
+In the preceding example, we explicitly mention the `BeanNameUrlHandlerMapping` and set
+an interceptor, to let only administrators and operators call the beans mentioned in
 this application context.
  
-[NOTE]
-====
-Of course, this example doesn't show a flexible kind of security infrastructure. For
+NOTE: The preceding example does not show a flexible kind of security infrastructure. For
 more options as far as security is concerned, have a look at the Spring Security project
-at http://projects.spring.io/spring-security/[].
-====
+at http://projects.spring.io/spring-security/.
  
  
  
 [[remoting-httpinvoker]]
-=== Exposing services using HTTP invokers
+=== Exposing Services by Using HTTP Invokers
  
-As opposed to Hessian, which are both lightweight protocols using their own slim
-serialization mechanisms, Spring HTTP invokers use the standard Java serialization
+As opposed to Hessian, Spring HTTP invokers are both lightweight protocols that use their own slim
+serialization mechanisms and use the standard Java serialization
 mechanism to expose services through HTTP. This has a huge advantage if your arguments
-and return types are complex types that cannot be serialized using the serialization
-mechanisms Hessian uses (refer to the next section for more considerations when
-choosing a remoting technology).
+and return types are complex types that cannot be serialized by using the serialization
+mechanisms Hessian uses (see the next section for more considerations when
+you choose a remoting technology).
  
 Under the hood, Spring uses either the standard facilities provided by the JDK or
-Apache `HttpComponents` to perform HTTP calls. Use the latter if you need more
-advanced and easier-to-use functionality. Refer to
+Apache `HttpComponents` to perform HTTP calls. If you need more
+advanced and easier-to-use functionality, use the latter. See
 http://hc.apache.org/httpcomponents-client-ga/[hc.apache.org/httpcomponents-client-ga/]
 for more information.
  
 [WARNING]
 ====
 Be aware of vulnerabilities due to unsafe Java deserialization:
-Manipulated input streams could lead to unwanted code execution on the server
+Manipulated input streams can lead to unwanted code execution on the server
… diff truncated

@@ -1,18 +1,18 @@
 [[kotlin]]
 = Kotlin
  
-https://kotlinlang.org[Kotlin] is a statically-typed language targeting the JVM (and other platforms)
+https://kotlinlang.org[Kotlin] is a statically typed language that targets the JVM (and other platforms),
 which allows writing concise and elegant code while providing very good
 https://kotlinlang.org/docs/reference/java-interop.html[interoperability] with
 existing libraries written in Java.
  
-The Spring Framework provides first-class support for Kotlin that allows developers to write
-Kotlin applications almost as if the Spring Framework was a native Kotlin framework.
+The Spring Framework provides first-class support for Kotlin that lets developers write
+Kotlin applications almost as if the Spring Framework were a native Kotlin framework.
  
-The easiest way to learn about Spring + Kotlin is to follow
+The easiest way to learn about Spring and Kotlin is to follow
 https://spring.io/guides/tutorials/spring-boot-kotlin/[this comprehensive tutorial]. Feel
 free to join the #spring channel of http://slack.kotlinlang.org/[Kotlin Slack] or ask a
-question with `spring` and `kotlin` tags on
+question with `spring` and `kotlin` as tags on
 https://stackoverflow.com/questions/tagged/spring+kotlin[Stackoverflow] if you need support.
  
  
@@ -20,178 +20,163 @@ https://stackoverflow.com/questions/tagged/spring+kotlin[Stackoverflow] if you n
 [[kotlin-requirements]]
 == Requirements
  
-Spring Framework supports Kotlin 1.1+ and requires
+The Spring Framework supports Kotlin 1.1+ and requires
 https://bintray.com/bintray/jcenter/org.jetbrains.kotlin%3Akotlin-stdlib[`kotlin-stdlib`]
-(or one of its variants like https://bintray.com/bintray/jcenter/org.jetbrains.kotlin%3Akotlin-stdlib-jre8[`kotlin-stdlib-jre8`]
+(or one of its variants, such as https://bintray.com/bintray/jcenter/org.jetbrains.kotlin%3Akotlin-stdlib-jre8[`kotlin-stdlib-jre8`]
 for Kotlin 1.1 or https://bintray.com/bintray/jcenter/org.jetbrains.kotlin%3Akotlin-stdlib-jdk8[`kotlin-stdlib-jdk8`] for Kotlin 1.2+)
 and https://bintray.com/bintray/jcenter/org.jetbrains.kotlin%3Akotlin-reflect[`kotlin-reflect`]
-to be present on the classpath. They are provided by default if one bootstraps a Kotlin project on
+to be present on the classpath. They are provided by default if you bootstrap a Kotlin project on
 https://start.spring.io/#!language=kotlin[start.spring.io].
  
  
  
- 
 [[kotlin-extensions]]
 == Extensions
  
 Kotlin https://kotlinlang.org/docs/reference/extensions.html[extensions] provide the ability
-to extend existing classes with additional functionality. The Spring Framework Kotlin APIs make
-use of these extensions to add new Kotlin specific conveniences to existing Spring APIs.
+to extend existing classes with additional functionality. The Spring Framework Kotlin APIs
+use these extensions to add new Kotlin-specific conveniences to existing Spring APIs.
  
-{doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/[Spring Framework KDoc API] lists
-and documents all the Kotlin extensions and DSLs available.
+The {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/[Spring Framework KDoc API] lists
+and documents all available the Kotlin extensions and DSLs.
  
-[NOTE]
-====
-Keep in mind that Kotlin extensions need to be imported to be used. This means
-for example that the `GenericApplicationContext.registerBean` Kotlin extension
-will only be available if `import org.springframework.context.support.registerBean` is imported.
+NOTE: Keep in mind that Kotlin extensions need to be imported to be used. This means,
+for example, that the `GenericApplicationContext.registerBean` Kotlin extension
+is available only if `org.springframework.context.support.registerBean` is imported.
 That said, similar to static imports, an IDE should automatically suggest the import in most cases.
-====
  
 For example, https://kotlinlang.org/docs/reference/inline-functions.html#reified-type-parameters[Kotlin reified type parameters]
 provide a workaround for JVM https://docs.oracle.com/javase/tutorial/java/generics/erasure.html[generics type erasure],
-and Spring Framework provides some extensions to take advantage of this feature.
-This allows for a better Kotlin API `RestTemplate`, the new `WebClient` from Spring
-WebFlux and for various other APIs.
+and the Spring Framework provides some extensions to take advantage of this feature.
+This allows for a better Kotlin API `RestTemplate`, for the new `WebClient` from Spring
+WebFlux, and for various other APIs.
  
-[NOTE]
-====
-Other libraries like Reactor and Spring Data also provide Kotlin extensions
+NOTE: Other libraries, such as Reactor and Spring Data, also provide Kotlin extensions
 for their APIs, thus giving a better Kotlin development experience overall.
-====
  
-To retrieve a list of `Foo` objects in Java, one would normally write:
+To retrieve a list of `User` objects in Java, you would normally write the following:
  
+====
 [source,java,indent=0]
 ----
 	Flux<User> users  = client.get().retrieve().bodyToFlux(User.class)
 ----
+====
  
-Whilst with Kotlin and Spring Framework extensions, one is able to write:
+With Kotlin and the Spring Framework extensions, you can instead write the following:
  
+====
 [source,kotlin,indent=0]
 ----
 	val users = client.get().retrieve().bodyToFlux<User>()
 	// or (both are equivalent)
 	val users : Flux<User> = client.get().retrieve().bodyToFlux()
 ----
+====
  
 As in Java, `users` in Kotlin is strongly typed, but Kotlin's clever type inference allows
 for shorter syntax.
  
  
  
- 
 [[kotlin-null-safety]]
 == Null-safety
  
-One of Kotlin's key features is https://kotlinlang.org/docs/reference/null-safety.html[null-safety]
-- which cleanly deals with `null` values at compile time rather than bumping into the famous
+One of Kotlin's key features is https://kotlinlang.org/docs/reference/null-safety.html[null-safety],
+which cleanly deals with `null` values at compile time rather than bumping into the famous
 `NullPointerException` at runtime. This makes applications safer through nullability
-declarations and expressing "value or no value" semantics without paying the cost of wrappers like `Optional`.
-(Kotlin allows using functional constructs with nullable values; check out this
+declarations and expressing "`value or no value`" semantics without paying the cost of wrappers, such as `Optional`.
+(Kotlin allows using functional constructs with nullable values. See this
 http://www.baeldung.com/kotlin-null-safety[comprehensive guide to Kotlin null-safety].)
  
-Although Java does not allow one to express null-safety in its type-system, Spring Framework now
+Although Java does not let you express null-safety in its type-system, the Spring Framework
 provides <<core#null-safety,null-safety of the whole Spring Framework API>>
 via tooling-friendly annotations declared in the `org.springframework.lang` package.
 By default, types from Java APIs used in Kotlin are recognized as
-https://kotlinlang.org/docs/reference/java-interop.html#null-safety-and-platform-types[platform types]
+https://kotlinlang.org/docs/reference/java-interop.html#null-safety-and-platform-types[platform types],
 for which null-checks are relaxed.
-https://kotlinlang.org/docs/reference/java-interop.html#jsr-305-support[Kotlin support for JSR 305 annotations]
-+ Spring nullability annotations provide null-safety for the whole Spring Framework API to Kotlin developers,
-with the advantage of dealing with `null` related issues at compile time.
+https://kotlinlang.org/docs/reference/java-interop.html#jsr-305-support[Kotlin support for JSR-305 annotations]
+and Spring nullability annotations provide null-safety for the whole Spring Framework API to Kotlin developers,
+with the advantage of dealing with `null`-related issues at compile time.
  
-[NOTE]
-====
-Libraries like Reactor or Spring Data provide null-safe APIs leveraging this feature.
-====
+NOTE: Libraries such as Reactor or Spring Data provide null-safe APIs to leverage this feature.
  
-The JSR 305 checks can be configured by adding the `-Xjsr305` compiler flag with the following
+You can configure JSR-305 checks by adding the `-Xjsr305` compiler flag with the following
 options: `-Xjsr305={strict|warn|ignore}`.
  
-For kotlin versions 1.1+, the default behavior is the same to `-Xjsr305=warn`.
-The `strict` value is required to have Spring Framework API null-safety taken in account
+For kotlin versions 1.1+, the default behavior is the same as `-Xjsr305=warn`.
+The `strict` value is required to have Spring Framework API null-safety taken into account
 in Kotlin types inferred from Spring API but should be used with the knowledge that Spring
-API nullability declaration could evolve even between minor releases and more checks may
+API nullability declaration could evolve even between minor releases and that more checks may
 be added in the future).
  
-[NOTE]
-====
-Generic type arguments, varargs and array elements nullability are not supported yet,
-but should be in an upcoming release, see https://github.com/Kotlin/KEEP/issues/79[this discussion]
+NOTE: Generic type arguments, varargs, and array elements nullability are not supported yet,
+but should be in an upcoming release. See https://github.com/Kotlin/KEEP/issues/79[this discussion]
 for up-to-date information.
-====
- 
  
  
  
 [[kotlin-classes-interfaces]]
-== Classes & Interfaces
+== Classes and Interfaces
  
-Spring Framework supports various Kotlin constructs like instantiating Kotlin classes
-via primary constructors, immutable classes data binding and function optional parameters
+The Spring Framework supports various Kotlin constructs, such as instantiating Kotlin classes
+through primary constructors, immutable classes data binding, and function optional parameters
 with default values.
  
-Kotlin parameter names are recognized via a dedicated `KotlinReflectionParameterNameDiscoverer`
+Kotlin parameter names are recognized through a dedicated `KotlinReflectionParameterNameDiscoverer`,
 which allows finding interface method parameter names without requiring the Java 8 `-parameters`
-compiler flag enabled during compilation.
+compiler flag to be enabled during compilation.
  
-https://github.com/FasterXML/jackson-module-kotlin[Jackson Kotlin module] which is required
-for serializing / deserializing JSON data is automatically registered when
-found in the classpath and a warning message will be logged if Jackson and Kotlin are
-detected without the Jackson Kotlin module present.
+The https://github.com/FasterXML/jackson-module-kotlin[Jackson Kotlin module], which is required
+for serializing or deserializing JSON data, is automatically registered when
+found in the classpath, and a warning message is logged if Jackson and Kotlin are
+detected without the Jackson Kotlin module being present.
  
-Configuration classes can be
-https://kotlinlang.org/docs/reference/nested-classes.html[top level or nested but not inner]
+You can declare configuration classes as
+https://kotlinlang.org/docs/reference/nested-classes.html[top level or nested but not inner],
 since the later requires a reference to the outer class.
  
  
  
- 
 [[kotlin-annotations]]
 == Annotations
  
-Spring Framework also takes advantage of https://kotlinlang.org/docs/reference/null-safety.html[Kotlin null-safety]
+The Spring Framework also takes advantage of https://kotlinlang.org/docs/reference/null-safety.html[Kotlin null-safety]
 to determine if a HTTP parameter is required without having to explicitly
-define the `required` attribute.  That means `@RequestParam name: String?` will be treated
-as not required and conversely `@RequestParam name: String` as being required.
+define the `required` attribute.  That means `@RequestParam name: String?` is treated
+as not required and, conversely,  `@RequestParam name: String` is treated as being required.
 This feature is also supported on the Spring Messaging `@Header` annotation.
  
-In a similar fashion, Spring bean injection with `@Autowired`, `@Bean` or `@Inject` uses
+In a similar fashion, Spring bean injection with `@Autowired`, `@Bean`, or `@Inject` uses
 this information to determine if a bean is required or not.
  
-For example, `@Autowired lateinit var foo: Foo` implies that a bean
-of type `Foo` must be registered in the application context, while `@Autowired lateinit var foo: Foo?`
-won’t raise an error if such bean does not exist.
+For example, `@Autowired lateinit var thing: Thing` implies that a bean
+of type `Thing` must be registered in the application context, while `@Autowired lateinit var thing: Thing?`
+does not raise an error if such a bean does not exist.
  
-Following the same principle, `@Bean fun baz(foo: Foo, bar: Bar?) = Baz(foo, bar)` implies
-that a bean of type `Foo` must be registered in the application context while a bean of
-type `Bar` may or may not exist. The same behavior applies to autowired constructor parameters.
+Following the same principle, `@Bean fun play(toy: Toy, car: Car?) = Baz(toy, Car)` implies
+that a bean of type `Toy` must be registered in the application context, while a bean of
+type `Car` may or may not exist. The same behavior applies to autowired constructor parameters.
  
-[NOTE]
-====
-If you are using bean validation on classes with properties or a primary constructor
-parameters, you may need to leverage
-https://kotlinlang.org/docs/reference/annotations.html#annotation-use-site-targets[annotation use-site targets]
-like `@field:NotNull` or `@get:Size(min=5, max=15)` as described in
+NOTE: If you use bean validation on classes with properties or a primary constructor
+parameters, you may need to use
+https://kotlinlang.org/docs/reference/annotations.html#annotation-use-site-targets[annotation use-site targets],
+such as `@field:NotNull` or `@get:Size(min=5, max=15)`, as described in
 https://stackoverflow.com/a/35853200/1092077[this Stack Overflow response].
-====
- 
  
  
  
 [[kotlin-bean-definition-dsl]]
-== Bean definition DSL
+== Bean Definition DSL
  
-Spring Framework 5 introduces a new way to register beans in a functional way using lambdas
-as an alternative to XML or JavaConfig (`@Configuration` and `@Bean`). In a nutshell,
-it makes it possible to register beans with a lambda that acts as a `FactoryBean`.
-This mechanism is very efficient as it does not require any reflection or CGLIB proxies.
+Spring Framework 5 introduces a new way to register beans in a functional way by using lambdas
+as an alternative to XML or Java configuration (`@Configuration` and `@Bean`). In a nutshell,
+it lets you register beans with a lambda that acts as a `FactoryBean`.
+This mechanism is very efficient, as it does not require any reflection or CGLIB proxies.
  
-In Java, one may for example write:
+In Java, you can, for example, write the following:
  
+====
 [source,java,indent=0]
 ----
 	GenericApplicationContext context = new GenericApplicationContext();
@@ -199,10 +184,12 @@ In Java, one may for example write:
 	context.registerBean(Bar.class, () -> new Bar(context.getBean(Foo.class))
 );
 ----
+====
  
-Whilst in Kotlin with reified type parameters and `GenericApplicationContext`
-Kotlin extensions one can instead simply write:
+In Kotlin, with reified type parameters and `GenericApplicationContext`
+Kotlin extensions, you can instead write the following:
  
+====
 [source,kotlin,indent=0]
 ----
 	val context = GenericApplicationContext().apply {
@@ -210,13 +197,15 @@ Kotlin extensions one can instead simply write:
 		registerBean { Bar(it.getBean<Foo>()) }
 	}
 ----
+====
  
 In order to allow a more declarative approach and cleaner syntax, Spring Framework provides
 a {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.context.support/-bean-definition-dsl/[Kotlin bean definition DSL]
-It declares an `ApplicationContextInitializer` via a clean declarative API
-which enables one to deal with profiles and `Environment` for customizing
-how beans are registered.
+It declares an `ApplicationContextInitializer` through a clean declarative API,
+which lets you deal with profiles and `Environment` for customizing
+how beans are registered. The following example creates a `Play` profile:
  
+====
 [source,kotlin,indent=0]
 ----
 	fun beans() = beans {
@@ -243,17 +232,20 @@ how beans are registered.
 				setSuffix(suffix)
 			}
 		}
-		profile("foo") {
-			bean<Foo>()
+		profile("play") {
+			bean<Play>()
 		}
 	}
 ----
+====
  
-In this example, `bean<Routes>()` is using autowiring by constructor and `ref<Routes>()`
+In the preceding example, `bean<Routes>()` uses autowiring by constructor, and `ref<Routes>()`
 is a shortcut for `applicationContext.getBean(Routes::class.java)`.
  
-This `beans()` function can then be used to register beans on the application context.
+You can then use this `beans()` function to register beans on the application context,
+as the following example shows:
  
+====
 [source,kotlin,indent=0]
 ----
 	val context = GenericApplicationContext().apply {
@@ -261,25 +253,19 @@ This `beans()` function can then be used to register beans on the application co
 		refresh()
 	}
 ----
- 
-[NOTE]
-====
-This DSL is programmatic, thus it allows custom registration logic of beans
-via an `if` expression, a `for` loop or any other Kotlin constructs.
 ====
  
+NOTE: This DSL is programmatic, meaning it allows custom registration logic of beans
+through an `if` expression, a `for` loop, or any other Kotlin constructs.
+ 
 See https://github.com/sdeleuze/spring-kotlin-functional/blob/master/src/main/kotlin/functional/Beans.kt[spring-kotlin-functional beans declaration]
 for a concrete example.
  
-[NOTE]
-====
-Spring Boot is based on Java Config and
-https://github.com/spring-projects/spring-boot/issues/8115[does not provide specific support for functional bean definition yet],
-but one can experimentally use functional bean definitions via Spring Boot's `ApplicationContextInitializer` support,
-see https://stackoverflow.com/questions/45935931/how-to-use-functional-bean-definition-kotlin-dsl-with-spring-boot-and-spring-w/46033685#46033685[this Stack Overflow answer]
+NOTE: Spring Boot is based on Java configuration and
+https://github.com/spring-projects/spring-boot/issues/8115[does not yet provide specific support for functional bean definition],
+but you can experimentally use functional bean definitions through Spring Boot's `ApplicationContextInitializer` support.
+See https://stackoverflow.com/questions/45935931/how-to-use-functional-bean-definition-kotlin-dsl-with-spring-boot-and-spring-w/46033685#46033685[this Stack Overflow answer]
 for more details and up-to-date information.
-====
- 
  
  
  
@@ -292,9 +278,10 @@ for more details and up-to-date information.
  
 Spring Framework now comes with a
 {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.web.reactive.function.server/-router-function-dsl/[Kotlin routing DSL]
-that allows one to leverage the <<web-reactive#webflux-fn,WebFlux functional
-API>> for writing clean and idiomatic Kotlin code:
+that lets you use the <<web-reactive#webflux-fn,WebFlux functional
+API>> to write clean and idiomatic Kotlin code, as the following example shows:
  
+====
 [source,kotlin,indent=0]
 ----
 	router {
@@ -314,37 +301,36 @@ API>> for writing clean and idiomatic Kotlin code:
 		resources("/**", ClassPathResource("static/"))
 	}
 ----
- 
-[NOTE]
 ====
-This DSL is programmatic, thus it allows custom registration logic of beans
-via an `if` expression, a `for` loop or any other Kotlin constructs. That can be useful when routes need to be registered
+ 
+NOTE: This DSL is programmatic, meaning that it allows custom registration logic of beans
+through an `if` expression, a `for` loop, or any other Kotlin constructs. That can be useful when you need to register routes
 depending on dynamic data (for example, from a database).
-====
  
 See https://github.com/mixitconf/mixit/tree/bad6b92bce6193f9b3f696af9d416c276501dbf1/src/main/kotlin/mixit/web/routes[MiXiT project routes]
 for a concrete example.
  
  
  
-=== Kotlin Script templates
+=== Kotlin Script Templates
  
 As of version 4.3, Spring Framework provides a
… diff truncated

@@ -1,18 +1,13 @@
 [[dynamic-language]]
 = Dynamic Language Support
  
- 
- 
-[[dynamic-language-introduction]]
-== Introduction
- 
-Spring 2.0 introduces comprehensive support for using classes and objects that have been
-defined using a dynamic language (such as JRuby) with Spring. This support allows you to
-write any number of classes in a supported dynamic language, and have the Spring
-container transparently instantiate, configure and dependency inject the resulting
+Spring 2.0 introduced comprehensive support for using classes and objects that have been
+defined by using a dynamic language (such as JRuby) with Spring. This support lets you
+write any number of classes in a supported dynamic language and have the Spring
+container transparently instantiate, configure, and dependency inject the resulting
 objects.
  
-The dynamic languages currently supported are:
+Spring currently supports the following dynamic languages:
  
 * JRuby 1.5+
 * Groovy 1.8+
@@ -20,32 +15,34 @@ The dynamic languages currently supported are:
  
 .Why only these languages?
 ****
-The supported languages were chosen because __a)__ the languages have a lot of traction in
-the Java enterprise community, __b)__ no requests were made for other languages at the time
-that this support was added, and __c)__ the Spring developers were most familiar with
-them.
+We chose to support these languages because:
+ 
+* The languages have a lot of traction in the Java enterprise community.
+* No requests were made for other languages at the time that this support was added
+* The Spring developers were most familiar with them.
 ****
  
-Fully working examples of where this dynamic language support can be immediately useful
-are described in <<dynamic-language-scenarios>>.
+You can find fully working examples of where this dynamic language support can be immediately useful
+in <<dynamic-language-scenarios>>.
  
  
  
 [[dynamic-language-a-first-example]]
-== A first example
+== A First Example
  
-This bulk of this chapter is concerned with describing the dynamic language support in
+The bulk of this chapter is concerned with describing the dynamic language support in
 detail. Before diving into all of the ins and outs of the dynamic language support,
-let's look at a quick example of a bean defined in a dynamic language. The dynamic
-language for this first bean is Groovy (the basis of this example was taken from the
-Spring test suite, so if you want to see equivalent examples in any of the other
+we look at a quick example of a bean defined in a dynamic language. The dynamic
+language for this first bean is Groovy. (The basis of this example was taken from the
+Spring test suite. If you want to see equivalent examples in any of the other
 supported languages, take a look at the source code).
  
-Find below the `Messenger` interface that the Groovy bean is going to be implementing,
-and note that this interface is defined in plain Java. Dependent objects that are
-injected with a reference to the `Messenger` won't know that the underlying
-implementation is a Groovy script.
+The next example shows the `Messenger` interface, which the Groovy bean is going to implement.
+Note that this interface is defined in plain Java. Dependent objects that are
+injected with a reference to the `Messenger` do not know that the underlying
+implementation is a Groovy script. The following listing shows the `Messenger` interface:
  
+====
 [source,java,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -57,9 +54,11 @@ implementation is a Groovy script.
  
 	}
 ----
+====
  
-Here is the definition of a class that has a dependency on the `Messenger` interface.
+The following example defines a class that has a dependency on the `Messenger` interface:
  
+====
 [source,java,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -79,9 +78,11 @@ Here is the definition of a class that has a dependency on the `Messenger` inter
  
 	}
 ----
+====
  
-Here is an implementation of the `Messenger` interface in Groovy.
+The following example implements the `Messenger` interface in Groovy:
  
+====
 [source,java,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -98,16 +99,13 @@ Here is an implementation of the `Messenger` interface in Groovy.
  
 	}
 ----
- 
-Finally, here are the bean definitions that will effect the injection of the
-Groovy-defined `Messenger` implementation into an instance of the
-`DefaultBookingService` class.
+====
  
 [NOTE]
 ====
 To use the custom dynamic language tags to define dynamic-language-backed beans, you
 need to have the XML Schema preamble at the top of your Spring XML configuration file.
-You also need to be using a Spring `ApplicationContext` implementation as your IoC
+You also need to use a Spring `ApplicationContext` implementation as your IoC
 container. Using the dynamic-language-backed beans with a plain `BeanFactory`
 implementation is supported, but you have to manage the plumbing of the Spring internals
 to do so.
@@ -116,6 +114,11 @@ For more information on schema-based configuration, see <<appendix.adoc#xsd-conf
 XML Schema-based configuration>>.
 ====
  
+Finally, the following example shows the bean definitions that effect the injection of the
+Groovy-defined `Messenger` implementation into an instance of the
+`DefaultBookingService` class:
+ 
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -138,60 +141,64 @@ XML Schema-based configuration>>.
  
 	</beans>
 ----
+====
  
 The `bookingService` bean (a `DefaultBookingService`) can now use its private
-`messenger` member variable as normal because the `Messenger` instance that was injected
-into it __is__ a `Messenger` instance. There is nothing special going on here, just
+`messenger` member variable as normal, because the `Messenger` instance that was injected
+into it is a `Messenger` instance. There is nothing special going on here -- just
 plain Java and plain Groovy.
  
-Hopefully the above XML snippet is self-explanatory, but don't worry unduly if it isn't.
-Keep reading for the in-depth detail on the whys and wherefores of the above
+Hopefully, the preceding XML snippet is self-explanatory, but do not worry unduly if it is not.
+Keep reading for the in-depth detail on the whys and wherefores of the preceding
 configuration.
  
  
  
 [[dynamic-language-beans]]
-== Defining beans that are backed by dynamic languages
+== Defining Beans that Are Backed by Dynamic Languages
  
-This section describes exactly how you define Spring managed beans in any of the
+This section describes exactly how you define Spring-managed beans in any of the
 supported dynamic languages.
  
-Please note that this chapter does not attempt to explain the syntax and idioms of the
+Note that this chapter does not attempt to explain the syntax and idioms of the
 supported dynamic languages. For example, if you want to use Groovy to write certain of
-the classes in your application, then the assumption is that you already know Groovy. If
-you need further details about the dynamic languages themselves, please
-consult <<dynamic-language-resources>> at the end of this chapter.
+the classes in your application, we assume that you already know Groovy. If
+you need further details about the dynamic languages themselves, see
+<<dynamic-language-resources>> at the end of this chapter.
+ 
  
  
 [[dynamic-language-beans-concepts]]
-=== Common concepts
+=== Common Concepts
  
 The steps involved in using dynamic-language-backed beans are as follows:
  
-* Write the test for the dynamic language source code (naturally)
-* __Then__ write the dynamic language source code itself :)
-* Define your dynamic-language-backed beans using the appropriate `<lang:language/>`
-  element in the XML configuration (you can of course define such beans programmatically
-  using the Spring API - although you will have to consult the source code for
-  directions on how to do this as this type of advanced configuration is not covered in
-  this chapter). Note this is an iterative step. You will need at least one bean
-  definition per dynamic language source file (although the same dynamic language source
-  file can of course be referenced by multiple bean definitions).
+. Write the test for the dynamic language source code (naturally).
+. Then write the dynamic language source code itself.
+. Define your dynamic-language-backed beans by using the appropriate `<lang:language/>`
+  element in the XML configuration (you can define such beans programmatically by
+  using the Spring API, although you will have to consult the source code for
+  directions on how to do this, as this chapter does not cover this type of advanced configuration).
+  Note that this is an iterative step. You need at least one bean
+  definition for each dynamic language source file (although multiple bean definitions can reference the same dynamic language source
+  file).
  
 The first two steps (testing and writing your dynamic language source files) are beyond
-the scope of this chapter. Refer to the language specification and / or reference manual
+the scope of this chapter. See the language specification and reference manual
 for your chosen dynamic language and crack on with developing your dynamic language
-source files. You __will__ first want to read the rest of this chapter though, as
+source files. You first want to read the rest of this chapter, though, as
 Spring's dynamic language support does make some (small) assumptions about the contents
 of your dynamic language source files.
  
+ 
+ 
 [[dynamic-language-beans-concepts-xml-language-element]]
 ==== The <lang:language/> element
  
-The final step involves defining dynamic-language-backed bean definitions, one for each
+The final step in the list in the <<dynamic-language-beans-concepts,preceding section>> involves defining dynamic-language-backed bean definitions, one for each
 bean that you want to configure (this is no different from normal JavaBean
 configuration). However, instead of specifying the fully qualified classname of the
-class that is to be instantiated and configured by the container, you use the
+class that is to be instantiated and configured by the container, you can use the
 `<lang:language/>` element to define the dynamic language-backed bean.
  
 Each of the supported languages has a corresponding `<lang:language/>` element:
@@ -202,42 +209,42 @@ Each of the supported languages has a corresponding `<lang:language/>` element:
  
 The exact attributes and child elements that are available for configuration depends on
 exactly which language the bean has been defined in (the language-specific sections
-below provide the full lowdown on this).
+later in this chapter detail this).
+ 
+ 
  
 [[dynamic-language-refreshable-beans]]
-==== Refreshable beans
+==== Refreshable Beans
  
-One of the (if not __the__) most compelling value adds of the dynamic language support
-in Spring is the__'refreshable bean'__ feature.
+One of the (and perhaps the single) most compelling value adds of the dynamic language support
+in Spring is the "`refreshable bean`" feature.
  
-A refreshable bean is a dynamic-language-backed bean that with a small amount of
+A refreshable bean is a dynamic-language-backed bean. With a small amount of
 configuration, a dynamic-language-backed bean can monitor changes in its underlying
-source file resource, and then reload itself when the dynamic language source file is
-changed (for example when a developer edits and saves changes to the file on the
-filesystem).
+source file resource and then reload itself when the dynamic language source file is
+changed (for example, when you edit and save changes to the file on the
+file system).
  
-This allows a developer to deploy any number of dynamic language source files as part of
+This lets you deploy any number of dynamic language source files as part of
 an application, configure the Spring container to create beans backed by dynamic
-language source files (using the mechanisms described in this chapter), and then later,
-as requirements change or some other external factor comes into play, simply edit a
-dynamic language source file and have any change they make reflected in the bean that is
+language source files (using the mechanisms described in this chapter), and (later,
+as requirements change or some other external factor comes into play) edit a
+dynamic language source file and have any change they make be reflected in the bean that is
 backed by the changed dynamic language source file. There is no need to shut down a
 running application (or redeploy in the case of a web application). The
-dynamic-language-backed bean so amended will pick up the new state and logic from the
+dynamic-language-backed bean so amended picks up the new state and logic from the
 changed dynamic language source file.
  
-[NOTE]
-====
-Please note that this feature is __off__ by default.
-====
+NOTE: This feature is off by default.
  
-Let's take a look at an example to see just how easy it is to start using refreshable
-beans. To __turn on__ the refreshable beans feature, you simply have to specify exactly
-__one__ additional attribute on the `<lang:language/>` element of your bean definition.
-So if we stick with <<dynamic-language-a-first-example,the example>> from earlier in this
-chapter, here's what we would change in the Spring XML configuration to effect
+Now we can take a look at an example to see how easy it is to start using refreshable
+beans. To turn on the refreshable beans feature, you have to specify exactly
+one additional attribute on the `<lang:language/>` element of your bean definition.
+So, if we stick with <<dynamic-language-a-first-example,the example>> from earlier in this
+chapter, the following example shows what we would change in the Spring XML configuration to effect
 refreshable beans:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -256,21 +263,25 @@ refreshable beans:
  
 	</beans>
 ----
+====
  
-That really is all you have to do. The `'refresh-check-delay'` attribute defined on the
-`'messenger'` bean definition is the number of milliseconds after which the bean will be
+That really is all you have to do. The `refresh-check-delay` attribute defined on the
+`messenger` bean definition is the number of milliseconds after which the bean is
 refreshed with any changes made to the underlying dynamic language source file. You can
 turn off the refresh behavior by assigning a negative value to the
-`'refresh-check-delay'` attribute. Remember that, by default, the refresh behavior is
-disabled. If you don't want the refresh behavior, then simply don't define the attribute.
- 
-If we then run the following application we can exercise the refreshable feature; please
-do excuse the __'jumping-through-hoops-to-pause-the-execution'__ shenanigans in this
-next slice of code. The `System.in.read()` call is only there so that the execution of
-the program pauses while I (the author) go off and edit the underlying dynamic language
-source file so that the refresh will trigger on the dynamic-language-backed bean when
+`refresh-check-delay` attribute. Remember that, by default, the refresh behavior is
+disabled. If you do not want the refresh behavior, do not define the attribute.
+ 
+If we then run the following application, we can exercise the refreshable feature (Please
+do excuse the "`jumping-through-hoops-to-pause-the-execution`" shenanigans in this
+next slice of code.) The `System.in.read()` call is only there so that the execution of
+the program pauses while you (the developer in this scenario) go off and edit the underlying dynamic language
+source file so that the refresh triggers on the dynamic-language-backed bean when
 the program resumes execution.
  
+The following listing shows this sample application:
+ 
+====
 [source,java,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -290,12 +301,14 @@ the program resumes execution.
 		}
 	}
 ----
+====
  
-Let's assume then, for the purposes of this example, that all calls to the
+Assume then, for the purposes of this example, that all calls to the
 `getMessage()` method of `Messenger` implementations have to be changed such that the
-message is surrounded by quotes. Below are the changes that I (the author) make to the
-`Messenger.groovy` source file when the execution of the program is paused.
+message is surrounded by quotation marks. The following listing shows the changes that you (the developer) should make to the
+`Messenger.groovy` source file when the execution of the program is paused:
  
+====
 [source,java,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -315,38 +328,42 @@ message is surrounded by quotes. Below are the changes that I (the author) make
 		}
 	}
 ----
+====
  
-When the program executes, the output before the input pause will be __I Can Do The
-Frug__. After the change to the source file is made and saved, and the program resumes
+When the program runs, the output before the input pause will be `I Can Do The
+Frug`. After the change to the source file is made and saved and the program resumes
 execution, the result of calling the `getMessage()` method on the
-dynamic-language-backed `Messenger` implementation will be __'I Can Do The Frug'__
-(notice the inclusion of the additional quotes).
+dynamic-language-backed `Messenger` implementation is `'I Can Do The Frug'`
+(notice the inclusion of the additional quotation marks).
  
-It is important to understand that changes to a script will __not__ trigger a refresh if
-the changes occur within the window of the `'refresh-check-delay'` value. It is equally
-important to understand that changes to the script are __not__ actually 'picked up' until
+Changes to a script do not trigger a refresh if
+the changes occur within the window of the `refresh-check-delay` value.
+Changes to the script are not actually picked up until
 a method is called on the dynamic-language-backed bean. It is only when a method is
 called on a dynamic-language-backed bean that it checks to see if its underlying script
-source has changed. Any exceptions relating to refreshing the script (such as
-encountering a compilation error, or finding that the script file has been deleted) will
-result in a __fatal__ exception being propagated to the calling code.
- 
-The refreshable bean behavior described above does __not__ apply to dynamic language
-source files defined using the `<lang:inline-script/>` element notation (see
-<<dynamic-language-beans-inline>>). Additionally, it __only__ applies to beans where
-changes to the underlying source file can actually be detected; for example, by code
+source has changed. Any exceptions that relate to refreshing the script (such as
+encountering a compilation error or finding that the script file has been deleted)
+results in a fatal exception being propagated to the calling code.
+ 
+The refreshable bean behavior described earlier does not apply to dynamic language
+source files defined with the `<lang:inline-script/>` element notation (see
+<<dynamic-language-beans-inline>>). Additionally, it applies only to beans where
+changes to the underlying source file can actually be detected (for example, by code
 that checks the last modified date of a dynamic language source file that exists on the
-filesystem.
+file system).
+ 
+ 
  
 [[dynamic-language-beans-inline]]
-==== Inline dynamic language source files
+==== Inline Dynamic Language Source Files
  
-The dynamic language support can also cater for dynamic language source files that are
+The dynamic language support can also cater to dynamic language source files that are
 embedded directly in Spring bean definitions. More specifically, the
-`<lang:inline-script/>` element allows you to define dynamic language source immediately
-inside a Spring configuration file. An example will perhaps make the inline script
-feature crystal clear:
+`<lang:inline-script/>` element lets you define dynamic language source immediately
+inside a Spring configuration file. An example might clarify how the inline script
+feature works:
  
+====
… diff truncated

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2002-2018 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.web.reactive.function.server.support;
+ 
+import org.junit.Test;
+import reactor.core.publisher.Mono;
+ 
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.server.reactive.AbstractHttpHandlerIntegrationTests;
+import org.springframework.http.server.reactive.HttpHandler;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.web.reactive.DispatcherHandler;
+import org.springframework.web.reactive.config.EnableWebFlux;
+import org.springframework.web.reactive.function.server.RouterFunction;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
+ 
+import static org.junit.Assert.*;
+import static org.springframework.web.reactive.function.server.RequestPredicates.accept;
+import static org.springframework.web.reactive.function.server.RouterFunctions.route;
+ 
+/**
+ * @author Arjen Poutsma
+ */
+public class DispatcherHandlerIntegrationTests extends AbstractHttpHandlerIntegrationTests {
+ 
+	private final RestTemplate restTemplate = new RestTemplate();
+ 
+	@Override
+	protected HttpHandler createHttpHandler() {
+		AnnotationConfigApplicationContext wac = new AnnotationConfigApplicationContext();
+		wac.register(TestConfiguration.class);
+		wac.refresh();
+ 
+		return WebHttpHandlerBuilder.webHandler(new DispatcherHandler(wac)).build();
+	}
+ 
+	@Test
+	public void nested() {
+		ResponseEntity<String> result = this.restTemplate
+				.getForEntity("http://localhost:" + this.port + "/foo/bar", String.class);
+ 
+		assertEquals(200, result.getStatusCodeValue());
+	}
+ 
+ 
+	@Configuration
+	@EnableWebFlux
+	static class TestConfiguration {
+ 
+		@Bean
+		public RouterFunction<ServerResponse> router(Handler handler) {
+			return route()
+					.path("/foo", () -> route()
+							.nest(accept(MediaType.APPLICATION_JSON), builder -> builder
+									.GET("/bar", handler::handle))
+							.build())
+					.build();
+		}
+ 
+		@Bean
+		public Handler handler() {
+			return new Handler();
+		}
+	}
+ 
+	static class Handler {
+ 
+		public Mono<ServerResponse> handle(ServerRequest request) {
+			return ServerResponse.ok().build();
+		}
+	}
+ 
+ 
+ 
+ 
+}
 .../beans/factory/NoUniqueBeanDefinitionException.java      | 4 ++--
 .../annotation/AutowiredAnnotationBeanPostProcessor.java    | 2 +-
 .../beans/factory/config/BeanExpressionContext.java         | 4 ++--
 .../factory/config/PreferencesPlaceholderConfigurer.java    | 4 ++--
 .../beans/factory/config/PropertyOverrideConfigurer.java    | 2 +-
 .../factory/support/AbstractAutowireCapableBeanFactory.java | 4 ++--
 .../beans/factory/support/DefaultListableBeanFactory.java   | 2 +-
 .../factory/support/PropertiesBeanDefinitionReader.java     | 2 +-
 .../beans/factory/support/SimpleInstantiationStrategy.java  | 2 +-
 .../beans/factory/support/StaticListableBeanFactory.java    | 2 +-
 .../factory/xml/SimpleConstructorNamespaceHandler.java      | 6 +++---
 .../java/org/springframework/core/AttributeAccessor.java    | 4 ++--
 .../src/main/java/org/springframework/util/ObjectUtils.java | 4 ++--
 .../util/UpdateMessageDigestInputStream.java                | 6 +++---
 14 files changed, 24 insertions(+), 24 deletions(-)

@@ -1556,7 +1556,7 @@ applies to transactions). See <<core.adoc#aop,AOP>> for detailed coverage of the
 configuration and AOP in general.
  
 The following code shows the simple profiling aspect discussed earlier:
-.
+ 
 [source,java,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -3221,16 +3221,14 @@ connection are made.
 To configure a `DriverManagerDataSource`:
  
 . Obtain a connection with `DriverManagerDataSource` as you typically obtain a JDBC
-connection.
-. Specify the fully qualified classname of the JDBC driver so that the
-`DriverManager` can load the driver class.
-. Provide a URL that varies between JDBC
-drivers. (See the documentation for your driver for the correct value.)
-. Provide
-a username and a password to connect to the database.
+  connection.
+. Specify the fully qualified classname of the JDBC driver so that the `DriverManager`
+  can load the driver class.
+. Provide a URL that varies between JDBC drivers. (See the documentation for your driver
+  for the correct value.)
+. Provide a username and a password to connect to the database.
  
-The following example shows how to
-configure a `DriverManagerDataSource` in Java:
+The following example shows how to configure a `DriverManagerDataSource` in Java:
  
 ====
 [source,java,indent=0]
@@ -3246,6 +3244,7 @@ configure a `DriverManagerDataSource` in Java:
  
 The following example shows the corresponding XML configuration:
  
+====
 [source,java,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -3258,6 +3257,7 @@ The following example shows the corresponding XML configuration:
  
 	<context:property-placeholder location="jdbc.properties"/>
 ----
+====
  
 The next two examples show the basic connectivity and configuration for DBCP and C3P0.
 To learn about more options that help control the pooling features, see the product
@@ -3506,14 +3506,15 @@ The following example shows a batch update using named parameters:
 ----
 ====
  
-For an SQL statement that uses the classic `?` placeholders, you pass in a list containing an
-object array with the update values. This object array must have one entry for each
-placeholder in the SQL statement, and they must be in the same order as they are defined
-in the SQL statement.
+For an SQL statement that uses the classic `?` placeholders, you pass in a list
+containing an object array with the update values. This object array must have one entry
+for each placeholder in the SQL statement, and they must be in the same order as they are
+defined in the SQL statement.
  
-The following example is the same as the preceding example, except that it uses classic JDBC "?" placeholders:
+The following example is the same as the preceding example, except that it uses classic
+JDBC `?` placeholders:
  
-===
+====
 [source,java,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -3542,9 +3543,9 @@ The following example is the same as the preceding example, except that it uses
 ----
 ====
  
-All of the batch update methods that we described earlier return an `int` array containing the number of
-affected rows for each batch entry. This count is reported by the JDBC driver. If the
-count is not available, the JDBC driver returns a value of `-2`.
+All of the batch update methods that we described earlier return an `int` array
+containing the number of affected rows for each batch entry. This count is reported by
+the JDBC driver. If the count is not available, the JDBC driver returns a value of `-2`.
  
 [NOTE]
 ====
@@ -4271,6 +4272,7 @@ thread-safe after it is compiled, so, as long as these instances are created whe
 is initialized, they can be kept as instance variables and be reused. The following
 example shows how to define such a class:
  
+====
 [source,java,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -4285,6 +4287,7 @@ example shows how to define such a class:
 		return actorMappingQuery.findObject(id);
 	}
 ----
+====
  
 The method in the preceding example retrieves the customer with the `id` that is passed in as the
 only parameter. Since we want only one object to be returned, we call the `findObject` convenience
@@ -6802,7 +6805,10 @@ preamble of the XML configuration file. The following example shows how to do so
 	<?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:oxm="http://www.springframework.org/schema/oxm" xsi:schemaLocation="http://www.springframework.org/schema/beans <1> http://www.springframework.org/schema/beans/spring-beans.xsd **http://www.springframework.org/schema/oxm http://www.springframework.org/schema/oxm/spring-oxm.xsd"**>
+		xmlns:oxm="http://www.springframework.org/schema/oxm"
+		xsi:schemaLocation="
+			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+			http://www.springframework.org/schema/oxm http://www.springframework.org/schema/oxm/spring-oxm.xsd"> <1>
 ----
 <1> Reference the `oxm` schema.
 ====
 src/docs/asciidoc/data-access-appendix.adoc | 28 ++++++++++-----------
 src/docs/asciidoc/data-access.adoc          |  6 ++---
 src/docs/asciidoc/web/webflux.adoc          |  4 +--
 3 files changed, 19 insertions(+), 19 deletions(-)

@@ -37,16 +37,19 @@ are available to you:
 ----
 	<?xml version="1.0" encoding="UTF-8"?>
 	<beans xmlns="http://www.springframework.org/schema/beans"
-			xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-			xmlns:aop="http://www.springframework.org/schema/aop"
-			xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation=" <1>
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:aop="http://www.springframework.org/schema/aop"
+		xmlns:tx="http://www.springframework.org/schema/tx" <1>
+		xsi:schemaLocation="
 			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 			http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd <2>
-			http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here -->
+			http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
+ 
+		<!-- bean definitions here -->
  
 	</beans>
 ----
-<1> Specify the namespace.
+<1> Declare usage of the `tx` namespace.
 <2> Specify the location (with other schema locations).
 ====
  
@@ -77,12 +80,15 @@ the correct schema so that the elements in the `jdbc` namespace are available to
 	<?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:jdbc="http://www.springframework.org/schema/jdbc" xsi:schemaLocation=" <2>
+		xmlns:jdbc="http://www.springframework.org/schema/jdbc" <1>
+		xsi:schemaLocation="
 			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
-			http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd"> <!-- bean definitions here --> <2>
+			http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd"> <2>
+ 
+		<!-- bean definitions here -->
  
 	</beans>
 ----
-<1> Specify the namespace.
+<1> Declare usage of the `jdbc` namespace.
 <2> Specify the location (with other schema locations).
 ====

@@ -1,8 +1,6 @@
 = Appendix
  
  
- 
- 
 [[xsd-schemas]]
 == XML Schemas
  
@@ -11,15 +9,16 @@ This part of the appendix lists XML schemas related to integration technologies.
  
  
 [[xsd-schemas-jee]]
-=== The jee schema
+=== The `jee` Schema
  
-The `jee` tags deal with Java EE (Java Enterprise Edition)-related configuration issues,
+The `jee` elements deal with issues related to Java EE (Java Enterprise Edition) configuration,
 such as looking up a JNDI object and defining EJB references.
  
-To use the tags in the `jee` schema, you need to have the following preamble at the top
-of your Spring XML configuration file; the text in the following snippet references the
-correct schema so that the tags in the `jee` namespace are available to you.
+To use the elements in the `jee` schema, you need to have the following preamble at the top
+of your Spring XML configuration file. The text in the following snippet references the
+correct schema so that the elements in the `jee` namespace are available to you:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -28,17 +27,22 @@ correct schema so that the tags in the `jee` namespace are available to you.
 		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 		__xmlns:jee="http://www.springframework.org/schema/jee"__ xsi:schemaLocation="
 			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
-			__http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd"__> <!-- bean definitions here -->
+			__http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd"__>
+			<!-- bean definitions here -->
  
 	</beans>
 ----
+====
+ 
  
  
 [[xsd-schemas-jee-jndi-lookup]]
 ==== <jee:jndi-lookup/> (simple)
  
-Before...
+The following example shows how to use JNDI to look up a data source without the `jee`
+schema:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -50,9 +54,12 @@ Before...
 		<property name="dataSource" ref="**dataSource**"/>
 	</bean>
 ----
+====
  
-After...
+The following example shows how to use JNDI to look up a data source with the `jee`
+schema:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -63,13 +70,17 @@ After...
 		<property name="dataSource" ref="**dataSource**"/>
 	</bean>
 ----
+====
+ 
  
  
 [[xsd-schemas-jee-jndi-lookup-environment-single]]
-==== <jee:jndi-lookup/> (with single JNDI environment setting)
+==== `<jee:jndi-lookup/>` (with Single JNDI Environment Setting)
  
-Before...
+The following example shows how to use JNDI to look up an environment variable without
+`jee`:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -77,28 +88,31 @@ Before...
 		<property name="jndiName" value="jdbc/MyDataSource"/>
 		<property name="jndiEnvironment">
 			<props>
-				<prop key="foo">bar</prop>
+				<prop key="ping">pong</prop>
 			</props>
 		</property>
 	</bean>
 ----
+====
  
-After...
+The following example shows how to use JNDI to look up an environment variable with `jee`:
  
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
 	<jee:jndi-lookup id="simple" jndi-name="jdbc/MyDataSource">
-		<jee:environment>foo=bar</jee:environment>
+		<jee:environment>ping=pong</jee:environment>
 	</jee:jndi-lookup>
 ----
  
  
 [[xsd-schemas-jee-jndi-lookup-evironment-multiple]]
-==== <jee:jndi-lookup/> (with multiple JNDI environment settings)
+==== `<jee:jndi-lookup/>` (with Multiple JNDI Environment Settings)
  
-Before...
+The following example shows how to use JNDI to look up multiple environment variables
+without `jee`:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -106,33 +120,39 @@ Before...
 		<property name="jndiName" value="jdbc/MyDataSource"/>
 		<property name="jndiEnvironment">
 			<props>
-				<prop key="foo">bar</prop>
+				<prop key="sing">song</prop>
 				<prop key="ping">pong</prop>
 			</props>
 		</property>
 	</bean>
 ----
+====
  
-After...
+The following example shows how to use JNDI to look up multiple environment variables with
+`jee`:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
 	<jee:jndi-lookup id="simple" jndi-name="jdbc/MyDataSource">
 		<!-- newline-separated, key-value pairs for the environment (standard Properties format) -->
 		<jee:environment>
-			foo=bar
+			sing=song
 			ping=pong
 		</jee:environment>
 	</jee:jndi-lookup>
 ----
+====
  
  
 [[xsd-schemas-jee-jndi-lookup-complex]]
-==== <jee:jndi-lookup/> (complex)
+==== `<jee:jndi-lookup/>` (Complex)
  
-Before...
+The following example shows how to use JNDI to look up a data source and a number of
+different properties without `jee`:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -141,13 +161,16 @@ Before...
 		<property name="cache" value="true"/>
 		<property name="resourceRef" value="true"/>
 		<property name="lookupOnStartup" value="false"/>
-		<property name="expectedType" value="com.myapp.DefaultFoo"/>
-		<property name="proxyInterface" value="com.myapp.Foo"/>
+		<property name="expectedType" value="com.myapp.DefaultThing"/>
+		<property name="proxyInterface" value="com.myapp.Thing"/>
 	</bean>
 ----
+====
  
-After...
+The following example shows how to use JNDI to look up a data source and a number of
+different properties with `jee`:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -156,18 +179,22 @@ After...
 			cache="true"
 			resource-ref="true"
 			lookup-on-startup="false"
-			expected-type="com.myapp.DefaultFoo"
-			proxy-interface="com.myapp.Foo"/>
+			expected-type="com.myapp.DefaultThing"
+			proxy-interface="com.myapp.Thing"/>
 ----
+====
+ 
  
  
 [[xsd-schemas-jee-local-slsb]]
-==== <jee:local-slsb/> (simple)
+==== `<jee:local-slsb/>` (Simple)
  
-The `<jee:local-slsb/>` tag configures a reference to an EJB Stateless SessionBean.
+The `<jee:local-slsb/>` element configures a reference to a local EJB Stateless SessionBean.
  
-Before...
+The following example shows how to configures a reference to a local EJB Stateless
+SessionBean without `jee`:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -177,35 +204,49 @@ Before...
 		<property name="businessInterface" value="com.foo.service.RentalService"/>
 	</bean>
 ----
+====
  
-After...
+The following example shows how to configures a reference to a local EJB Stateless
+SessionBean with `jee`:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
 	<jee:local-slsb id="simpleSlsb" jndi-name="ejb/RentalServiceBean"
 			business-interface="com.foo.service.RentalService"/>
 ----
+====
+ 
  
  
 [[xsd-schemas-jee-local-slsb-complex]]
-==== <jee:local-slsb/> (complex)
+==== `<jee:local-slsb/>` (Complex)
+ 
+The `<jee:local-slsb/>` element configures a reference to a local EJB Stateless SessionBean.
+ 
+The following example shows how to configures a reference to a local EJB Stateless
+SessionBean and a number of properties without `jee`:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
 	<bean id="complexLocalEjb"
 			class="org.springframework.ejb.access.LocalStatelessSessionProxyFactoryBean">
 		<property name="jndiName" value="ejb/RentalServiceBean"/>
-		<property name="businessInterface" value="com.foo.service.RentalService"/>
+		<property name="businessInterface" value="com.example.service.RentalService"/>
 		<property name="cacheHome" value="true"/>
 		<property name="lookupHomeOnStartup" value="true"/>
 		<property name="resourceRef" value="true"/>
 	</bean>
 ----
+====
  
-After...
+The following example shows how to configures a reference to a local EJB Stateless
+SessionBean and a number of properties with `jee`:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -216,16 +257,19 @@ After...
 			lookup-home-on-startup="true"
 			resource-ref="true">
 ----
+====
  
  
 [[xsd-schemas-jee-remote-slsb]]
 ==== <jee:remote-slsb/>
  
-The `<jee:remote-slsb/>` tag configures a reference to a `remote` EJB Stateless
+The `<jee:remote-slsb/>` element configures a reference to a `remote` EJB Stateless
 SessionBean.
  
-Before...
+The following example shows how to configures a reference to a remote EJB Stateless
+SessionBean without `jee`:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -240,9 +284,12 @@ Before...
 		<property name="refreshHomeOnConnectFailure" value="true"/>
 	</bean>
 ----
+====
  
-After...
+The following example shows how to configures a reference to a remote EJB Stateless
+SessionBean with `jee`:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -255,24 +302,25 @@ After...
 			home-interface="com.foo.service.RentalService"
 			refresh-home-on-connect-failure="true">
 ----
- 
+====
  
  
  
 [[xsd-schemas-jms]]
-=== The jms schema
+=== The `jms` Schema
  
-The `jms` tags deal with configuring JMS-related beans such as Spring's
-<<integration.adoc#jms-mdp,MessageListenerContainers>>. These tags are detailed in the
+The `jms` elements deal with configuring JMS-related beans, such as Spring's
+<<integration.adoc#jms-mdp,Message Listener Containers>>. These elements are detailed in the
 section of the <<integration.adoc#jms,JMS chapter>> entitled <<integration.adoc#jms-namespace,
-JMS namespace support>>. Please do consult that chapter for full details on this support
-and the `jms` tags themselves.
+JMS Namespace Support>>. See that chapter for full details on this support
+and the `jms` elements themselves.
  
-In the interest of completeness, to use the tags in the `jms` schema, you need to have
-the following preamble at the top of your Spring XML configuration file; the text in the
-following snippet references the correct schema so that the tags in the `jms` namespace
-are available to you.
+In the interest of completeness, to use the elements in the `jms` schema, you need to have
+the following preamble at the top of your Spring XML configuration file. The text in the
+following snippet references the correct schema so that the elements in the `jms` namespace
+are available to you:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -285,28 +333,31 @@ are available to you.
  
 	</beans>
 ----
+====
+ 
  
  
 [[xsd-schemas-context-mbe]]
-=== <context:mbean-export/>
+=== Using `<context:mbean-export/>`
  
 This element is detailed in
-<<integration.adoc#jmx-context-mbeanexport, Configuring annotation based MBean export>>.
+<<integration.adoc#jmx-context-mbeanexport, Configuring Annotation-based MBean Export>>.
  
  
  
 [[xsd-schemas-cache]]
-=== The cache schema
+=== The `cache` Schema
  
-The `cache` tags can be used to enable support for Spring's `@CacheEvict`, `@CachePut`
+You can use the `cache` elements to enable support for Spring's `@CacheEvict`, `@CachePut`,
 and `@Caching` annotations. It it also supports declarative XML-based caching. See
-<<integration.adoc#cache-annotation-enable,Enable caching annotations>> and
-<<integration.adoc#cache-declarative-xml,Declarative XML-based caching>> for details.
+<<integration.adoc#cache-annotation-enable,Enabling Caching Annotations>> and
+<<integration.adoc#cache-declarative-xml,Declarative XML-based Caching>> for details.
  
-To use the tags in the `cache` schema, you need to have the following preamble at the
-top of your Spring XML configuration file; the text in the following snippet references
-the correct schema so that the tags in the `cache` namespace are available to you.
+To use the elements in the `cache` schema, you need to have the following preamble at the
+top of your Spring XML configuration file. The text in the following snippet references
+the correct schema so that the elements in the `cache` namespace are available to you:
  
+====
 [source,xml,indent=0]
 [subs="verbatim,quotes"]
 ----
@@ -319,3 +370,4 @@ the correct schema so that the tags in the `cache` namespace are available to yo
  
 	</beans>
 ----
+====

@@ -6805,12 +6805,13 @@ preamble of the XML configuration file. The following example shows how to do so
 	<?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:oxm="http://www.springframework.org/schema/oxm"
-		xsi:schemaLocation="
-			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
-			http://www.springframework.org/schema/oxm http://www.springframework.org/schema/oxm/spring-oxm.xsd"> <1>
+		xmlns:oxm="http://www.springframework.org/schema/oxm" <1>
+    xsi:schemaLocation="http://www.springframework.org/schema/beans
+      http://www.springframework.org/schema/beans/spring-beans.xsd
+      http://www.springframework.org/schema/oxm http://www.springframework.org/schema/oxm/spring-oxm.xsd"> <2>
 ----
 <1> Reference the `oxm` schema.
+<2> Specify the `oxm` schema location.
 ====
  
 Currently, the schema makes the following elements available:

@@ -74,15 +74,15 @@
  * <p>Also supports JSR-330's {@link javax.inject.Inject @Inject} annotation,
  * if available, as a direct alternative to Spring's own {@code @Autowired}.
  *
- * <p>Only one constructor (at max) of any given bean class may carry this
- * annotation with the 'required' parameter set to {@code true},
- * indicating <i>the</i> constructor to autowire when used as a Spring bean.
- * If multiple <i>non-required</i> constructors carry the annotation, they
- * will be considered as candidates for autowiring. The constructor with
- * the greatest number of dependencies that can be satisfied by matching
- * beans in the Spring container will be chosen. If none of the candidates
- * can be satisfied, then a default constructor (if present) will be used.
- * An annotated constructor does not have to be public.
+ * <p>Only one constructor (at max) of any given bean class may declare this annotation
+ * with the 'required' parameter set to {@code true}, indicating <i>the</i> constructor
+ * to autowire when used as a Spring bean. If multiple <i>non-required</i> constructors
+ * declare the annotation, they will be considered as candidates for autowiring.
+ * The constructor with the greatest number of dependencies that can be satisfied by
+ * matching beans in the Spring container will be chosen. If none of the candidates
+ * can be satisfied, then a primary/default constructor (if present) will be used.
+ * If a class only declares a single constructor to begin with, it will always be used,
+ * even if not annotated. An annotated constructor does not have to be public.
  *
  * <p>Fields are injected right after construction of a bean, before any
  * config methods are invoked. Such a config field does not have to be public.
@@ -161,11 +161,11 @@ public AutowiredAnnotationBeanPostProcessor() {
 	/**
 	 * Set the 'autowired' annotation type, to be used on constructors, fields,
 	 * setter methods and arbitrary config methods.
-	 * <p>The default autowired annotation type is the Spring-provided
-	 * {@link Autowired} annotation, as well as {@link Value}.
+	 * <p>The default autowired annotation type is the Spring-provided {@link Autowired}
+	 * annotation, as well as {@link Value}.
 	 * <p>This setter property exists so that developers can provide their own
-	 * (non-Spring-specific) annotation type to indicate that a member is
-	 * supposed to be autowired.
+	 * (non-Spring-specific) annotation type to indicate that a member is supposed
+	 * to be autowired.
 	 */
 	public void setAutowiredAnnotationType(Class<? extends Annotation> autowiredAnnotationType) {
 		Assert.notNull(autowiredAnnotationType, "'autowiredAnnotationType' must not be null");
@@ -176,11 +176,11 @@ public void setAutowiredAnnotationType(Class<? extends Annotation> autowiredAnno
 	/**
 	 * Set the 'autowired' annotation types, to be used on constructors, fields,
 	 * setter methods and arbitrary config methods.
-	 * <p>The default autowired annotation type is the Spring-provided
-	 * {@link Autowired} annotation, as well as {@link Value}.
+	 * <p>The default autowired annotation type is the Spring-provided {@link Autowired}
+	 * annotation, as well as {@link Value}.
 	 * <p>This setter property exists so that developers can provide their own
-	 * (non-Spring-specific) annotation types to indicate that a member is
-	 * supposed to be autowired.
+	 * (non-Spring-specific) annotation types to indicate that a member is supposed
+	 * to be autowired.
 	 */
 	public void setAutowiredAnnotationTypes(Set<Class<? extends Annotation>> autowiredAnnotationTypes) {
 		Assert.notEmpty(autowiredAnnotationTypes, "'autowiredAnnotationTypes' must not be empty");
@@ -189,8 +189,7 @@ public void setAutowiredAnnotationTypes(Set<Class<? extends Annotation>> autowir
 	}
  
 	/**
-	 * Set the name of a parameter of the annotation that specifies
-	 * whether it is required.
+	 * Set the name of a parameter of the annotation that specifies whether it is required.
 	 * @see #setRequiredParameterValue(boolean)
 	 */
 	public void setRequiredParameterName(String requiredParameterName) {
@@ -199,9 +198,8 @@ public void setRequiredParameterName(String requiredParameterName) {
  
 	/**
 	 * Set the boolean value that marks a dependency as required
-	 * <p>For example if using 'required=true' (the default),
-	 * this value should be {@code true}; but if using
-	 * 'optional=false', this value should be {@code false}.
+	 * <p>For example if using 'required=true' (the default), this value should be
+	 * {@code true}; but if using 'optional=false', this value should be {@code false}.
 	 * @see #setRequiredParameterName(String)
 	 */
 	public void setRequiredParameterValue(boolean requiredParameterValue) {
 methods
 .../commons/logging/LogFactoryService.java    | 30 ++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

@@ -1264,7 +1264,7 @@ programming model in JUnit 5):
 * <<integration-testing-annotations-junit-jupiter-springjunitconfig>>
 * <<integration-testing-annotations-junit-jupiter-springjunitwebconfig>>
 * <<integration-testing-annotations-junit-jupiter-enabledif>>
-* <<integration-testing-annotations-junit-jupiter=-disabledif>>
+* <<integration-testing-annotations-junit-jupiter-disabledif>>
  
  
  
@@ -1406,7 +1406,7 @@ example, you can create a custom `@EnabledOnMac` annotation as follows:
  
  
  
-[[integration-testing-annotations-junit-jupiter=-disabledif]]
+[[integration-testing-annotations-junit-jupiter-disabledif]]
 ===== `@DisabledIf`
  
 `@DisabledIf` is used to signal that the annotated JUnit Jupiter test class or test
@@ -1627,8 +1627,9 @@ configuration of individual JUnit Jupiter based test methods, as follows:
 ----
 ====
  
-For further details, see the <<core.adoc#annotation-programming-model,Spring
-Annotation Programming Model>>.
+For further details, see the
+https://github.com/spring-projects/spring-framework/wiki/Spring-Annotation-Programming-Model[Spring Annotation Programming Model]
+wiki page.
  
  
  
@@ -1670,9 +1671,8 @@ in turn, manages a `TestContext` that holds the context of the current test. The
 and delegates to `TestExecutionListener` implementations, which instrument the actual
 test execution by providing dependency injection, managing transactions, and so on. A
 `SmartContextLoader` is responsible for loading an `ApplicationContext` for a given test
-class. See the {api-spring-framework}[Javadoc] and the Spring test suite for further
-information and examples of various implementations.
- 
+class. See the {api-spring-framework}/test/context/package-summary.html[Javadoc] and the
+Spring test suite for further information and examples of various implementations.
  
  
 ===== `TestContext`
@@ -3860,7 +3860,7 @@ of `PlatformTransactionManager` within the test's `ApplicationContext`, you can
 qualifier by using `@Transactional("myTxMgr")` or `@Transactional(transactionManager =
 "myTxMgr")`, or `TransactionManagementConfigurer` can be implemented by an
 `@Configuration` class. Consult the
-{api-spring-framework}/test/context/transaction/TestContextTransactionUtils.html#retrieveTransactionManager[Javadoc
+{api-spring-framework}/test/context/transaction/TestContextTransactionUtils.html#retrieveTransactionManager-org.springframework.test.context.TestContext-java.lang.String-[Javadoc
 for `TestContextTransactionUtils.retrieveTransactionManager()`] for details on the
 algorithm used to look up a transaction manager in the test's `ApplicationContext`.
  
@@ -5295,8 +5295,8 @@ when using HTML-based views. This integration lets you:
 * Easily test HTML pages by using tools such as
   http://htmlunit.sourceforge.net/[HtmlUnit],
   http://seleniumhq.org/projects/webdriver/[WebDriver], and
-  http://www.gebish.org/manual/current/testing.html#spock_junit__testng[Geb] without the
-  need to deploy to a Servlet container.
+  http://www.gebish.org/manual/current/#spock-junit-testng[Geb] without the need to
+  deploy to a Servlet container.
 * Test JavaScript within pages.
 * Optionally, test using mock services to speed up testing.
 * Share logic between in-container end-to-end tests and out-of-container integration tests.
 src/docs/asciidoc/data-access.adoc | 46 +++++++++++++++++-------------
 1 file changed, 26 insertions(+), 20 deletions(-)

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2018 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.
@@ -17,21 +17,19 @@
 package org.springframework.beans.factory;
  
 /**
- * Marker superinterface indicating that a bean is eligible to be
- * notified by the Spring container of a particular framework object
- * through a callback-style method. Actual method signature is
- * determined by individual subinterfaces, but should typically
- * consist of just one void-returning method that accepts a single
- * argument.
+ * A marker superinterface indicating that a bean is eligible to be notified by the
+ * Spring container of a particular framework object through a callback-style method.
+ * The actual method signature is determined by individual subinterfaces but should
+ * typically consist of just one void-returning method that accepts a single argument.
  *
- * <p>Note that merely implementing {@link Aware} provides no default
- * functionality. Rather, processing must be done explicitly, for example
- * in a {@link org.springframework.beans.factory.config.BeanPostProcessor BeanPostProcessor}.
+ * <p>Note that merely implementing {@link Aware} provides no default functionality.
+ * Rather, processing must be done explicitly, for example in a
+ * {@link org.springframework.beans.factory.config.BeanPostProcessor}.
  * Refer to {@link org.springframework.context.support.ApplicationContextAwareProcessor}
- * and {@link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory}
- * for examples of processing {@code *Aware} interface callbacks.
+ * for an example of processing specific {@code *Aware} interface callbacks.
  *
  * @author Chris Beams
+ * @author Juergen Hoeller
  * @since 3.1
  */
 public interface Aware {

@@ -0,0 +1,206 @@
+/*
+ * Copyright 2002-2018 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.web.reactive.function.server;
+ 
+import java.util.Collections;
+ 
+import org.junit.Before;
+import org.junit.Test;
+ 
+import org.springframework.core.codec.StringDecoder;
+import org.springframework.http.codec.DecoderHttpMessageReader;
+import org.springframework.mock.http.server.reactive.test.MockServerHttpRequest;
+import org.springframework.mock.web.test.server.MockServerWebExchange;
+ 
+import static org.junit.Assert.*;
+ 
+/**
+ * @author Arjen Poutsma
+ */
+public class RequestPredicateAttributesTests {
+ 
+	private DefaultServerRequest request;
+ 
+	@Before
+	public void createRequest() {
+		MockServerHttpRequest request = MockServerHttpRequest.get("http://example.com/path").build();
+		MockServerWebExchange webExchange = MockServerWebExchange.from(request);
+		webExchange.getAttributes().put("exchange", "bar");
+ 
+		this.request = new DefaultServerRequest(webExchange,
+				Collections.singletonList(
+						new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes())));
+	}
+ 
+ 
+	@Test
+	public void negateSucceed() {
+		RequestPredicate predicate = new AddAttributePredicate(false, "predicate", "baz").negate();
+ 
+		boolean result = predicate.test(this.request);
+		assertTrue(result);
+ 
+		assertEquals("bar", this.request.attributes().get("exchange"));
+		assertEquals("baz", this.request.attributes().get("predicate"));
+	}
+ 
+	@Test
+	public void negateFail() {
+		RequestPredicate predicate = new AddAttributePredicate(true, "predicate", "baz").negate();
+ 
+		boolean result = predicate.test(this.request);
+		assertFalse(result);
+ 
+		assertEquals("bar", this.request.attributes().get("exchange"));
+		assertFalse(this.request.attributes().containsKey("baz"));
+	}
+ 
+	@Test
+	public void andBothSucceed() {
+		RequestPredicate left = new AddAttributePredicate(true, "left", "baz");
+		RequestPredicate right = new AddAttributePredicate(true, "right", "qux");
+		RequestPredicate predicate = new RequestPredicates.AndRequestPredicate(left, right);
+ 
+		boolean result = predicate.test(this.request);
+		assertTrue(result);
+ 
+		assertEquals("bar", this.request.attributes().get("exchange"));
+		assertEquals("baz", this.request.attributes().get("left"));
+		assertEquals("qux", this.request.attributes().get("right"));
+	}
+ 
+	@Test
+	public void andLeftSucceed() {
+		RequestPredicate left = new AddAttributePredicate(true, "left", "bar");
+		RequestPredicate right = new AddAttributePredicate(false, "right", "qux");
+		RequestPredicate predicate = new RequestPredicates.AndRequestPredicate(left, right);
+ 
+		boolean result = predicate.test(this.request);
+		assertFalse(result);
+ 
+		assertEquals("bar", this.request.attributes().get("exchange"));
+		assertFalse(this.request.attributes().containsKey("left"));
+		assertFalse(this.request.attributes().containsKey("right"));
+	}
+ 
+	@Test
+	public void andRightSucceed() {
+		RequestPredicate left = new AddAttributePredicate(false, "left", "bar");
+		RequestPredicate right = new AddAttributePredicate(true, "right", "qux");
+		RequestPredicate predicate = new RequestPredicates.AndRequestPredicate(left, right);
+ 
+		boolean result = predicate.test(this.request);
+		assertFalse(result);
+ 
+		assertEquals("bar", this.request.attributes().get("exchange"));
+		assertFalse(this.request.attributes().containsKey("left"));
+		assertFalse(this.request.attributes().containsKey("right"));
+	}
+ 
+	@Test
+	public void andBothFail() {
+		RequestPredicate left = new AddAttributePredicate(false, "left", "bar");
+		RequestPredicate right = new AddAttributePredicate(false, "right", "qux");
+		RequestPredicate predicate = new RequestPredicates.AndRequestPredicate(left, right);
+ 
+		boolean result = predicate.test(this.request);
+		assertFalse(result);
+ 
+		assertEquals("bar", this.request.attributes().get("exchange"));
+		assertFalse(this.request.attributes().containsKey("left"));
+		assertFalse(this.request.attributes().containsKey("right"));
+	}
+ 
+	@Test
+	public void orBothSucceed() {
+		RequestPredicate left = new AddAttributePredicate(true, "left", "baz");
+		RequestPredicate right = new AddAttributePredicate(true, "right", "qux");
+		RequestPredicate predicate = new RequestPredicates.OrRequestPredicate(left, right);
+ 
+		boolean result = predicate.test(this.request);
+		assertTrue(result);
+ 
+		assertEquals("bar", this.request.attributes().get("exchange"));
+		assertEquals("baz", this.request.attributes().get("left"));
+		assertFalse(this.request.attributes().containsKey("right"));
+	}
+ 
+	@Test
+	public void orLeftSucceed() {
+		RequestPredicate left = new AddAttributePredicate(true, "left", "baz");
+		RequestPredicate right = new AddAttributePredicate(false, "right", "qux");
+		RequestPredicate predicate = new RequestPredicates.OrRequestPredicate(left, right);
+ 
+		boolean result = predicate.test(this.request);
+		assertTrue(result);
+ 
+		assertEquals("bar", this.request.attributes().get("exchange"));
+		assertEquals("baz", this.request.attributes().get("left"));
+		assertFalse(this.request.attributes().containsKey("right"));
+	}
+ 
+	@Test
+	public void orRightSucceed() {
+		RequestPredicate left = new AddAttributePredicate(false, "left", "baz");
+		RequestPredicate right = new AddAttributePredicate(true, "right", "qux");
+		RequestPredicate predicate = new RequestPredicates.OrRequestPredicate(left, right);
+ 
+		boolean result = predicate.test(this.request);
+		assertTrue(result);
+ 
+		assertEquals("bar", this.request.attributes().get("exchange"));
+		assertFalse(this.request.attributes().containsKey("left"));
+		assertEquals("qux", this.request.attributes().get("right"));
+	}
+ 
+	@Test
+	public void orBothFail() {
+		RequestPredicate left = new AddAttributePredicate(false, "left", "baz");
+		RequestPredicate right = new AddAttributePredicate(false, "right", "qux");
+		RequestPredicate predicate = new RequestPredicates.OrRequestPredicate(left, right);
+ 
+		boolean result = predicate.test(this.request);
+		assertFalse(result);
+ 
+		assertEquals("bar", this.request.attributes().get("exchange"));
+		assertFalse(this.request.attributes().containsKey("baz"));
+		assertFalse(this.request.attributes().containsKey("quux"));
+	}
+ 
+ 
+	private static class AddAttributePredicate implements RequestPredicate {
+ 
+		private boolean result;
+ 
+		private final String key;
+ 
+		private final String value;
+ 
+		private AddAttributePredicate(boolean result, String key, String value) {
+			this.result = result;
+			this.key = key;
+			this.value = value;
+		}
+ 
+		@Override
+		public boolean test(ServerRequest request) {
+			request.attributes().put(key, value);
+			return this.result;
+		}
+	}
+ 
+}
 .../function/server/RouterFunctions.java      |  7 +-
 .../DispatcherHandlerIntegrationTests.java    | 96 +++++++++++++++++++
 2 files changed, 101 insertions(+), 2 deletions(-)
 create mode 100644 spring-webflux/src/test/java/org/springframework/web/reactive/function/server/support/DispatcherHandlerIntegrationTests.java

@@ -19,13 +19,12 @@ The `tx` tags deal with configuring all of those beans in Spring's comprehensive
 for transactions. These tags are covered in the chapter entitled
 <<data-access.adoc#transaction,Transaction Management>>.
  
-TIP: We strongly encourag you to look at the `'spring-tx.xsd'` file that ships with the
+TIP: We strongly encourage you to look at the `'spring-tx.xsd'` file that ships with the
 Spring distribution. This file contains the XML Schema for Spring's transaction
 configuration and covers all of the various elements in the `tx` namespace, including
-attribute defaults and similar information. This file is documented inline, and, thus, the
-information is not repeated here in the interests of adhering to the DRY (Don't Repeat
-Yourself) principle.
-====
+attribute defaults and similar information. This file is documented inline, and, thus,
+the information is not repeated here in the interests of adhering to the DRY (Don't
+Repeat Yourself) principle.
  
 In the interest of completeness, to use the elements in the `tx` schema, you need to have
 the following preamble at the top of your Spring XML configuration file. The text in the
@@ -51,10 +50,11 @@ are available to you:
 <2> Specify the location (with other schema locations).
 ====
  
-NOTE: Often, when you use the elements in the `tx` namespace, you are also using the elements from the
-`aop` namespace (since the declarative transaction support in Spring is implemented
-by using AOP). The preceding XML snippet contains the relevant lines needed to reference the
-`aop` schema so that the elements in the `aop` namespace are available to you.
+NOTE: Often, when you use the elements in the `tx` namespace, you are also using the
+elements from the `aop` namespace (since the declarative transaction support in Spring is
+implemented by using AOP). The preceding XML snippet contains the relevant lines needed
+to reference the `aop` schema so that the elements in the `aop` namespace are available
+to you.
  
  
  
@@ -63,12 +63,12 @@ by using AOP). The preceding XML snippet contains the relevant lines needed to r
  
 The `jdbc` elements let you quickly configure an embedded database or initialize an
 existing data source. These elements are documented in
-<<data-access.adoc#jdbc-embedded-database-support,Embedded Database Support>>
-and <<data-access.adoc#jdbc-initializing-datasource,Initializing a DataSource>>, respectively.
+<<data-access.adoc#jdbc-embedded-database-support,Embedded Database Support>> and
+<<data-access.adoc#jdbc-initializing-datasource,Initializing a DataSource>>, respectively.
  
-To use the elements in the `jdbc` schema, you need to have the following preamble at the top
-of your Spring XML configuration file. The text in the following snippet references the
-correct schema so that the elements in the `jdbc` namespace are available to you:
+To use the elements in the `jdbc` schema, you need to have the following preamble at the
+top of your Spring XML configuration file. The text in the following snippet references
+the correct schema so that the elements in the `jdbc` namespace are available to you:
  
 ====
 [source,xml,indent=0]

@@ -23,15 +23,21 @@
 import java.lang.annotation.Target;
  
 /**
- * Marks a constructor, field, setter method or config method as to be autowired
- * by Spring's dependency injection facilities.
+ * Marks a constructor, field, setter method or config method as to be autowired by
+ * Spring's dependency injection facilities.
  *
- * <p>Only one constructor (at max) of any given bean class may carry this annotation,
- * indicating the constructor to autowire when used as a Spring bean. Such a
- * constructor does not have to be public.
+ * <p>Only one constructor (at max) of any given bean class may declare this annotation
+ * with the 'required' parameter set to {@code true}, indicating <i>the</i> constructor
+ * to autowire when used as a Spring bean. If multiple <i>non-required</i> constructors
+ * declare the annotation, they will be considered as candidates for autowiring.
+ * The constructor with the greatest number of dependencies that can be satisfied by
+ * matching beans in the Spring container will be chosen. If none of the candidates
+ * can be satisfied, then a primary/default constructor (if present) will be used.
+ * If a class only declares a single constructor to begin with, it will always be used,
+ * even if not annotated. An annotated constructor does not have to be public.
  *
- * <p>Fields are injected right after construction of a bean, before any config
- * methods are invoked. Such a config field does not have to be public.
+ * <p>Fields are injected right after construction of a bean, before any config methods
+ * are invoked. Such a config field does not have to be public.
  *
  * <p>Config methods may have an arbitrary name and any number of arguments; each of
  * those arguments will be autowired with a matching bean in the Spring container.

@@ -18,13 +18,11 @@
  
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.List;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
  
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.ApplicationContext;
 import org.springframework.core.annotation.AnnotationAwareOrderComparator;
 import org.springframework.http.codec.ServerCodecConfigurer;
@@ -158,12 +156,16 @@ public static WebHttpHandlerBuilder applicationContext(ApplicationContext contex
 		WebHttpHandlerBuilder builder = new WebHttpHandlerBuilder(
 				context.getBean(WEB_HANDLER_BEAN_NAME, WebHandler.class), context);
  
-		// Autowire lists for @Bean + @Order
- 
-		SortedBeanContainer container = new SortedBeanContainer();
-		context.getAutowireCapableBeanFactory().autowireBean(container);
-		builder.filters(filters -> filters.addAll(container.getFilters()));
-		builder.exceptionHandlers(handlers -> handlers.addAll(container.getExceptionHandlers()));
+		List<WebFilter> webFilters = context
+				.getBeanProvider(WebFilter.class)
+				.orderedStream()
+				.collect(Collectors.toList());
+		builder.filters(filters -> filters.addAll(webFilters));
+		List<WebExceptionHandler> exceptionHandlers = context
+				.getBeanProvider(WebExceptionHandler.class)
+				.orderedStream()
+				.collect(Collectors.toList());
+		builder.exceptionHandlers(handlers -> handlers.addAll(exceptionHandlers));
  
 		try {
 			builder.sessionManager(
@@ -389,30 +391,4 @@ public WebHttpHandlerBuilder clone() {
 		return new WebHttpHandlerBuilder(this);
 	}
  
- 
-	private static class SortedBeanContainer {
- 
-		private List<WebFilter> filters = Collections.emptyList();
- 
-		private List<WebExceptionHandler> exceptionHandlers = Collections.emptyList();
- 
-		@Autowired(required = false)
-		public void setFilters(List<WebFilter> filters) {
-			this.filters = filters;
-		}
- 
-		public List<WebFilter> getFilters() {
-			return this.filters;
-		}
- 
-		@Autowired(required = false)
-		public void setExceptionHandlers(List<WebExceptionHandler> exceptionHandlers) {
-			this.exceptionHandlers = exceptionHandlers;
-		}
- 
-		public List<WebExceptionHandler> getExceptionHandlers() {
-			return this.exceptionHandlers;
-		}
-	}
- 
 }

@@ -1,24 +1,46 @@
+/*
+ * Copyright 2002-2017 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.web.cors.reactive;
  
  
 import java.io.IOException;
 import java.util.Arrays;
- 
 import javax.servlet.ServletException;
  
 import org.junit.Before;
 import org.junit.Test;
 import reactor.core.publisher.Mono;
  
+import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
 import org.springframework.mock.http.server.reactive.test.MockServerHttpRequest;
-import org.springframework.mock.http.server.reactive.test.MockServerWebExchange;
+import org.springframework.mock.web.test.server.MockServerWebExchange;
 import org.springframework.web.cors.CorsConfiguration;
 import org.springframework.web.server.WebFilterChain;
  
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
-import static org.springframework.http.HttpHeaders.*;
+import static org.springframework.http.HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS;
+import static org.springframework.http.HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN;
+import static org.springframework.http.HttpHeaders.ACCESS_CONTROL_EXPOSE_HEADERS;
+import static org.springframework.http.HttpHeaders.ACCESS_CONTROL_MAX_AGE;
+import static org.springframework.http.HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS;
+import static org.springframework.http.HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD;
+import static org.springframework.http.HttpHeaders.HOST;
+import static org.springframework.http.HttpHeaders.ORIGIN;
  
 /**
  * Unit tests for {@link CorsWebFilter}.
@@ -50,19 +72,19 @@ public void validActualRequest() {
 				.header(ORIGIN, "http://domain2.com")
 				.header("header2", "foo")
 				.build();
-		MockServerWebExchange exchange = new MockServerWebExchange(request);
  
 		WebFilterChain filterChain = (filterExchange) -> {
 			try {
-				assertEquals("http://domain2.com", filterExchange.getResponse().getHeaders().getFirst(ACCESS_CONTROL_ALLOW_ORIGIN));
-				assertEquals("header3, header4", filterExchange.getResponse().getHeaders().getFirst(ACCESS_CONTROL_EXPOSE_HEADERS));
+				HttpHeaders headers = filterExchange.getResponse().getHeaders();
+				assertEquals("http://domain2.com", headers.getFirst(ACCESS_CONTROL_ALLOW_ORIGIN));
+				assertEquals("header3, header4", headers.getFirst(ACCESS_CONTROL_EXPOSE_HEADERS));
 			} catch (AssertionError ex) {
 				return Mono.error(ex);
 			}
 			return Mono.empty();
  
 		};
-		filter.filter(exchange, filterChain);
+		filter.filter(MockServerWebExchange.from(request), filterChain);
 	}
  
 	@Test
@@ -74,9 +96,10 @@ public void invalidActualRequest() throws ServletException, IOException {
 				.header(ORIGIN, "http://domain2.com")
 				.header("header2", "foo")
 				.build();
-		MockServerWebExchange exchange = new MockServerWebExchange(request);
+		MockServerWebExchange exchange = MockServerWebExchange.from(request);
  
-		WebFilterChain filterChain = (filterExchange) -> Mono.error(new AssertionError("Invalid requests must not be forwarded to the filter chain"));
+		WebFilterChain filterChain = (filterExchange) -> Mono.error(
+				new AssertionError("Invalid requests must not be forwarded to the filter chain"));
 		filter.filter(exchange, filterChain);
  
 		assertNull(exchange.getResponse().getHeaders().getFirst(ACCESS_CONTROL_ALLOW_ORIGIN));
@@ -92,15 +115,17 @@ public void validPreFlightRequest() throws ServletException, IOException {
 				.header(ACCESS_CONTROL_REQUEST_METHOD, HttpMethod.GET.name())
 				.header(ACCESS_CONTROL_REQUEST_HEADERS, "header1, header2")
 				.build();
-		MockServerWebExchange exchange = new MockServerWebExchange(request);
+		MockServerWebExchange exchange = MockServerWebExchange.from(request);
  
-		WebFilterChain filterChain = (filterExchange) -> Mono.error(new AssertionError("Preflight requests must not be forwarded to the filter chain"));
+		WebFilterChain filterChain = (filterExchange) -> Mono.error(
+				new AssertionError("Preflight requests must not be forwarded to the filter chain"));
 		filter.filter(exchange, filterChain);
  
-		assertEquals("http://domain2.com", exchange.getResponse().getHeaders().getFirst(ACCESS_CONTROL_ALLOW_ORIGIN));
-		assertEquals("header1, header2", exchange.getResponse().getHeaders().getFirst(ACCESS_CONTROL_ALLOW_HEADERS));
-		assertEquals("header3, header4", exchange.getResponse().getHeaders().getFirst(ACCESS_CONTROL_EXPOSE_HEADERS));
-		assertEquals(123L, Long.parseLong(exchange.getResponse().getHeaders().getFirst(ACCESS_CONTROL_MAX_AGE)));
+		HttpHeaders headers = exchange.getResponse().getHeaders();
+		assertEquals("http://domain2.com", headers.getFirst(ACCESS_CONTROL_ALLOW_ORIGIN));
+		assertEquals("header1, header2", headers.getFirst(ACCESS_CONTROL_ALLOW_HEADERS));
+		assertEquals("header3, header4", headers.getFirst(ACCESS_CONTROL_EXPOSE_HEADERS));
+		assertEquals(123L, Long.parseLong(headers.getFirst(ACCESS_CONTROL_MAX_AGE)));
 	}
  
 	@Test
@@ -113,9 +138,11 @@ public void invalidPreFlightRequest() throws ServletException, IOException {
 				.header(ACCESS_CONTROL_REQUEST_METHOD, HttpMethod.DELETE.name())
 				.header(ACCESS_CONTROL_REQUEST_HEADERS, "header1, header2")
 				.build();
-		MockServerWebExchange exchange = new MockServerWebExchange(request);
+		MockServerWebExchange exchange = MockServerWebExchange.from(request);
+ 
+		WebFilterChain filterChain = (filterExchange) -> Mono.error(
+				new AssertionError("Preflight requests must not be forwarded to the filter chain"));
  
-		WebFilterChain filterChain = (filterExchange) -> Mono.error(new AssertionError("Preflight requests must not be forwarded to the filter chain"));
 		filter.filter(exchange, filterChain);
  
 		assertNull(exchange.getResponse().getHeaders().getFirst(ACCESS_CONTROL_ALLOW_ORIGIN));

@@ -25,14 +25,20 @@
 import org.springframework.core.ReactiveAdapterRegistry;
 import org.springframework.http.MediaType;
 import org.springframework.mock.http.server.reactive.test.MockServerHttpRequest;
-import org.springframework.mock.http.server.reactive.test.MockServerWebExchange;
+import org.springframework.mock.web.test.server.MockServerWebExchange;
 import org.springframework.web.reactive.HandlerMapping;
 import org.springframework.web.reactive.accept.FixedContentTypeResolver;
 import org.springframework.web.reactive.accept.HeaderContentTypeResolver;
 import org.springframework.web.reactive.accept.RequestedContentTypeResolver;
  
-import static org.junit.Assert.*;
-import static org.springframework.http.MediaType.*;
+import static org.junit.Assert.assertEquals;
+import static org.springframework.http.MediaType.ALL;
+import static org.springframework.http.MediaType.APPLICATION_JSON_UTF8;
+import static org.springframework.http.MediaType.APPLICATION_OCTET_STREAM;
+import static org.springframework.http.MediaType.IMAGE_GIF;
+import static org.springframework.http.MediaType.IMAGE_JPEG;
+import static org.springframework.http.MediaType.IMAGE_PNG;
+import static org.springframework.http.MediaType.TEXT_PLAIN;
  
 /**
  * Unit tests for {@link HandlerResultHandlerSupport}.
@@ -48,7 +54,7 @@ public class HandlerResultHandlerTests {
 	public void usesContentTypeResolver() throws Exception {
 		TestResultHandler resultHandler = new TestResultHandler(new FixedContentTypeResolver(IMAGE_GIF));
 		List<MediaType> mediaTypes = Arrays.asList(IMAGE_JPEG, IMAGE_GIF, IMAGE_PNG);
-		MockServerWebExchange exchange = MockServerHttpRequest.get("/path").toExchange();
+		MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/path").build());
 		MediaType actual = resultHandler.selectMediaType(exchange, () -> mediaTypes);
  
 		assertEquals(IMAGE_GIF, actual);
@@ -56,7 +62,7 @@ public void usesContentTypeResolver() throws Exception {
  
 	@Test
 	public void producibleMediaTypesRequestAttribute() throws Exception {
-		MockServerWebExchange exchange = MockServerHttpRequest.get("/path").toExchange();
+		MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/path").build());
 		exchange.getAttributes().put(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE, Collections.singleton(IMAGE_GIF));
  
 		List<MediaType> mediaTypes = Arrays.asList(IMAGE_JPEG, IMAGE_GIF, IMAGE_PNG);
@@ -67,9 +73,9 @@ public void producibleMediaTypesRequestAttribute() throws Exception {
  
 	@Test  // SPR-9160
 	public void sortsByQuality() throws Exception {
-		MockServerWebExchange exchange = MockServerHttpRequest.get("/path")
+		MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/path")
 				.header("Accept", "text/plain; q=0.5, application/json")
-				.toExchange();
+				.build());
  
 		List<MediaType> mediaTypes = Arrays.asList(TEXT_PLAIN, APPLICATION_JSON_UTF8);
 		MediaType actual = this.resultHandler.selectMediaType(exchange, () -> mediaTypes);
@@ -81,7 +87,7 @@ public void sortsByQuality() throws Exception {
 	public void charsetFromAcceptHeader() throws Exception {
 		MediaType text8859 = MediaType.parseMediaType("text/plain;charset=ISO-8859-1");
 		MediaType textUtf8 = MediaType.parseMediaType("text/plain;charset=UTF-8");
-		MockServerWebExchange exchange = MockServerHttpRequest.get("/path").accept(text8859).toExchange();
+		MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/path").accept(text8859).build());
 		MediaType actual = this.resultHandler.selectMediaType(exchange, () -> Collections.singletonList(textUtf8));
  
 		assertEquals(text8859, actual);
@@ -90,7 +96,7 @@ public void charsetFromAcceptHeader() throws Exception {
 	@Test // SPR-12894
 	public void noConcreteMediaType() throws Exception {
 		List<MediaType> producible = Collections.singletonList(ALL);
-		MockServerWebExchange exchange = MockServerHttpRequest.get("/path").toExchange();
+		MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/path").build());
 		MediaType actual = this.resultHandler.selectMediaType(exchange, () -> producible);
  
 		assertEquals(APPLICATION_OCTET_STREAM, actual);