Type Parameters:
T - the type of the handler function to route to
Functional Interface:
This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
```
@FunctionalInterface
public interface RouterFunction<T extends ServerResponse>
```
Represents a function that routes to a handler function.
Since:
5.0
Author:
Arjen Poutsma
See Also:
RouterFunctions

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method	Description
`default void`	`accept(RouterFunctions.Visitor visitor)`	Accept the given visitor.
`default RouterFunction<T>`	`and(RouterFunction<T> other)`	Return a composed routing function that first invokes this function, and then invokes the `other` function (of the same response type `T`) if this route had no result.
`default RouterFunction<T>`	`andNest(RequestPredicate predicate, RouterFunction<T> routerFunction)`	Return a composed routing function that routes to the given router function if this route does not match and the given request predicate applies.
`default RouterFunction<?>`	`andOther(RouterFunction<?> other)`	Return a composed routing function that first invokes this function, and then invokes the `other` function (of a different response type) if this route had no result.
`default RouterFunction<T>`	`andRoute(RequestPredicate predicate, HandlerFunction<T> handlerFunction)`	Return a composed routing function that routes to the given handler function if this route does not match and the given request predicate applies.
`default <S extends ServerResponse> RouterFunction<S>`	`filter(HandlerFilterFunction<T,S> filterFunction)`	Filter all handler functions routed by this function with the given filter function.
`reactor.core.publisher.Mono<HandlerFunction<T>>`	`route(ServerRequest request)`	Return the handler function that matches the given request.

- Method Detail
  - route
```
reactor.core.publisher.Mono<HandlerFunction<T>> route(ServerRequest request)
```
    Return the handler function that matches the given request.
    Parameters:
    request - the request to route
    Returns:
    an Mono describing the HandlerFunction that matches this request, or an empty Mono if there is no match
  - and
```
default RouterFunction<T> and(RouterFunction<T> other)
```
    Return a composed routing function that first invokes this function, and then invokes the other function (of the same response type T) if this route had no result.
    Parameters:
    other - the function of type T to apply when this function has no result
    Returns:
    a composed function that first routes with this function and then the other function if this function has no result
    See Also:
    andOther(RouterFunction)
  - andOther
```
default RouterFunction<?> andOther(RouterFunction<?> other)
```
    Return a composed routing function that first invokes this function, and then invokes the other function (of a different response type) if this route had no result.
    Parameters:
    other - the function to apply when this function has no result
    Returns:
    a composed function that first routes with this function and then the other function if this function has no result
    See Also:
    and(RouterFunction)
  - andRoute
```
default RouterFunction<T> andRoute(RequestPredicate predicate,
                                   HandlerFunction<T> handlerFunction)
```
    Return a composed routing function that routes to the given handler function if this route does not match and the given request predicate applies. This method is a convenient combination of and(RouterFunction) and RouterFunctions.route(RequestPredicate, HandlerFunction).
    Parameters:
    predicate - the predicate to test if this route does not match
    handlerFunction - the handler function to route to if this route does not match and the predicate applies
    Returns:
    a composed function that route to handlerFunction if this route does not match and if predicate applies
  - andNest
```
default RouterFunction<T> andNest(RequestPredicate predicate,
                                  RouterFunction<T> routerFunction)
```
    Return a composed routing function that routes to the given router function if this route does not match and the given request predicate applies. This method is a convenient combination of and(RouterFunction) and RouterFunctions.nest(RequestPredicate, RouterFunction).
    Parameters:
    predicate - the predicate to test if this route does not match
    routerFunction - the router function to route to if this route does not match and the predicate applies
    Returns:
    a composed function that route to routerFunction if this route does not match and if predicate applies
  - filter
```
default <S extends ServerResponse> RouterFunction<S> filter(HandlerFilterFunction<T,S> filterFunction)
```
    Filter all handler functions routed by this function with the given filter function.
    Type Parameters:
    S - the filter return type
    Parameters:
    filterFunction - the filter to apply
    Returns:
    the filtered routing function
  - accept
```
default void accept(RouterFunctions.Visitor visitor)
```
    Accept the given visitor. Default implementation calls RouterFunctions.Visitor.unknown(RouterFunction); composed RouterFunction implementations are expected to call accept for all components that make up this router function.
    Parameters:
    visitor - the visitor to accept

Interface RouterFunction<T extends ServerResponse>

Method Summary

Method Detail

route

and

andOther

andRoute

andNest

filter

accept