public class Jooby extends Object
A new application must extends Jooby, register one ore more Renderer
and some
routes
. It sounds like a lot of work to do, but it isn't.
public class MyApp extends Jooby { { renderer(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").value(); // 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
.
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
|
Constructor and Description |
---|
Jooby() |
Modifier and Type | Method and Description |
---|---|
Route.Definition |
assets(String path)
Send a static file.
|
Route.Definition |
assets(String path,
String location)
Send a static file.
|
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:
|
Route.Definitions |
delete(String path1,
String path2,
Route.Filter filter)
Append three routes that supports HTTP DELETE method on the same handler:
|
Route.Definitions |
delete(String path1,
String path2,
Route.Handler handler)
Append three routes that supports HTTP DELETE method on the same handler:
|
Route.Definitions |
delete(String path1,
String path2,
Route.OneArgHandler handler)
Append three routes that supports HTTP DELETE method on the same handler:
|
Route.Definitions |
delete(String path1,
String path2,
Route.ZeroArgHandler handler)
Append three routes that supports HTTP DELETE method on the same handler:
|
Route.Definitions |
delete(String path1,
String path2,
String path3,
Route.Filter filter)
Append three routes that supports HTTP DELETE method on the same handler:
|
Route.Definitions |
delete(String path1,
String path2,
String path3,
Route.Handler handler)
Append three routes that supports HTTP DELETE method on the same handler:
|
Route.Definitions |
delete(String path1,
String path2,
String path3,
Route.OneArgHandler handler)
Append three routes that supports HTTP DELETE method on the same handler:
|
Route.Definitions |
delete(String path1,
String path2,
String path3,
Route.ZeroArgHandler handler)
Append three routes that supports HTTP DELETE method on the same handler:
|
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,
Route.Filter filter)
Append a filter that supports HTTP GET method:
|
Route.Definition |
get(String path,
Route.Handler handler)
Append a 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.Definitions |
get(String path1,
String path2,
Route.Filter filter)
Append three routes that supports HTTP GET method on the same handler:
|
Route.Definitions |
get(String path1,
String path2,
Route.Handler handler)
Append two routes that supports HTTP GET method on the same handler:
|
Route.Definitions |
get(String path1,
String path2,
Route.OneArgHandler handler)
Append three routes that supports HTTP GET method on the same handler:
|
Route.Definitions |
get(String path1,
String path2,
Route.ZeroArgHandler handler)
Append three routes that supports HTTP GET method on the same handler:
|
Route.Definitions |
get(String path1,
String path2,
String path3,
Route.Filter filter)
Append three routes that supports HTTP GET method on the same handler:
|
Route.Definitions |
get(String path1,
String path2,
String path3,
Route.Handler handler)
Append three routes that supports HTTP GET method on the same handler:
|
Route.Definitions |
get(String path1,
String path2,
String path3,
Route.OneArgHandler handler)
Append three routes that supports HTTP GET method on the same handler:
|
Route.Definitions |
get(String path1,
String path2,
String path3,
Route.ZeroArgHandler handler)
Append three routes that supports HTTP GET method on the same handler:
|
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:
|
Jooby |
on(Predicate<String> predicate,
Runnable callback)
Run the given callback if and only if, app runs in the given enviroment.
|
Jooby |
on(String env,
Runnable callback)
Run the given callback if and only if, app runs in the given enviroment.
|
Jooby |
on(String env1,
String env2,
String env3,
Runnable callback)
Run the given callback if and only if, app runs in the given enviroment.
|
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:
|
Jooby |
parser(Parser parser)
Register a new param converter.
|
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.Definitions |
patch(String path1,
String path2,
Route.Filter filter)
Append three routes that supports HTTP PATCH method on the same handler:
|
Route.Definitions |
patch(String path1,
String path2,
Route.Handler handler)
Append three routes that supports HTTP PATCH method on the same handler:
|
Route.Definitions |
patch(String path1,
String path2,
Route.OneArgHandler handler)
Append three routes that supports HTTP PATCH method on the same handler:
|
Route.Definitions |
patch(String path1,
String path2,
Route.ZeroArgHandler handler)
Append three routes that supports HTTP PATCH method on the same handler:
|
Route.Definitions |
patch(String path1,
String path2,
String path3,
Route.Filter filter)
Append three routes that supports HTTP PATCH method on the same handler:
|
Route.Definitions |
patch(String path1,
String path2,
String path3,
Route.Handler handler)
Append three routes that supports HTTP PATCH method on the same handler:
|
Route.Definitions |
patch(String path1,
String path2,
String path3,
Route.OneArgHandler handler)
Append three routes that supports HTTP PATCH method on the same handler:
|
Route.Definitions |
patch(String path1,
String path2,
String path3,
Route.ZeroArgHandler handler)
Append three routes that supports HTTP PATCH method on the same handler:
|
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.Definitions |
post(String path1,
String path2,
Route.Filter filter)
Append three routes that supports HTTP POST method on the same handler:
|
Route.Definitions |
post(String path1,
String path2,
Route.Handler handler)
Append three routes that supports HTTP POST method on the same handler:
|
Route.Definitions |
post(String path1,
String path2,
Route.OneArgHandler handler)
Append three routes that supports HTTP POST method on the same handler:
|
Route.Definitions |
post(String path1,
String path2,
Route.ZeroArgHandler handler)
Append three routes that supports HTTP POST method on the same handler:
|
Route.Definitions |
post(String path1,
String path2,
String path3,
Route.Filter filter)
Append three routes that supports HTTP POST method on the same handler:
|
Route.Definitions |
post(String path1,
String path2,
String path3,
Route.Handler handler)
Append three routes that supports HTTP POST method on the same handler:
|
Route.Definitions |
post(String path1,
String path2,
String path3,
Route.OneArgHandler handler)
Append three routes that supports HTTP POST method on the same handler:
|
Route.Definitions |
post(String path1,
String path2,
String path3,
Route.ZeroArgHandler handler)
Append three routes that supports HTTP POST method on the same handler:
|
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.Definitions |
put(String path1,
String path2,
Route.Filter filter)
Append three routes that supports HTTP PUT method on the same handler:
|
Route.Definitions |
put(String path1,
String path2,
Route.Handler handler)
Append three routes that supports HTTP PUT method on the same handler:
|
Route.Definitions |
put(String path1,
String path2,
Route.OneArgHandler handler)
Append three routes that supports HTTP PUT method on the same handler:
|
Route.Definitions |
put(String path1,
String path2,
Route.ZeroArgHandler handler)
Append three routes that supports HTTP PUT method on the same handler:
|
Route.Definitions |
put(String path1,
String path2,
String path3,
Route.Filter filter)
Append three routes that supports HTTP PUT method on the same handler:
|
Route.Definitions |
put(String path1,
String path2,
String path3,
Route.Handler handler)
Append three routes that supports HTTP PUT method on the same handler:
|
Route.Definitions |
put(String path1,
String path2,
String path3,
Route.OneArgHandler handler)
Append three routes that supports HTTP PUT method on the same handler:
|
Route.Definitions |
put(String path1,
String path2,
String path3,
Route.ZeroArgHandler handler)
Append three routes that supports HTTP PUT method on the same handler:
|
Jooby |
renderer(Renderer renderer)
Append a response
Renderer for write HTTP messages. |
<T> T |
require(Class<T> type)
Ask Guice for the given type.
|
Session.Definition |
session(Class<? extends Session.Store> store)
Setup a session store to use.
|
Session.Definition |
session(Session.Store store)
Setup a session store to use.
|
void |
start()
Bootstrap
|
void |
start(String[] args)
Bootstrap
|
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(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(Jooby app)
Import ALL the direct routes from the given app.
|
Route.Namespace |
use(String pattern)
Define one or more routes under the same namespace:
|
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.
|
public Jooby use(Jooby app)
app
- Routes provider.public Route.Namespace use(String pattern)
{ use("/pets") .get("/{id}", req -> db.get(req.param("id").value())) .get(() -> db.values()); }
pattern
- Global pattern to use.public Jooby env(Env.Builder env)
Env.Builder
to use.env
- A custom env builder.public Jooby on(String env, Runnable callback)
{ on("dev", () -> { use(new DevModule()); }); }
env
- Environment where we want to run the callback.callback
- An env callback.public Jooby on(Predicate<String> predicate, Runnable callback)
{ on("dev", "test", () -> { use(new DevModule()); }); }
predicate
- Predicate to check the environment.callback
- An env callback.public Jooby on(String env1, String env2, String env3, Runnable callback)
{ on("dev", "test", "mock", () -> { use(new DevModule()); }); }
env1
- Environment where we want to run the callback.env2
- Environment where we want to run the callback.env3
- Environment where we want to run the callback.callback
- An env callback.public <T> T require(Class<T> type)
T
- Service type.type
- A service type.public Session.Definition session(Class<? extends Session.Store> store)
store
- A session store.public Session.Definition session(Session.Store store)
store
- A session store.public Jooby parser(Parser parser)
Parser
for more details.parser
- A parser.public Jooby renderer(Renderer renderer)
Renderer
for write HTTP messages.renderer
- A renderer renderer.public Route.Definition use(String path, Route.Filter filter)
path
- A path pattern.filter
- A filter to execute.public Route.Definition use(String verb, String path, Route.Filter filter)
verb
- A HTTP verb.path
- A path pattern.filter
- A filter to execute.public Route.Definition use(String verb, String path, Route.Handler handler)
verb
- A HTTP verb.path
- A path pattern.handler
- A handler to execute.public Route.Definition use(String path, Route.Handler handler)
path
- A path pattern.handler
- A handler to execute.public Route.Definition get(String path, 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.public Route.Definitions get(String path1, String path2, Route.Handler handler)
get("/model", "/mode/:id", req -> { return req.param("id").toOptional(String.class); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions get(String path1, String path2, String path3, Route.Handler handler)
get("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition get(String path, 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.public Route.Definitions get(String path1, String path2, Route.OneArgHandler handler)
get("/model", "/model/:id", req -> { return req.param("id").toOptional(String.class); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions get(String path1, String path2, String path3, Route.OneArgHandler handler)
get("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition get(String path, 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.public Route.Definitions get(String path1, String path2, Route.ZeroArgHandler handler)
get("/model", "/model/:id", req -> { return req.param("id").toOptional(String.class); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions get(String path1, String path2, String path3, Route.ZeroArgHandler handler)
get("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition get(String path, 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.public Route.Definitions get(String path1, String path2, Route.Filter filter)
get("/model", "/model/:id", req -> { return req.param("id").toOptional(String.class); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.filter
- A filter to execute.public Route.Definitions get(String path1, String path2, String path3, Route.Filter filter)
get("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.filter
- A filter to execute.public Route.Definition post(String path, 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.public Route.Definitions post(String path1, String path2, Route.Handler handler)
post("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions post(String path1, String path2, String path3, Route.Handler handler)
post("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition post(String path, 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.public Route.Definitions post(String path1, String path2, Route.OneArgHandler handler)
post("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions post(String path1, String path2, String path3, Route.OneArgHandler handler)
post("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition post(String path, 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.public Route.Definitions post(String path1, String path2, Route.ZeroArgHandler handler)
post("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions post(String path1, String path2, String path3, Route.ZeroArgHandler handler)
post("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition post(String path, 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.Definitions post(String path1, String path2, Route.Filter filter)
post("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.filter
- A filter to execute.public Route.Definitions post(String path1, String path2, String path3, Route.Filter filter)
post("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.filter
- A filter to execute.public Route.Definition head(String path, 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.public Route.Definition head(String path, 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.public Route.Definition head(String path, 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.public Route.Definition head(String path, 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()
get("/", (req, rsp) -> { rsp.send(something); // This route provides default HEAD for this GET route. });
public Route.Definition options(String path, 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.public Route.Definition options(String path, 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.public Route.Definition options(String path, 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.public Route.Definition options(String path, 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.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.
public Route.Definition put(String path, 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.public Route.Definitions put(String path1, String path2, Route.Handler handler)
put("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions put(String path1, String path2, String path3, Route.Handler handler)
put("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition put(String path, 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.public Route.Definitions put(String path1, String path2, Route.OneArgHandler handler)
put("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions put(String path1, String path2, String path3, Route.OneArgHandler handler)
put("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition put(String path, 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.public Route.Definitions put(String path1, String path2, Route.ZeroArgHandler handler)
put("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions put(String path1, String path2, String path3, Route.ZeroArgHandler handler)
put("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition put(String path, 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.public Route.Definitions put(String path1, String path2, Route.Filter filter)
put("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.filter
- A filter to execute.public Route.Definitions put(String path1, String path2, String path3, Route.Filter filter)
put("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.filter
- A filter to execute.public Route.Definition patch(String path, 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.public Route.Definitions patch(String path1, String path2, Route.Handler handler)
patch("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions patch(String path1, String path2, String path3, Route.Handler handler)
patch("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition patch(String path, 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.public Route.Definitions patch(String path1, String path2, Route.OneArgHandler handler)
patch("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions patch(String path1, String path2, String path3, Route.OneArgHandler handler)
patch("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition patch(String path, 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.public Route.Definitions patch(String path1, String path2, Route.ZeroArgHandler handler)
patch("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions patch(String path1, String path2, String path3, Route.ZeroArgHandler handler)
patch("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition patch(String path, 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.public Route.Definitions patch(String path1, String path2, Route.Filter filter)
patch("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.filter
- A filter to execute.public Route.Definitions patch(String path1, String path2, String path3, Route.Filter filter)
patch("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.filter
- A filter to execute.public Route.Definition delete(String path, 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.public Route.Definitions delete(String path1, String path2, Route.Handler handler)
delete("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions delete(String path1, String path2, String path3, Route.Handler handler)
delete("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition delete(String path, 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.public Route.Definitions delete(String path1, String path2, Route.OneArgHandler handler)
delete("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions delete(String path1, String path2, String path3, Route.OneArgHandler handler)
delete("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition delete(String path, 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.public Route.Definitions delete(String path1, String path2, Route.ZeroArgHandler handler)
delete("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.handler
- A handler to execute.public Route.Definitions delete(String path1, String path2, String path3, Route.ZeroArgHandler handler)
delete("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.handler
- A handler to execute.public Route.Definition delete(String path, 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.public Route.Definitions delete(String path1, String path2, Route.Filter filter)
delete("/p1", "/p2", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.filter
- A filter to execute.public Route.Definitions delete(String path1, String path2, String path3, Route.Filter filter)
delete("/p1", "/p2", "/p3", req -> { return req.path(); });This is a singleton route so make sure you don't share or use global variables.
path1
- A path pattern.path2
- A path pattern.path3
- A path pattern.filter
- A filter to execute.public Route.Definition trace(String path, 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.public Route.Definition trace(String path, 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.public Route.Definition trace(String path, 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.public Route.Definition trace(String path, 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.public Route.Definition trace()
TRACE /path header1: value header2: value
public Route.Definition connect(String path, 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.public Route.Definition connect(String path, 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.public Route.Definition connect(String path, 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.public Route.Definition connect(String path, 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.public Route.Definition assets(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.public Route.Definition assets(String path, String location)
Basic example
assets("/js/**", "/");A request for:
/js/jquery.js
will be translated to: /lib/jquery.js
.
Webjars example:
assets("/js/**", "/resources/webjars/{0}");A request for:
/js/jquery/2.1.3/jquery.js
will be translated to:
/resources/webjars/jquery/2.1.3/jquery.js
.
The {0}
represent the **
capturing group.
Another webjars example:
assets("/js/*-*.js", "/resources/webjars/{0}/{1}/{0}.js");
A request for: /js/jquery-2.1.3.js
will be translated to:
/resources/webjars/jquery/2.1.3/jquery.js
.
path
- The path to publish.location
- A resource location.public Jooby use(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
.
routeClass
- A route(s) class.public Jooby use(Jooby.Module module)
module
- The module to register.Jooby.Module
public Jooby use(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
public Jooby err(Err.Handler err)
Err.DefHandler
does content
negotation and this method allow to override/complement default handler.err
- A route error handler.public WebSocket.Definition ws(String path, 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.