All Implemented Interfaces:: Registry, Router

public class Jooby
extends Object
implements Router, Registry

Welcome to Jooby!

Hello World!



 public class App extends Jooby {

   {
     get("/", ctx -> "Hello World!");
   }

   public static void main(String[] args) {
     runApp(args, App::new);
   }
 }

Constructors
Constructor and Description
`Jooby()` Creates a new Jooby instance.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Jooby`	`after(Route.After after)` Add an after route decorator to the route pipeline.
`<T> T`	`attribute(String key)` Get an attribute by his key.
`Jooby`	`attribute(String key, Object value)` Set an application attribute.
`Jooby`	`before(Route.Before before)` Add a before route decorator to the route pipeline.
`Jooby`	`decorator(Route.Decorator decorator)` Add a route decorator to the route pipeline.
`Jooby`	`dispatch(Executor executor, Runnable action)` Dispatch route pipeline to the given executor.
`Jooby`	`dispatch(Runnable body)` Dispatch route pipeline to the `Router.getWorker()` worker thread pool.
`Jooby`	`error(ErrorHandler handler)` Add a custom error handler.
`Jooby`	`errorCode(Class<? extends Throwable> type, StatusCode statusCode)` Map an exception type to a status code.
`StatusCode`	`errorCode(Throwable cause)` Computes the status code for the given exception.
`Map<String,Object>`	`getAttributes()` Mutable map of application attributes.
`String`	`getBasePackage()` Get base application package.
`String`	`getContextPath()` Get application context path (a.k.a as base path).
`Environment`	`getEnvironment()` Application environment.
`ErrorHandler`	`getErrorHandler()` Get the error handler.
`ExecutionMode`	`getExecutionMode()` Application execution mode.
`org.slf4j.Logger`	`getLog()` Application logger.
`Map<ResourceKey,Object>`	`getResources()` Application resource registry.
`RouterOptions`	`getRouterOptions()` Router options.
`List<Route>`	`getRoutes()` Returns all routes.
`ServerOptions`	`getServerOptions()` Server options or `null`.
`Path`	`getTmpdir()` Application temporary directory.
`Executor`	`getWorker()` Returns the worker thread pool.
`Jooby`	`install(Extension extension)` Install extension module.
`Router.Match`	`match(Context ctx)` Find a matching route using the given context.
`Jooby`	`mvc(Class router)` Import all route method from the given controller class.
`<T> Jooby`	`mvc(Class<T> router, javax.inject.Provider<T> provider)` Import all route method from the given controller class.
`Jooby`	`mvc(Object router)` Import all route methods from given controller instance.
`Jooby`	`onStart(Throwing.Runnable body)` Start event is fire once all components has been initialized, for example router and web-server are up and running, extension installed, etc...
`Jooby`	`onStop(AutoCloseable body)` Stop event is fire at application shutdown time.
`Jooby`	`parser(MediaType contentType, Parser parser)` Register a parser for the given content type.
`Jooby`	`path(String pattern, Runnable action)` Group one or more routes under a common path prefix.
`Jooby`	`ready(Server server)` Callback method that indicates application was successfully started it and it is ready listening for connections.
`Jooby`	`registry(Registry registry)` Set application registry.
`Jooby`	`renderer(MediaType contentType, Renderer renderer)` Register a route response renderer.
`Jooby`	`renderer(Renderer renderer)` Register a route response renderer.
`<T> T`	`require(Class<T> type)` Provides an instance of the given type.
`<T> T`	`require(Class<T> type, String name)` Provides an instance of the given type where name matches it.
`<R> Jooby`	`resource(ResourceKey<R> key, R resource)` Put an application resource.
`<T> T`	`resource(ResourceKey<T> key)` Get a resource under this key or throws a `IllegalStateException` exception.
`Jooby`	`responseHandler(ResponseHandler handler)` Add a response handler factory.
`Jooby`	`route(Runnable action)` Group one or more routes.
`Route`	`route(String method, String pattern, Route.Handler handler)` Add a route.
`static void`	`runApp(String[] args, Class<? extends Jooby> applicationType)` Setup default environment, logging (logback or log4j2) and run application.
`static void`	`runApp(String[] args, Consumer<Jooby> consumer)` Setup default environment, logging (logback or log4j2) and run application.
`static void`	`runApp(String[] args, ExecutionMode executionMode, Class<? extends Jooby> applicationType)` Setup default environment, logging (logback or log4j2) and run application.
`static void`	`runApp(String[] args, ExecutionMode executionMode, Consumer<Jooby> consumer)` Setup default environment, logging (logback or log4j2) and run application.
`static void`	`runApp(String[] args, ExecutionMode executionMode, Supplier<Jooby> provider)` Setup default environment, logging (logback or log4j2) and run application.
`static void`	`runApp(String[] args, Supplier<Jooby> provider)` Setup default environment, logging (logback or log4j2) and run application.
`Jooby`	`setContextPath(String basePath)` Set application context path.
`Jooby`	`setDefaultWorker(Executor worker)` Set the default worker thread pool.
`Jooby`	`setEnvironment(Environment environment)` Set application environment.
`Environment`	`setEnvironmentOptions(EnvironmentOptions options)` Set environment options and initialize/overrides the environment.
`Jooby`	`setExecutionMode(ExecutionMode mode)` Set application execution mode.
`Jooby`	`setRouterOptions(RouterOptions options)` Set router options.
`Jooby`	`setServerOptions(ServerOptions serverOptions)` Set server options.
`Jooby`	`setTmpdir(Path tmpdir)` Set application temporary directory.
`Jooby`	`setWorker(Executor worker)` Set a worker thread pool.
`Server`	`start()` Start application, find a web server, deploy application, start router, extension modules, etc..
`Jooby`	`start(Server server)` Call back method that indicates application was deploy it in the given server.
`Jooby`	`stop()` Stop application, fire the stop event to cleanup resources.
`String`	`toString()`
`Jooby`	`use(Predicate<Context> predicate, Router router)` Import routes from given router.
`Jooby`	`use(Router router)` Import all routes from the given router.
`Jooby`	`use(String path, Router router)` Import all routes from the given router and prefix them with the given path.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.jooby.Router
assets, assets, assets, assets, connect, delete, error, error, error, get, head, normalizePath, options, patch, pathKeys, post, put, trace

- Constructor Detail
  - Jooby
```
public Jooby()
```
    Creates a new Jooby instance.
- Method Detail
  - getServerOptions
```
@Nullable
public ServerOptions getServerOptions()
```
    Server options or null.
    
    Returns:
    
    Server options or null.
  - setServerOptions
```
@Nonnull
public Jooby setServerOptions(@Nonnull
                                       ServerOptions serverOptions)
```
    Set server options.
    
    Parameters:
    
    serverOptions - Server options.
    
    Returns:
    
    This application.
  - getRouterOptions
```
@Nonnull
public RouterOptions getRouterOptions()
```
    Description copied from interface: Router
    
    Router options.
    
    Specified by:
    
    getRouterOptions in interface Router
    
    Returns:
    
    Router options.
  - setRouterOptions
```
@Nonnull
public Jooby setRouterOptions(@Nonnull
                                       RouterOptions options)
```
    Description copied from interface: Router
    
    Set router options.
    
    Specified by:
    
    setRouterOptions in interface Router
    
    Parameters:
    
    options - router options.
    
    Returns:
    
    This router.
  - getEnvironment
```
@Nonnull
public Environment getEnvironment()
```
    Application environment. If none was set, environment is initialized using Environment.loadEnvironment(EnvironmentOptions).
    
    Returns:
    
    Application environment.
  - setEnvironment
```
@Nonnull
public Jooby setEnvironment(@Nonnull
                                     Environment environment)
```
    Set application environment.
    
    Parameters:
    
    environment - Application environment.
    
    Returns:
    
    This application.
  - setEnvironmentOptions
```
@Nonnull
public Environment setEnvironmentOptions(@Nonnull
                                                  EnvironmentOptions options)
```
    Set environment options and initialize/overrides the environment.
    
    Parameters:
    
    options - Environment options.
    
    Returns:
    
    New environment.
  - onStart
```
@Nonnull
public Jooby onStart(@Nonnull
                              Throwing.Runnable body)
```
    Start event is fire once all components has been initialized, for example router and web-server are up and running, extension installed, etc...
    
    Parameters:
    
    body - Start body.
    
    Returns:
    
    This application.
  - onStop
```
@Nonnull
public Jooby onStop(@Nonnull
                             AutoCloseable body)
```
    Stop event is fire at application shutdown time. Useful to execute cleanup task, free resources, etc...
    
    Parameters:
    
    body - Stop body.
    
    Returns:
    
    This application.
  - setContextPath
```
@Nonnull
public Jooby setContextPath(@Nonnull
                                     String basePath)
```
    Description copied from interface: Router
    
    Set application context path. Context path is the base path for all routes. Default is: /.
    
    Specified by:
    
    setContextPath in interface Router
    
    Parameters:
    
    basePath - Context path.
    
    Returns:
    
    This router.
  - getContextPath
```
@Nonnull
public String getContextPath()
```
    Description copied from interface: Router
    
    Get application context path (a.k.a as base path).
    
    Specified by:
    
    getContextPath in interface Router
    
    Returns:
    
    Application context path (a.k.a as base path).
  - use
```
@Nonnull
public Jooby use(@Nonnull
                          Router router)
```
    Description copied from interface: Router
    
    Import all routes from the given router.
    
    Specified by:
    
    use in interface Router
    
    Parameters:
    
    router - Router to import.
    
    Returns:
    
    This router.
  - use
```
@Nonnull
public Jooby use(@Nonnull
                          Predicate<Context> predicate,
                          @Nonnull
                          Router router)
```
    Description copied from interface: Router
    Import routes from given router. Predicate works like a filter and only when predicate pass the routes match against the current request. Example of domain predicate filter:
```
 {

   use(ctx -> ctx.getHost().equals("foo.com"), new FooApp());
   use(ctx -> ctx.getHost().equals("bar.com"), new BarApp());
 }
 
```
    Imported routes are matched only when predicate pass.
    Specified by:
    
    use in interface Router
    
    Parameters:
    
    predicate - Context predicate.
    
    router - Router to import.
    
    Returns:
    
    This router.
  - use
```
@Nonnull
public Jooby use(@Nonnull
                          String path,
                          @Nonnull
                          Router router)
```
    Description copied from interface: Router
    
    Import all routes from the given router and prefix them with the given path.
    
    Specified by:
    
    use in interface Router
    
    Parameters:
    
    path - Prefix path.
    
    router - Router to import.
    
    Returns:
    
    This router.
  - mvc
```
@Nonnull
public Jooby mvc(@Nonnull
                          Object router)
```
    Description copied from interface: Router
    
    Import all route methods from given controller instance.
    
    Specified by:
    
    mvc in interface Router
    
    Parameters:
    
    router - Controller instance.
    
    Returns:
    
    This routes.
  - mvc
```
@Nonnull
public Jooby mvc(@Nonnull
                          Class router)
```
    Description copied from interface: Router
    
    Import all route method from the given controller class. At runtime the controller instance is resolved by calling require(Class).
    
    Specified by:
    
    mvc in interface Router
    
    Parameters:
    
    router - Controller class.
    
    Returns:
    
    This router.
  - mvc
```
@Nonnull
public <T> Jooby mvc(@Nonnull
                              Class<T> router,
                              @Nonnull
                              javax.inject.Provider<T> provider)
```
    Description copied from interface: Router
    
    Import all route method from the given controller class.
    
    Specified by:
    
    mvc in interface Router
    
    Type Parameters:
    
    T - Controller type.
    
    Parameters:
    
    router - Controller class.
    
    provider - Controller provider.
    
    Returns:
    
    This router.
  - getRoutes
```
@Nonnull
public List<Route> getRoutes()
```
    Description copied from interface: Router
    
    Returns all routes.
    
    Specified by:
    
    getRoutes in interface Router
    
    Returns:
    
    All routes.
  - error
```
@Nonnull
public Jooby error(@Nonnull
                            ErrorHandler handler)
```
    Description copied from interface: Router
    
    Add a custom error handler.
    
    Specified by:
    
    error in interface Router
    
    Parameters:
    
    handler - Error handler.
    
    Returns:
    
    This router.
  - decorator
```
@Nonnull
public Jooby decorator(@Nonnull
                                Route.Decorator decorator)
```
    Description copied from interface: Router
    
    Add a route decorator to the route pipeline.
    
    Specified by:
    
    decorator in interface Router
    
    Parameters:
    
    decorator - Decorator.
    
    Returns:
    
    This router.
  - before
```
@Nonnull
public Jooby before(@Nonnull
                             Route.Before before)
```
    Description copied from interface: Router
    
    Add a before route decorator to the route pipeline.
    
    Specified by:
    
    before in interface Router
    
    Parameters:
    
    before - Before decorator.
    
    Returns:
    
    This router.
  - after
```
@Nonnull
public Jooby after(@Nonnull
                            Route.After after)
```
    Description copied from interface: Router
    
    Add an after route decorator to the route pipeline.
    
    Specified by:
    
    after in interface Router
    
    Parameters:
    
    after - After decorator.
    
    Returns:
    
    This router.
  - renderer
```
@Nonnull
public Jooby renderer(@Nonnull
                               Renderer renderer)
```
    Description copied from interface: Router
    
    Register a route response renderer.
    
    Specified by:
    
    renderer in interface Router
    
    Parameters:
    
    renderer - Renderer instance.
    
    Returns:
    
    This router.
  - parser
```
@Nonnull
public Jooby parser(@Nonnull
                             MediaType contentType,
                             @Nonnull
                             Parser parser)
```
    Description copied from interface: Router
    
    Register a parser for the given content type.
    
    Specified by:
    
    parser in interface Router
    
    Parameters:
    
    contentType - Content type to match.
    
    parser - Parser.
    
    Returns:
    
    This router.
  - renderer
```
@Nonnull
public Jooby renderer(@Nonnull
                               MediaType contentType,
                               @Nonnull
                               Renderer renderer)
```
    Description copied from interface: Router
    
    Register a route response renderer.
    
    Specified by:
    
    renderer in interface Router
    
    Parameters:
    
    contentType - Accept header should matches the content-type.
    
    renderer - Renderer instance.
    
    Returns:
    
    This router.
  - install
```
@Nonnull
public Jooby install(@Nonnull
                              Extension extension)
```
    Install extension module.
    
    Parameters:
    
    extension - Extension module.
    
    Returns:
    
    This application.
  - dispatch
```
@Nonnull
public Jooby dispatch(@Nonnull
                               Runnable body)
```
    Description copied from interface: Router
    
    Dispatch route pipeline to the Router.getWorker() worker thread pool. After dispatch application code is allowed to do blocking calls.
    
    Specified by:
    
    dispatch in interface Router
    
    Parameters:
    
    body - Dispatch body.
    
    Returns:
    
    This router.
  - dispatch
```
@Nonnull
public Jooby dispatch(@Nonnull
                               Executor executor,
                               @Nonnull
                               Runnable action)
```
    Description copied from interface: Router
    
    Dispatch route pipeline to the given executor. After dispatch application code is allowed to do blocking calls.
    
    Specified by:
    
    dispatch in interface Router
    
    Parameters:
    
    executor - Executor. ExecutorService instances automatically shutdown at application exit.
    
    action - Dispatch body.
    
    Returns:
    
    This router.
  - path
```
@Nonnull
public Jooby path(@Nonnull
                           String pattern,
                           @Nonnull
                           Runnable action)
```
    Description copied from interface: Router
    
    Group one or more routes under a common path prefix. Useful for applying cross cutting concerns to the enclosed routes.
    
    Specified by:
    
    path in interface Router
    
    Parameters:
    
    pattern - Path pattern.
    
    action - Route body.
    
    Returns:
    
    This router.
  - route
```
@Nonnull
public Jooby route(@Nonnull
                            Runnable action)
```
    Description copied from interface: Router
    
    Group one or more routes. Useful for applying cross cutting concerns to the enclosed routes.
    
    Specified by:
    
    route in interface Router
    
    Parameters:
    
    action - Route body.
    
    Returns:
    
    This router.
  - route
```
@Nonnull
public Route route(@Nonnull
                            String method,
                            @Nonnull
                            String pattern,
                            @Nonnull
                            Route.Handler handler)
```
    Description copied from interface: Router
    
    Add a route.
    
    Specified by:
    
    route in interface Router
    
    Parameters:
    
    method - HTTP method.
    
    pattern - Path pattern.
    
    handler - Application code.
    
    Returns:
    
    A route.
  - match
```
@Nonnull
public Router.Match match(@Nonnull
                                   Context ctx)
```
    Description copied from interface: Router
    
    Find a matching route using the given context. If no match exists this method returns a route with a 404 handler. See Route.NOT_FOUND.
    
    Specified by:
    
    match in interface Router
    
    Parameters:
    
    ctx - Web Context.
    
    Returns:
    
    A route match result.
  - errorCode
```
@Nonnull
public Jooby errorCode(@Nonnull
                                Class<? extends Throwable> type,
                                @Nonnull
                                StatusCode statusCode)
```
    Description copied from interface: Router
    
    Map an exception type to a status code.
    
    Specified by:
    
    errorCode in interface Router
    
    Parameters:
    
    type - Exception type.
    
    statusCode - Status code.
    
    Returns:
    
    This router.
  - errorCode
```
@Nonnull
public StatusCode errorCode(@Nonnull
                                     Throwable cause)
```
    Description copied from interface: Router
    
    Computes the status code for the given exception.
    
    Specified by:
    
    errorCode in interface Router
    
    Parameters:
    
    cause - Exception.
    
    Returns:
    
    Status code.
  - getWorker
```
@Nonnull
public Executor getWorker()
```
    Description copied from interface: Router
    
    Returns the worker thread pool. This thread pool is used to run application blocking code.
    
    Specified by:
    
    getWorker in interface Router
    
    Returns:
    
    Worker thread pool.
  - setWorker
```
@Nonnull
public Jooby setWorker(@Nonnull
                                Executor worker)
```
    Description copied from interface: Router
    
    Set a worker thread pool. This thread pool is used to run application blocking code.
    
    Specified by:
    
    setWorker in interface Router
    
    Parameters:
    
    worker - Worker thread pool.
    
    Returns:
    
    This router.
  - setDefaultWorker
```
@Nonnull
public Jooby setDefaultWorker(@Nonnull
                                       Executor worker)
```
    Description copied from interface: Router
    
    Set the default worker thread pool. Via this method the underlying web server set/suggests the worker thread pool that should be used it. A call to Router.getWorker() returns the default thread pool, unless you explicitly set one.
    
    Specified by:
    
    setDefaultWorker in interface Router
    
    Parameters:
    
    worker - Default worker thread pool.
    
    Returns:
    
    This router.
  - getLog
```
@Nonnull
public org.slf4j.Logger getLog()
```
    Description copied from interface: Router
    
    Application logger.
    
    Specified by:
    
    getLog in interface Router
    
    Returns:
    
    Application logger.
  - responseHandler
```
@Nonnull
public Jooby responseHandler(ResponseHandler handler)
```
    Description copied from interface: Router
    
    Add a response handler factory.
    
    Specified by:
    
    responseHandler in interface Router
    
    Parameters:
    
    handler - Response handler factory.
    
    Returns:
    
    This router.
  - getErrorHandler
```
@Nonnull
public ErrorHandler getErrorHandler()
```
    Description copied from interface: Router
    
    Get the error handler.
    
    Specified by:
    
    getErrorHandler in interface Router
    
    Returns:
    
    An error handler.
  - getTmpdir
```
@Nonnull
public Path getTmpdir()
```
    Description copied from interface: Router
    
    Application temporary directory.
    
    Specified by:
    
    getTmpdir in interface Router
    
    Returns:
    
    Application temporary directory.
  - setTmpdir
```
@Nonnull
public Jooby setTmpdir(@Nonnull
                                Path tmpdir)
```
    Set application temporary directory.
    
    Parameters:
    
    tmpdir - Temp directory.
    
    Returns:
    
    This application.
  - getExecutionMode
```
@Nonnull
public ExecutionMode getExecutionMode()
```
    Application execution mode.
    
    Returns:
    
    Application execution mode.
  - setExecutionMode
```
@Nonnull
public Jooby setExecutionMode(@Nonnull
                                       ExecutionMode mode)
```
    Set application execution mode.
    
    Parameters:
    
    mode - Application execution mode.
    
    Returns:
    
    This application.
  - getAttributes
```
@Nonnull
public Map<String,Object> getAttributes()
```
    Description copied from interface: Router
    
    Mutable map of application attributes.
    
    Specified by:
    
    getAttributes in interface Router
    
    Returns:
    
    Mutable map of application attributes.
  - attribute
```
@Nonnull
public Jooby attribute(@Nonnull
                                String key,
                                Object value)
```
    Description copied from interface: Router
    
    Set an application attribute.
    
    Specified by:
    
    attribute in interface Router
    
    Parameters:
    
    key - Attribute key.
    
    value - Attribute value.
    
    Returns:
    
    This router.
  - attribute
```
@Nonnull
public <T> T attribute(@Nonnull
                                String key)
```
    Description copied from interface: Router
    
    Get an attribute by his key. This is just an utility method around Router.getAttributes().
    
    Specified by:
    
    attribute in interface Router
    
    Type Parameters:
    
    T - Attribute type.
    
    Parameters:
    
    key - Attribute key.
    
    Returns:
    
    Attribute value.
  - require
```
@Nonnull
public <T> T require(@Nonnull
                              Class<T> type,
                              @Nonnull
                              String name)
```
    Description copied from interface: Registry
    
    Provides an instance of the given type where name matches it.
    
    Specified by:
    
    require in interface Registry
    
    Type Parameters:
    
    T - Object type.
    
    Parameters:
    
    type - Object type.
    
    name - Object name.
    
    Returns:
    
    Instance of this type.
  - require
```
@Nonnull
public <T> T require(@Nonnull
                              Class<T> type)
```
    Description copied from interface: Registry
    
    Provides an instance of the given type.
    
    Specified by:
    
    require in interface Registry
    
    Type Parameters:
    
    T - Object type.
    
    Parameters:
    
    type - Object type.
    
    Returns:
    
    Instance of this type.
  - registry
```
@Nonnull
public Jooby registry(@Nonnull
                               Registry registry)
```
    Set application registry.
    
    Parameters:
    
    registry - Application registry.
    
    Returns:
    
    This application.
  - getResources
```
@Nonnull
public Map<ResourceKey,Object> getResources()
```
    Description copied from interface: Router
    
    Application resource registry. A resource must be initialized at application startup time and release it using onStop(AutoCloseable) (if need it).
    
    Specified by:
    
    getResources in interface Router
    
    Returns:
    
    Resource registry.
  - resource
```
@Nonnull
public <R> Jooby resource(@Nonnull
                                   ResourceKey<R> key,
                                   @Nonnull
                                   R resource)
```
    Description copied from interface: Router
    
    Put an application resource.
    
    Specified by:
    
    resource in interface Router
    
    Type Parameters:
    
    R - Resource type.
    
    Parameters:
    
    key - Resource key.
    
    resource - Resource value.
    
    Returns:
    
    This router.
  - resource
```
@Nonnull
public <T> T resource(@Nonnull
                               ResourceKey<T> key)
                        throws IllegalStateException
```
    Description copied from interface: Router
    
    Get a resource under this key or throws a IllegalStateException exception.
    
    Specified by:
    
    resource in interface Router
    
    Type Parameters:
    
    T - Attribute type.
    
    Parameters:
    
    key - Attribute key.
    
    Returns:
    
    Attribute value.
    
    Throws:
    
    IllegalStateException - If there is no resource under this key.
  - getBasePackage
```
@Nullable
public String getBasePackage()
```
    Get base application package. This is the package from where application was initialized or the package of a Jooby application sub-class.
    
    Returns:
    
    Base application package.
  - start
```
@Nonnull
public Server start()
```
    Start application, find a web server, deploy application, start router, extension modules, etc..
    
    Returns:
    
    Server.
  - start
```
@Nonnull
public Jooby start(@Nonnull
                            Server server)
```
    Call back method that indicates application was deploy it in the given server.
    
    Parameters:
    
    server - Server.
    
    Returns:
    
    This application.
  - ready
```
@Nonnull
public Jooby ready(@Nonnull
                            Server server)
```
    Callback method that indicates application was successfully started it and it is ready listening for connections.
    
    Parameters:
    
    server - Server.
    
    Returns:
    
    This application.
  - stop
```
@Nonnull
public Jooby stop()
```
    Stop application, fire the stop event to cleanup resources.
    
    Returns:
    
    This application.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - runApp
```
public static void runApp(@Nonnull
                          String[] args,
                          @Nonnull
                          Class<? extends Jooby> applicationType)
```
    Setup default environment, logging (logback or log4j2) and run application.
    
    Parameters:
    
    args - Application arguments.
    
    applicationType - Application type.
  - runApp
```
public static void runApp(@Nonnull
                          String[] args,
                          @Nonnull
                          ExecutionMode executionMode,
                          @Nonnull
                          Class<? extends Jooby> applicationType)
```
    Setup default environment, logging (logback or log4j2) and run application.
    
    Parameters:
    
    args - Application arguments.
    
    executionMode - Application execution mode.
    
    applicationType - Application type.
  - runApp
```
public static void runApp(@Nonnull
                          String[] args,
                          @Nonnull
                          Supplier<Jooby> provider)
```
    Setup default environment, logging (logback or log4j2) and run application.
    
    Parameters:
    
    args - Application arguments.
    
    provider - Application provider.
  - runApp
```
public static void runApp(@Nonnull
                          String[] args,
                          @Nonnull
                          Consumer<Jooby> consumer)
```
    Setup default environment, logging (logback or log4j2) and run application.
    
    Parameters:
    
    args - Application arguments.
    
    consumer - Application consumer.
  - runApp
```
public static void runApp(@Nonnull
                          String[] args,
                          @Nonnull
                          ExecutionMode executionMode,
                          @Nonnull
                          Consumer<Jooby> consumer)
```
    Setup default environment, logging (logback or log4j2) and run application.
    
    Parameters:
    
    args - Application arguments.
    
    executionMode - Application execution mode.
    
    consumer - Application consumer.
  - runApp
```
public static void runApp(@Nonnull
                          String[] args,
                          @Nonnull
                          ExecutionMode executionMode,
                          @Nonnull
                          Supplier<Jooby> provider)
```
    Setup default environment, logging (logback or log4j2) and run application.
    
    Parameters:
    
    args - Application arguments.
    
    executionMode - Application execution mode.
    
    provider - Application provider.

Class Jooby

Welcome to Jooby!

Nested Class Summary

Nested classes/interfaces inherited from interface io.jooby.Router

Field Summary

Fields inherited from interface io.jooby.Router

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.jooby.Router

Constructor Detail

Jooby

Method Detail

getServerOptions

setServerOptions

getRouterOptions

setRouterOptions

getEnvironment

setEnvironment

setEnvironmentOptions

onStart

onStop

setContextPath

getContextPath

use

use

use

mvc

mvc

mvc

getRoutes

error

decorator

before

after

renderer

parser

renderer

install

dispatch

dispatch

path

route

route

match

errorCode

errorCode

getWorker

setWorker

setDefaultWorker

getLog

responseHandler

getErrorHandler

getTmpdir

setTmpdir

getExecutionMode

setExecutionMode

getAttributes

attribute

attribute

require

require

registry

getResources

resource

resource

getBasePackage

start

start

ready

stop

toString

runApp

runApp

runApp

runApp

runApp

runApp