http4k-core/org.http4k.routing

Package-level declarations

Types

interface Matcher : Function1<String, Boolean>

data class PathMethod(val path: String, val method: Method)

data class RequestWithContext(val delegate: Request, val context: Map<String, Any?> = emptyMap()) : Request, RoutedMessage

ResourceLoader

fun interface ResourceLoader

Looks up contents of a resource path.

ResponseWithContext

data class ResponseWithContext(val delegate: Response, val context: Map<String, Any> = emptyMap()) : Response, RoutedMessage

ReverseProxyHostMatcher

fun interface ReverseProxyHostMatcher

A ReverseProxyHostMatcher is used to determine how the host header is matched against the extracted host from the request.

RoutedMessage

interface RoutedMessage

RouteMatcher

interface RouteMatcher<R, F>

Router

interface Router

RouterDescription

data class RouterDescription(val description: String)

RoutingHandler

abstract class RoutingHandler<R, F, Self : RouteMatcher<R, F>>(val routes: List<RouteMatcher<R, F>>, copy: (List<RouteMatcher<R, F>>) -> Self) : Function1<Request, R> , RouteMatcher<R, F>

Composite handler which can potentially service many different URL patterns. Should return a specified Response if it cannot service a particular Request.

RoutingHttpHandler

class RoutingHttpHandler(routes: List<RouteMatcher<Response, Filter>>) : RoutingHandler<Response, Filter, RoutingHttpHandler>

RoutingMatch

data class RoutingMatch<R>(priority: Int, description: RouterDescription, handler: (Request) -> R) : Comparable<RoutingMatch<R>> , Function1<Request, R>

RoutingResult

sealed interface RoutingResult

SimpleRouteMatcher

data class SimpleRouteMatcher(router: Router, handler: HttpHandler, filter: Filter = Filter.NoOp) : RouteMatcher<Response, Filter>

StaticRouteMatcher

data class StaticRouteMatcher(pathSegments: String, resourceLoader: ResourceLoader, extraFileExtensionToContentTypes: Map<String, ContentType>, router: Router = All, filter: Filter = Filter.NoOp) : RouteMatcher<Response, Filter>

TemplatedHttpRoute

class TemplatedHttpRoute(uriTemplate: UriTemplate, handler: HttpHandler, router: Router = All, filter: Filter = Filter.NoOp) : TemplatedRoute<Response, Filter, TemplatedHttpRoute>

TemplatedRoute

abstract class TemplatedRoute<R, F : ((Request) -> R) -> (Request) -> R, Self : RouteMatcher<R, F>>(uriTemplate: UriTemplate, handler: (Request) -> R, router: Router, filter: F, responseFor: (Status) -> R, addUriTemplateFilter: ((Request) -> R) -> (Request) -> R) : RouteMatcher<R, F>

Applies the generic templating routing logic regardless of protocol

Properties

All

val All: Router

orElse

val orElse: Router

Functions

accepting

infix fun String.accepting(contentType: ContentType): Router

Ensure the request is accepting a specific content type

and

infix fun String.and(router: Router): Router

Bind a path and another router together

fun Method.and(router: Router): Router

fun Router.and(other: Router): Router

fun RoutingHttpHandler.and(router: Router): RoutingHttpHandler

asRouter

fun Method.asRouter(): Router

fun (Request) -> Boolean.asRouter(name: String = ""): Router

bind

infix fun String.bind(action: HttpHandler): RoutingHttpHandler

infix fun String.bind(method: Method): PathMethod

infix fun String.bind(httpHandler: RoutingHttpHandler): RoutingHttpHandler

infix fun Method.bind(handler: HttpHandler): RoutingHttpHandler

infix fun Router.bind(handler: HttpHandler): RoutingHttpHandler

infix fun Router.bind(handler: RoutingHttpHandler): RoutingHttpHandler

body

@JvmName(name = "bodyMatches")

fun body(fn: (String) -> Boolean): Router

Ensure body string matches predicate

fun body(fn: (Body) -> Boolean): Router

Ensure body matches predicate

contentLanguages

fun contentLanguages(routes: List<Pair<Locale, HttpHandler>>): HttpHandler

fun contentLanguages(vararg routes: Pair<Locale, HttpHandler>): HttpHandler

Route by proactive negotiation of content language.

header

fun header(name: String, fn: (String) -> Boolean): Router

fun header(name: String, value: String): Router

Apply routing predicate to a header

headers

fun headers(vararg names: String): Router

Ensure all headers are present

not

fun Router.not(): Router

fun Router.or(other: Router): Router

path

fun Request.path(name: String): String?

proactiveContentNegotiation

fun <Range : Any, OptionId : Any> proactiveContentNegotiation(acceptBy: Lens<HttpMessage, PriorityList<Range>?>, reportBy: BiDiLens<HttpMessage, OptionId?>, match: (Range, OptionId) -> Boolean, bindings: List<Pair<OptionId, HttpHandler>>): HttpHandler

A generic implementation of routing by proactive content negotiation. See RFC 9110, Section 12.1

queries

fun queries(vararg names: String): Router

Ensure all queries are present and not null

queriesFrom

fun queriesFrom(uri: Uri): Router

Ensure all queries are present and match what is in the Uri

query

fun query(name: String): Router

Ensure query is present - even with no value

fun query(name: String, fn: (String) -> Boolean): Router

fun query(name: String, value: String): Router

Apply routing predicate to a query

resolvedWithinRoot

fun String.resolvedWithinRoot(): String?

reverseProxy

fun reverseProxy(vararg hostToHandler: Pair<String, HttpHandler>, matcher: ReverseProxyHostMatcher = Exact): HttpHandler

Simple Reverse Proxy which will split and direct traffic to the appropriate HttpHandler based on the content of the Host header.

reverseProxyRouting

fun reverseProxyRouting(vararg hostToHandler: Pair<String, HttpHandler>, matcher: ReverseProxyHostMatcher = Exact): RoutingHttpHandler

Simple Reverse Proxy. Exposes routing.

routes

fun routes(routers: List<RoutingHttpHandler>): RoutingHttpHandler

fun routes(vararg list: Pair<Method, HttpHandler>): RoutingHttpHandler

fun routes(vararg list: RoutingHttpHandler): RoutingHttpHandler

singlePageApp

fun singlePageApp(resourceLoader: ResourceLoader = ResourceLoader.Classpath("/public"), vararg extraFileExtensionToContentTypes: Pair<String, ContentType>): RoutingHttpHandler

For SPAs we serve static content as usual, or fall back to the index page. The resource loader is configured to look at /public package (on the Classpath).

static

fun static(resourceLoader: ResourceLoader = Classpath(), vararg extraFileExtensionToContentTypes: Pair<String, ContentType>): RoutingHttpHandler

Serve static content using the passed ResourceLoader. Note that for security, by default ONLY mime-types registered in mime.types (resource file) will be served. All other types are registered as application/octet-stream and are not served.

webJars

fun webJars(): RoutingHttpHandler

Serve WebJar contents from the classpath. Just install the dependencies and add this line to your routes().