anchor.diff:  You can then use the returned `HttpHandler` with a number of server adapters by following
   <<web-reactive.adoc#webflux-httphandler,HttpHandler>> for server-specific instructions.
   
  -A more advanced option is to run with a
  +A more typical option, also used by Spring Boot, is to run with a
   <<web-reactive.adoc#webflux-dispatcher-handler,`DispatcherHandler`>>-based setup through the
   <<web-reactive.adoc#webflux-config>>, which uses Spring configuration to declare the
   components required to process requests. The WebFlux Java configuration declares the following
  
positive.code: 
  
  [[webflux-fn-handler-filter-function]]
  == `HandlerFilterFunction`
  
  You can filter routes mapped by a router function by calling
  `RouterFunction.filter(HandlerFilterFunction)`, where `HandlerFilterFunction` is essentially a
  function that takes a `ServerRequest` and `HandlerFunction` and returns a `ServerResponse`.
  The handler function parameter represents the next element in the chain. This is typically the
  `HandlerFunction` that is routed to, but it can also be another `FilterFunction` if multiple filters
  are applied.
  With annotations, you can achieve similar functionality by using `@ControllerAdvice`, a `ServletFilter`, or both.
  Now we can add a simple security filter to our route, assuming that we have a `SecurityManager` that
  can determine whether a particular path is allowed. The following example shows how to do so:
  
  ====
  [source,java,indent=0]
  [subs="verbatim,quotes"]
  ----
  import static org.springframework.http.HttpStatus.UNAUTHORIZED;
  
  SecurityManager securityManager = ...
  RouterFunction<ServerResponse> route = ...
  
  RouterFunction<ServerResponse> filteredRoute =
  	route.filter((request, next) -> {
  		if (securityManager.allowAccessTo(request.path())) {
  			return next.handle(request);
  		}
  		else {
  			return ServerResponse.status(UNAUTHORIZED).build();
  		}
    });
  ----
  ====
  
  The preceding example demonstrates that invoking the `next.handle(ServerRequest)` is optional. We
  allow only the handler function to be executed when access is allowed.
  
  NOTE: CORS support for functional endpoints is provided through a dedicated <<webflux-cors-webfilter,`CorsWebFilter`>>.
  
negative.code: ----
  ====
  
  That is convenient, but in an application we need multiple functions, and multiple inline
  lambda's can get messy.
  Therefore, it is useful to group related handler functions together into a handler class, which
  has a similar role as  `@Controller` in an annotation-based application.
  For example, the following class exposes a reactive `Person` repository:
  
  ====
  [source,java,indent=0]
  