org.springframework.web.reactive.function.server

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

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and 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.
    `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 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

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