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.htmlcom/*.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)modulesmodulesGuice Injector is created.modulestart 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.Modulepublic 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.Configpublic 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 propertiesmodulesGuice 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 propertiesmodulesGuice 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.