public.javadoc.org.spincast.core.routing.RouteBuilder.html Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of spincast-website Show documentation

Source code for the https://www.spincast.org website.

There is a newer version: 2.2.0







RouteBuilder (org.spincast:spincast-framework 1.0.0 API)











Skip navigation links




Overview
Package
Class
Use
Tree
Deprecated
Index
Help

 Spincast Framework Javadoc



Prev Class
Next Class


Frames
No Frames


All Classes






Summary: 
Nested | 
Field | 
Constr | 
Method


Detail: 
Field | 
Constr | 
Method








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

All Methods Instance Methods Abstract Methods 

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>
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 save(...) 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.













Skip navigation links




Overview
Package
Class
Use
Tree
Deprecated
Index
Help

 Spincast Framework Javadoc



Prev Class
Next Class


Frames
No Frames


All Classes






Summary: 
Nested | 
Field | 
Constr | 
Method


Detail: 
Field | 
Constr | 
Method






Copyright © 2019. All rights reserved.

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