Package org.springframework.web.servlet.function

# Interface RouterFunction<T extends ServerResponse>

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.2
Author:
  Arjen Poutsma
See Also:
  - `RouterFunctions`

## Method Summary

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.
`Optional<HandlerFunction<T>>`
`route(ServerRequest request)`
Return the handler function that matches the given request.
`default RouterFunction<T>`
`withAttribute(String name, Object value)`
Return a new routing function with the given attribute.
`default RouterFunction<T>`
`withAttributes(Consumer<Map<String,Object>> attributesConsumer)`
Return a new routing function with attributes manipulated with the given consumer.

## Method Details

### route

Optional<HandlerFunction<T>> route(ServerRequest request)
Return the handler function that matches the given request.

Parameters:
  `request` - the request to route
Returns:
  an `Optional` describing the `HandlerFunction` that matches this request, or an empty `Optional` 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

### withAttribute

default RouterFunction<T> withAttribute(String name, Object value)
Return a new routing function with the given attribute.

Parameters:
  `name` - the attribute name
  `value` - the attribute value
Returns:
  a function that has the specified attributes
Since:
  5.3

### withAttributes

default RouterFunction<T> withAttributes(Consumer<Map<String,Object>> attributesConsumer)
Return a new routing function with attributes manipulated with the given consumer.

The map provided to the consumer is "live", so that the consumer can be used to overwrite existing attributes, remove attributes, or use any of the other `Map` methods.

Parameters:
  `attributesConsumer` - a function that consumes the attributes map
Returns:
  this builder
Since:
  5.3

### 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.

The 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