org.spincast.core.routing

Interface RouteBuilder<R extends RequestContext<?>>

All Known Implementing Classes:

RouteBuilderDefault

public interface RouteBuilder<R extends RequestContext<?>>

Builder to create a route.

Method Summary

Modifier and Type	Method and Description
RouteBuilder<R>	accept(ContentTypeDefaults... acceptedContentTypes) Sets the accepted Content-Types.
RouteBuilder<R>	accept(Set<ContentTypeDefaults> acceptedContentTypes) Sets the accepted Content-Types.
RouteBuilder<R>	acceptAsString(Set<String> acceptedContentTypes) Sets the accepted Content-Types.
RouteBuilder<R>	acceptAsString(String... acceptedContentTypes) Sets the accepted Content-Types.
RouteBuilder<R>	after(Handler<R> afterFilter) Adds an "after" filter which will only be applied to this particular route.
RouteBuilder<R>	ALL() Adds all HTTP methods as being supported.
RouteBuilder<R>	allRoutingTypes() This route will be considered for all routing types.
RouteBuilder<R>	before(Handler<R> beforeFilter) Adds a "before" filter which will only be applied to this particular route.
RouteBuilder<R>	cache() Adds cache headers.
RouteBuilder<R>	cache(int seconds) Adds public cache headers.
RouteBuilder<R>	cache(int seconds, boolean isPrivate) Adds cache headers.
RouteBuilder<R>	cache(int seconds, boolean isPrivate, Integer secondsCdn) Adds cache headers.
Route<R>	create(Handler<R> mainHandler) Creates and returns the route without adding it to the router.
RouteBuilder<R>	DELETE() Adds DELETE as a supported HTTP method.
RouteBuilder<R>	exception() This route will be considered during an Exception routing process.
RouteBuilder<R>	found() This route will be considered during a Found routing process.
RouteBuilder<R>	GET() Addss GET as a supported HTTP method.
void	handle(Handler<R> mainHandler) Creates the route and saves it to the router.
RouteBuilder<R>	HEAD() Adds HEAD as a supported HTTP method.
RouteBuilder<R>	html() Adds application/html as an accepted Content-Type.
RouteBuilder<R>	id(String id) An id that can be used to identify the route.
RouteBuilder<R>	json() Adds application/json as an accepted Content-Type.
RouteBuilder<R>	methods(HttpMethod... httpMethods) Adds the specified HTTP methods as being supported.
RouteBuilder<R>	methods(Set<HttpMethod> httpMethods) Adds the specified HTTP methods as being supported.
RouteBuilder<R>	noCache() Automatically adds "no-cache" headers to the response.
RouteBuilder<R>	notFound() This route will be considered during a Not Found routing process.
RouteBuilder<R>	OPTIONS() Adds OPTIONS as a supported HTTP method.
RouteBuilder<R>	PATCH() Adds PATCH as a supported HTTP method.
RouteBuilder<R>	path(String path) The path of the route.
RouteBuilder<R>	pos(int position) The position of the handler.
RouteBuilder<R>	POST() Adds POST as a supported HTTP method.
RouteBuilder<R>	PUT() Adds PUT as a supported HTTP method.
RouteBuilder<R>	skip(String filterId) Skip a "before" and "after" filter for this route.
RouteBuilder<R>	skipResourcesRequests() Won't be applied if the request is for a resource (Route.isStaticResourceRoute()).
RouteBuilder<R>	specs(Object specs, Object... options) Generic method to provide specifications for an endpoint.
RouteBuilder<R>	specsIgnore() When calling this method, the associated route won't be part of the generated specs.
RouteBuilder<R>	spicastCoreRouteOrPluginRoute() This should only by called by *plugins*.
RouteBuilder<R>	TRACE() Adds TRACE as a supported HTTP method.
RouteBuilder<R>	xml() Adds application/xml as an accepted Content-Type.

Method Detail

spicastCoreRouteOrPluginRoute

RouteBuilder<R> spicastCoreRouteOrPluginRoute()

This should only by called by *plugins*.

When this method is called, the resulting route won't be remove by default when the Router.removeAllRoutes() method is used. The Router.removeAllRoutes(boolean) with true will have to be called to actually remove it.

This is useful during development, when an hotreload mecanism is used to reload the Router without restarting the application, when the application routes changed. By default only the routes for which the #isSpicastCoreRouteOrPluginRoute() method has been called would then be reloaded.

id

RouteBuilder<R> id(String id)

An id that can be used to identify the route. Must be unique.

path

RouteBuilder<R> path(String path)

The path of the route.

pos

RouteBuilder<R> pos(int position)

The position of the handler.

If "0", the handler is considered as the *main* handler. Only one main handler per request is run (the first one found)! The main handler is usually where the body of the response is created.

A route with a position less than "0" is considered as a "before" filter and will be run before the main handler. A route with a position greater than "0" is considered as an "after" filter and will be run after the main handler. All the matching before and after filters are run, from the lower position to the higher. If two filters have the same position, they will be run in order they have been added to the router.

Be especially careful with after filters since the response may have been flushed at that time. For example, after filters are run if a RedirectException is thrown, but the response will then be closed!

If not specified, "0" is used.

found

RouteBuilder<R> found()

This route will be considered during a Found routing process.

notFound

RouteBuilder<R> notFound()

This route will be considered during a Not Found routing process.

exception

RouteBuilder<R> exception()

This route will be considered during an Exception routing process.

allRoutingTypes

RouteBuilder<R> allRoutingTypes()

This route will be considered for all routing types.

before

RouteBuilder<R> before(Handler<R> beforeFilter)

Adds a "before" filter which will only be applied to this particular route. If more than one filter is added, they will be run in order they have been added.

after

RouteBuilder<R> after(Handler<R> afterFilter)

Adds an "after" filter which will only be applied to this particular route. If more than one filter is added, they will be run in order they have been added.

acceptAsString

RouteBuilder<R> acceptAsString(String... acceptedContentTypes)

Sets the accepted Content-Types. This route will only be considered for requests specifying those Content-Types as being accepted (using the Accept header).

acceptAsString

RouteBuilder<R> acceptAsString(Set<String> acceptedContentTypes)

Sets the accepted Content-Types. This route will only be considered for requests specifying those Content-Types as being accepted (using the Accept header).

accept

RouteBuilder<R> accept(ContentTypeDefaults... acceptedContentTypes)

Sets the accepted Content-Types. This route will only be considered for requests specifying those Content-Types as being accepted (using the Accept header).

accept

RouteBuilder<R> accept(Set<ContentTypeDefaults> acceptedContentTypes)

Sets the accepted Content-Types. This route will only be considered for requests specifying those Content-Types as being accepted (using the Accept header).

html

RouteBuilder<R> html()

Adds application/html as an accepted Content-Type.

json

RouteBuilder<R> json()

Adds application/json as an accepted Content-Type.

xml

RouteBuilder<R> xml()

Adds application/xml as an accepted Content-Type.

GET

RouteBuilder<R> GET()

Addss GET as a supported HTTP method. If you started the creation of the route from an Router object, you already specified some supported HTTP methods. This one will simply be added.

POST

RouteBuilder<R> POST()

Adds POST as a supported HTTP method. If you started the creation of the route from an Router object, you already specified some supported HTTP methods. This one will simply be added.

PUT

RouteBuilder<R> PUT()

Adds PUT as a supported HTTP method. If you started the creation of the route from an Router object, you already specified some supported HTTP methods. This one will simply be added.

DELETE

RouteBuilder<R> DELETE()

Adds DELETE as a supported HTTP method. If you started the creation of the route from an Router object, you already specified some supported HTTP methods. This one will simply be added.

OPTIONS

RouteBuilder<R> OPTIONS()

Adds OPTIONS as a supported HTTP method. If you started the creation of the route from an Router object, you already specified some supported HTTP methods. This one will simply be added.

TRACE

RouteBuilder<R> TRACE()

Adds TRACE as a supported HTTP method. If you started the creation of the route from an Router object, you already specified some supported HTTP methods. This one will simply be added.

HEAD

RouteBuilder<R> HEAD()

Adds HEAD as a supported HTTP method. If you started the creation of the route from an Router object, you already specified some supported HTTP methods. This one will simply be added.

PATCH

RouteBuilder<R> PATCH()

Adds PATCH as a supported HTTP method. If you started the creation of the route from an Router object, you already specified some supported HTTP methods. This one will simply be added.

ALL

RouteBuilder<R> ALL()

Adds all HTTP methods as being supported. If you started the creation of the route from an Router object, you already specified some supported HTTP methods. By calling this method, all methods will now be suported.

methods

RouteBuilder<R> methods(Set<HttpMethod> httpMethods)

Adds the specified HTTP methods as being supported. If you started the creation of the route from an Router object, you already specified some supported HTTP methods. Those new ones will simply be added.

methods

RouteBuilder<R> methods(HttpMethod... httpMethods)

Adds the specified HTTP methods as being supported. If you started the creation of the route from an Router object, you already specified some supported HTTP methods. Those new ones will simply be added.

handle

void handle(Handler<R> mainHandler)

Creates the route and saves it to the router. If the creation of the route was not started using an Router object, an exception will be thrown.

create

Route<R> create(Handler<R> mainHandler)

Creates and returns the route without adding it to the router. NOTE : use handle(...) instead to save the route to the router at the end of the build process!

noCache

RouteBuilder<R> noCache()

Automatically adds "no-cache" headers to the response.

cache

RouteBuilder<R> cache()

Adds cache headers.

Uses the default cache configurations, provided by SpincastConfig

cache

RouteBuilder<R> cache(int seconds)

Adds public cache headers.

Parameters:

seconds - The number of seconds the resource associated with this route should be cached.

cache

RouteBuilder<R> cache(int seconds,
                      boolean isPrivate)

Adds cache headers.

Parameters:

seconds - The number of seconds the resource associated with this route should be cached.

isPrivate - should the cache be private? (help)

cache

RouteBuilder<R> cache(int seconds,
                      boolean isPrivate,
                      Integer secondsCdn)

Adds cache headers.

Parameters:

seconds - The number of seconds the resource associated with this route should be cached.

isPrivate - should the cache be private? (help)

secondsCdn - The number of seconds the resource associated with this route should be cached by a CDN/proxy. If null, it won't be used.

skip

RouteBuilder<R> skip(String filterId)

Skip a "before" and "after" filter for this route.

This is useful when you set a global filter but want to skip it one a specific route only.

skipResourcesRequests

RouteBuilder<R> skipResourcesRequests()

Won't be applied if the request is for a resource (Route.isStaticResourceRoute()). In the case of Dynamic Resources, the filters will indeed be called when the generator is used. By calling this skipResourcesRequests() method, the current filter will never be called for such resources.

This feature only makes sense if the current route if a filter. Otherwise, it won't be used.

specs

RouteBuilder<R> specs(Object specs,
                      Object... options)

Generic method to provide specifications for an endpoint.

Does nothing by default. Requires a plugin that knows how to parse the provided object.

specsIgnore

RouteBuilder<R> specsIgnore()

When calling this method, the associated route won't be part of the generated specs.