Package 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 Details

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

    • classes

      RouteBuilder<R> classes(String... classes)
      A route may have multiple "classes" to identify and group them.

      For example, multiple routes may share the same "account" class and this information could be used to set a menu item as being active on an HTML page.

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