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

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?

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

reverseProxy

fun reverseProxy(vararg hostToHandler: Pair<String, HttpHandler>): 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>): RoutingHttpHandler

Simple Reverse Proxy. Exposes routing.

routes

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

fun routes(vararg list: RoutingHttpHandler): RoutingHttpHandler

fun routes(routers: 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().