public class Jooby extends Object
A new application must extends Jooby, register one ore more Body.Formatter
and some
routes
. It sounds like a lot of work to do, but it isn't.
public class MyApp extends Jooby { { use(new Json()); // 1. JSON serializer. // 2. Define a route get("/", (req, rsp) -> { Map <String, Object > model = ...; rsp.send(model); } } public static void main(String[] args) throws Exception { new MyApp().start(); // 3. Done! } }
Jooby delegate configuration management to TypeSafe Config. If you are unfamiliar with TypeSafe Config please take a few minutes to discover what TypeSafe Config can do for you.
By default Jooby looks for an application.conf
file at the root of the classpath. If
you want to specify a different file or location, you can do it with use(Config)
.
TypeSafe Config uses a hierarchical model to define and override properties.
A Jooby.Module
might provides his own set of properties through the
Jooby.Module.config()
method. By default, this method returns an empty config object.
use(new M1()); use(new M2()); use(new M3());Previous example had the following order (first-listed are higher priority):
System properties takes precedence over any application specific property.
Jooby defines two modes: dev or something else. In Jooby, dev
is special and some modules could apply special settings while running in dev.
Any other env is usually considered a prod
like env. But that depends on module
implementor.
A env can be defined in your application.conf
file using the
application.env
property. If missing, Jooby set the env for you to
dev.
There is more at Env
so take a few minutes to discover what a Env
can do for you.
Modules
are quite similar to a Guice modules except that the configure
callback has been complementing with Env
and Config
.
public class MyModule implements Jooby.Module { public void configure(env env, Config config, Binder binder) { } }From the configure callback you can bind your services as you usually do in a Guice app.
There is more at Jooby.Module
so take a few minutes to discover what a
Jooby.Module
can do for you.
Jooby supports Ant-style path patterns:
Some examples:
com/t?st.html
- matches com/test.html
but also com/tast.html
or
com/txst.html
com/*.html
- matches all .html
files in the com
directorycom/**/test.html
- matches all test.html
files underneath the
com
path**
/*
- matches any path at any level.*
- matches any path at any level, shorthand for **
/*
.Jooby supports path parameters too:
Some examples:
/user/{id}
- /user/* and give you access to the id
var. /user/:id
- /user/* and give you access to the id
var. /user/{id:\\d+}
- /user/[digits] and give you access to the numeric
id
var.
Routes perform actions in response to a server HTTP request. There are two types of routes
callback: Route.Handler
and Route.Filter
.
Routes are executed in the order they are defined, for example:
get("/", (req, rsp) -> { log.info("first"); // start here and go to second }); get("/", (req, rsp) -> { log.info("second"); // execute after first and go to final }); get("/", (req, rsp) -> { rsp.send("final"); // done! });Please note first and second routes are converted to a filter, so previous example is the same as:
get("/", (req, rsp, chain) -> { log.info("first"); // start here and go to second chain.next(req, rsp); }); get("/", (req, rsp, chain) -> { log.info("second"); // execute after first and go to final chain.next(req, rsp); }); get("/", (req, rsp) -> { rsp.send("final"); // done! });Due to the use of lambdas a route is a singleton and you should NOT use global variables. For example this is a bad practice:
List <String > names = new ArrayList < >(); // names produces side effects get("/", (req, rsp) -> { names.add(req.param("name").stringValue(); // response will be different between calls. rsp.send(names); });
A Mvc route use annotations to define routes:
use(MyRoute.class); ... // MyRoute.java @Path("/") public class MyRoute { @GET public String hello() { return "Hello Jooby"; } }
Programming model is quite similar to JAX-RS/Jersey with some minor differences and/or simplifications.
To learn more about Mvc Routes, please check Path
,
Produces
Consumes
, and Viewable
.
Static files, like: *.js, *.css, ..., etc... can be served with:
assets("assets/**");
Classpath resources under the /assets
folder will be accessible from client/browser.
The bootstrap process is defined as follows:
application.conf
or custom, see use(Config)
modules
modules
Guice Injector
is created.module
start method
is invoked.Jooby.Module
Modifier and Type | Class and Description |
---|---|
static interface |
Jooby.Module
A module can publish or produces:
routes , Body.Parser ,
Body.Formatter , request modules and any other
application specific service or contract of your choice. |
Constructor and Description |
---|
Jooby() |
Modifier and Type | Method and Description |
---|---|
Route.Definition |
assets(String path)
Serve or publish static files to browser.
|
Route.Definition |
connect(String path,
Route.Filter filter)
Append a route that supports HTTP CONNECT method:
|
Route.Definition |
connect(String path,
Route.Handler handler)
Append a route that supports HTTP CONNECT method:
|
Route.Definition |
connect(String path,
Route.OneArgHandler handler)
Append route that supports HTTP CONNECT method:
|
Route.Definition |
connect(String path,
Route.ZeroArgHandler handler)
Append route that supports HTTP CONNECT method:
|
Route.Definition |
delete(String path,
Route.Filter filter)
Append a route that supports HTTP DELETE method:
|
Route.Definition |
delete(String path,
Route.Handler handler)
Append a route that supports HTTP DELETE method:
|
Route.Definition |
delete(String path,
Route.OneArgHandler handler)
Append route that supports HTTP DELETE method:
|
Route.Definition |
delete(String path,
Route.ZeroArgHandler handler)
Append route that supports HTTP DELETE method:
|
Jooby |
env(Env.Builder env)
Set a custom
Env.Builder to use. |
Jooby |
err(Err.Handler err)
Setup a route error handler.
|
Route.Definition |
get(String path)
Serve a static file from classpath:
|
Route.Definition |
get(String path,
Route.Filter filter)
Append a filter that supports HTTP GET method:
|
Route.Definition |
get(String path,
Route.Handler handler)
Append route that supports HTTP GET method:
|
Route.Definition |
get(String path,
Route.OneArgHandler handler)
Append route that supports HTTP GET method:
|
Route.Definition |
get(String path,
Route.ZeroArgHandler handler)
Append route that supports HTTP GET method:
|
Route.Definition |
head()
Append a new route that automatically handles HEAD request from existing GET routes.
|
Route.Definition |
head(String path,
Route.Filter filter)
Append a route that supports HTTP HEAD method:
|
Route.Definition |
head(String path,
Route.Handler handler)
Append a route that supports HTTP HEAD method:
|
Route.Definition |
head(String path,
Route.OneArgHandler handler)
Append route that supports HTTP HEAD method:
|
Route.Definition |
head(String path,
Route.ZeroArgHandler handler)
Append route that supports HTTP HEAD method:
|
Route.Definition |
options()
Append a new route that automatically handles OPTIONS requests.
|
Route.Definition |
options(String path,
Route.Filter filter)
Append a route that supports HTTP OPTIONS method:
|
Route.Definition |
options(String path,
Route.Handler handler)
Append a route that supports HTTP OPTIONS method:
|
Route.Definition |
options(String path,
Route.OneArgHandler handler)
Append route that supports HTTP OPTIONS method:
|
Route.Definition |
options(String path,
Route.ZeroArgHandler handler)
Append route that supports HTTP OPTIONS method:
|
Route.Definition |
patch(String path,
Route.Filter filter)
Append route that supports HTTP PATCH method:
|
Route.Definition |
patch(String path,
Route.Handler handler)
Append route that supports HTTP PATCH method:
|
Route.Definition |
patch(String path,
Route.OneArgHandler handler)
Append route that supports HTTP PATCH method:
|
Route.Definition |
patch(String path,
Route.ZeroArgHandler handler)
Append route that supports HTTP PATCH method:
|
Route.Definition |
post(String path,
Route.Filter filter)
Append a route that supports HTTP POST method:
|
Route.Definition |
post(String path,
Route.Handler handler)
Append a route that supports HTTP POST method:
|
Route.Definition |
post(String path,
Route.OneArgHandler handler)
Append route that supports HTTP POST method:
|
Route.Definition |
post(String path,
Route.ZeroArgHandler handler)
Append route that supports HTTP POST method:
|
Route.Definition |
put(String path,
Route.Filter filter)
Append route that supports HTTP PUT method:
|
Route.Definition |
put(String path,
Route.Handler handler)
Append route that supports HTTP PUT method:
|
Route.Definition |
put(String path,
Route.OneArgHandler handler)
Append route that supports HTTP PUT method:
|
Route.Definition |
put(String path,
Route.ZeroArgHandler handler)
Append route that supports HTTP PUT method:
|
Route.Handler |
redirect(Status status,
String location)
Redirect to the given url with status code defaulting to
Status.FOUND . |
Route.Handler |
redirect(String location)
Redirect to the given url with status code defaulting to
Status.FOUND . |
void |
start()
Bootstrap
|
void |
start(String[] args)
Bootstrap
|
Route.Filter |
staticFile(String location)
Serve a single file from classpath.
|
void |
stop()
Stop the application, close all the modules and stop the web server.
|
Route.Definition |
trace()
Append a default trace implementation under the given path.
|
Route.Definition |
trace(String path,
Route.Filter filter)
Append a route that supports HTTP TRACE method:
|
Route.Definition |
trace(String path,
Route.Handler handler)
Append a route that supports HTTP TRACE method:
|
Route.Definition |
trace(String path,
Route.OneArgHandler handler)
Append route that supports HTTP TRACE method:
|
Route.Definition |
trace(String path,
Route.ZeroArgHandler handler)
Append route that supports HTTP TRACE method:
|
Jooby |
use(Body.Formatter formatter)
Append a body formatter for write HTTP messages.
|
Jooby |
use(Body.Parser parser)
Append a body parser for write HTTP messages.
|
Jooby |
use(Class<?> routeClass)
Append one or more routes defined in the given class.
|
Jooby |
use(com.typesafe.config.Config config)
Set the application configuration object.
|
Jooby |
use(Jooby.Module module)
Register a application module.
|
Jooby |
use(Request.Module module)
Register a request module.
|
Session.Definition |
use(Session.Store sessionStore)
Setup a session store to use.
|
Route.Definition |
use(String path,
Route.Filter filter)
Append a new filter that matches any method under the given path.
|
Route.Definition |
use(String path,
Route.Handler handler)
Append a new route handler that matches any method under the given path.
|
Route.Definition |
use(String verb,
String path,
Route.Filter filter)
Append a new filter that matches any method under the given path.
|
Route.Definition |
use(String verb,
String path,
Route.Handler handler)
Append a new route handler that matches any method under the given path.
|
WebSocket.Definition |
ws(String path,
WebSocket.Handler handler)
Append a new WebSocket handler under the given path.
|
@Nonnull public Jooby env(Env.Builder env)
Env.Builder
to use.env
- A custom env builder.@Nonnull public Session.Definition use(@Nonnull Session.Store sessionStore)
sessionStore
- A session store.@Nonnull public Jooby use(@Nonnull Body.Formatter formatter)
formatter
- A body formatter.@Nonnull public Jooby use(@Nonnull Body.Parser parser)
parser
- A body parser.@Nonnull public Route.Definition use(@Nonnull String path, @Nonnull Route.Filter filter)
path
- A path pattern.filter
- A filter to execute.@Nonnull public Route.Definition use(@Nonnull String verb, @Nonnull String path, @Nonnull Route.Filter filter)
verb
- A HTTP verb.path
- A path pattern.filter
- A filter to execute.@Nonnull public Route.Definition use(@Nonnull String verb, @Nonnull String path, @Nonnull Route.Handler handler)
verb
- A HTTP verb.path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition use(@Nonnull String path, @Nonnull Route.Handler handler)
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition get(String path)
get("/favicon.ico");This method is a shorcut for:
get("/favicon.ico", file("/favicon.ico");
path
- A path pattern.@Nonnull public Route.Definition get(@Nonnull String path, @Nonnull Route.Handler handler)
get("/", (req, rsp) -> { rsp.send(something); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition get(@Nonnull String path, @Nonnull Route.OneArgHandler handler)
get("/", (req) -> "hello" );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition get(@Nonnull String path, @Nonnull Route.ZeroArgHandler handler)
get("/", () -> "hello" );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition get(@Nonnull String path, @Nonnull Route.Filter filter)
get("/", (req, rsp, chain) -> { chain.next(req, rsp); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.filter
- A filter to execute.@Nonnull public Route.Definition post(@Nonnull String path, @Nonnull Route.Handler handler)
post("/", (req, rsp) -> { rsp.send(something); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition post(@Nonnull String path, @Nonnull Route.OneArgHandler handler)
post("/", (req) -> "hello" );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition post(@Nonnull String path, @Nonnull Route.ZeroArgHandler handler)
post("/", () -> "hello" );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition post(@Nonnull String path, @Nonnull Route.Filter filter)
post("/", (req, rsp, chain) -> { chain.next(req, rsp); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.filter
- A filter to execute.public Route.Definition head(@Nonnull String path, @Nonnull Route.Handler handler)
post("/", (req, rsp) -> { rsp.send(something); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition head(@Nonnull String path, @Nonnull Route.OneArgHandler handler)
head("/", (req) -> "hello" );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition head(@Nonnull String path, @Nonnull Route.ZeroArgHandler handler)
head("/", () -> "hello" );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition head(@Nonnull String path, @Nonnull Route.Filter filter)
post("/", (req, rsp, chain) -> { chain.next(req, rsp); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.filter
- A filter to execute.@Nonnull public Route.Definition head()
get("/", (req, rsp) -> { rsp.send(something); // This route provides default HEAD for this GET route. });
@Nonnull public Route.Definition options(@Nonnull String path, @Nonnull Route.Handler handler)
options("/", (req, rsp) -> { rsp.header("Allow", "GET, POST"); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition options(@Nonnull String path, @Nonnull Route.OneArgHandler handler)
options("/", (req) -> Body.status(200).header("Allow", "GET, POST") );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition options(@Nonnull String path, @Nonnull Route.ZeroArgHandler handler)
options("/", () -> Body.status(200).header("Allow", "GET, POST") );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition options(@Nonnull String path, @Nonnull Route.Filter filter)
options("/", (req, rsp, chain) -> { rsp.header("Allow", "GET, POST"); chain.next(req, rsp); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.filter
- A callback to execute.@Nonnull public Route.Definition options()
get("/", (req, rsp) -> { rsp.send(something); }); post("/", (req, rsp) -> { rsp.send(something); });OPTINOS / produces a response with a Allow header set to: GET, POST.
@Nonnull public Route.Definition put(@Nonnull String path, @Nonnull Route.Handler handler)
put("/", (req, rsp) -> { rsp.send(something); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A route to execute.@Nonnull public Route.Definition put(@Nonnull String path, @Nonnull Route.OneArgHandler handler)
put("/", (req) -> Body.status(202) );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition put(@Nonnull String path, @Nonnull Route.ZeroArgHandler handler)
put("/", () -> { Body.status(202) });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition put(@Nonnull String path, @Nonnull Route.Filter filter)
put("/", (req, rsp, chain) -> { chain.next(req, rsp); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.filter
- A callback to execute.@Nonnull public Route.Definition patch(@Nonnull String path, @Nonnull Route.Handler handler)
patch("/", (req, rsp) -> { rsp.send(something); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A route to execute.@Nonnull public Route.Definition patch(@Nonnull String path, @Nonnull Route.OneArgHandler handler)
patch("/", (req) -> Body.status(202) );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition patch(@Nonnull String path, @Nonnull Route.ZeroArgHandler handler)
patch("/", () -> { Body.status(202) });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition patch(@Nonnull String path, @Nonnull Route.Filter filter)
patch("/", (req, rsp, chain) -> { chain.next(req, rsp); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.filter
- A callback to execute.@Nonnull public Route.Definition delete(@Nonnull String path, @Nonnull Route.Handler handler)
delete("/", (req, rsp) -> { rsp.status(304); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition delete(@Nonnull String path, @Nonnull Route.OneArgHandler handler)
delete("/", (req) -> Body.status(204) );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition delete(@Nonnull String path, @Nonnull Route.ZeroArgHandler handler)
delete("/", () -> Body.status(204) );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition delete(@Nonnull String path, @Nonnull Route.Filter filter)
delete("/", (req, rsp, chain) -> { rsp.status(304); chain.next(req, rsp); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.filter
- A callback to execute.@Nonnull public Route.Definition trace(@Nonnull String path, @Nonnull Route.Handler handler)
trace("/", (req, rsp) -> { rsp.send(...); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A callback to execute.@Nonnull public Route.Definition trace(@Nonnull String path, @Nonnull Route.OneArgHandler handler)
trace("/", (req) -> "trace" );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition trace(@Nonnull String path, @Nonnull Route.ZeroArgHandler handler)
trace("/", () -> "trace" );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition trace(@Nonnull String path, @Nonnull Route.Filter filter)
trace("/", (req, rsp, chain) -> { chain.next(req, rsp); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.filter
- A callback to execute.@Nonnull public Route.Definition trace()
TRACE /path header1: value header2: value
@Nonnull public Route.Definition connect(@Nonnull String path, @Nonnull Route.Handler handler)
connect("/", (req, rsp, chain) -> { chain.next(req, rsp); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition connect(@Nonnull String path, @Nonnull Route.OneArgHandler handler)
connect("/", (req) -> "hello" );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition connect(@Nonnull String path, @Nonnull Route.ZeroArgHandler handler)
connect("/", () -> "connected" );This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.handler
- A handler to execute.@Nonnull public Route.Definition connect(@Nonnull String path, @Nonnull Route.Filter filter)
connect("/", (req, rsp, chain) -> { chain.next(req, rsp); });This is a singleton route so make sure you don't share or use global variables.
path
- A path pattern.filter
- A filter to execute.@Nonnull public Route.Definition assets(@Nonnull String path)
assets("/assets/**");Resources are served from root of classpath, for example
GET /assets/file.js
will
be resolve as classpath resource at the same location.path
- The path to publish.@Nonnull public Jooby use(@Nonnull Class<?> routeClass)
Append one or more routes defined in the given class.
use(MyRoute.class); ... // MyRoute.java @Path("/") public class MyRoute { @GET public String hello() { return "Hello Jooby"; } }
Programming model is quite similar to JAX-RS/Jersey with some minor differences and/or simplifications.
To learn more about Mvc Routes, please check Path
,
Produces
Consumes
and
Viewable
.
routeClass
- A route(s) class.public Route.Handler redirect(String location)
Status.FOUND
.
rsp.redirect("/foo/bar"); rsp.redirect("http://example.com"); rsp.redirect("http://example.com"); rsp.redirect("../login");Redirects can be a fully qualified URI for redirecting to a different site:
rsp.redirect("http://google.com");Redirects can be relative to the root of the host name. For example, if you were on
http://example.com/admin/post/new
, the following redirect to /admin would
land you at http://example.com/admin
:
rsp.redirect("/admin");Redirects can be relative to the current URL. A redirection of post/new, from
http://example.com/blog/admin/
(notice the trailing slash), would give you
http://example.com/blog/admin/post/new.
rsp.redirect("post/new");Redirecting to post/new from
http://example.com/blog/admin
(no trailing slash),
will take you to http://example.com/blog/post/new
.
If you found the above behavior confusing, think of path segments as directories (have trailing slashes) and files, it will start to make sense.
Pathname relative redirects are also possible. If you were onhttp://example.com/admin/post/new
, the following redirect would land you at
http//example.com/admin
:
rsp.redirect("..");A back redirection will redirect the request back to the
Referer
, defaulting to
/
when missing.
rsp.redirect("back");
location
- Either a relative or absolute location.public Route.Filter staticFile(@Nonnull String location)
{ // serve the welcome.html from classpath root get("/", file("welcome.html"); }
location
- Absolute classpath location.public Route.Handler redirect(Status status, String location)
Status.FOUND
.
rsp.redirect("/foo/bar"); rsp.redirect("http://example.com"); rsp.redirect("http://example.com"); rsp.redirect("../login");Redirects can be a fully qualified URI for redirecting to a different site:
rsp.redirect("http://google.com");Redirects can be relative to the root of the host name. For example, if you were on
http://example.com/admin/post/new
, the following redirect to /admin would
land you at http://example.com/admin
:
rsp.redirect("/admin");Redirects can be relative to the current URL. A redirection of post/new, from
http://example.com/blog/admin/
(notice the trailing slash), would give you
http://example.com/blog/admin/post/new.
rsp.redirect("post/new");Redirecting to post/new from
http://example.com/blog/admin
(no trailing slash),
will take you to http://example.com/blog/post/new
.
If you found the above behavior confusing, think of path segments as directories (have trailing slashes) and files, it will start to make sense.
Pathname relative redirects are also possible. If you were onhttp://example.com/admin/post/new
, the following redirect would land you at
http//example.com/admin
:
rsp.redirect("..");A back redirection will redirect the request back to the
Referer
, defaulting to
/
when missing.
rsp.redirect("back");
status
- A redirect status.location
- Either a relative or absolute location.@Nonnull public Jooby use(@Nonnull Jooby.Module module)
module
- The module to register.Jooby.Module
@Nonnull public Jooby use(@Nonnull Request.Module module)
module
- The module to register.Request.Module
@Nonnull public Jooby use(@Nonnull com.typesafe.config.Config config)
application.conf
doesn't work for you or when you need/want to register two
or more files.config
- The application configuration object.Config
@Nonnull public Jooby err(@Nonnull Err.Handler err)
Err.Default
does content
negotation and this method allow to override/complement default handler.err
- A route error handler.@Nonnull public WebSocket.Definition ws(@Nonnull String path, @Nonnull WebSocket.Handler handler)
ws("/ws", (socket) -> { // connected socket.onMessage(message -> { System.out.println(message); }); socket.send("Connected"): });
path
- A path pattern.handler
- A connect callback.public void start() throws Exception
The bootstrap process is defined as follows:
application.conf
or custom, see use(Config)
Modules
propertiesmodules
Guice Injector
is created.Jooby.Module.configure(Env, Config, Binder)
for each module.start method
for each module.Exception
- If something fails to start.public void start(String[] args) throws Exception
The bootstrap process is defined as follows:
application.conf
or custom, see use(Config)
Modules
propertiesmodules
Guice Injector
is created.Jooby.Module.configure(Env, Config, Binder)
for each module.start method
for each module.args
- Application arguments.Exception
- If something fails to start.public void stop()
Copyright © 2015. All rights reserved.