/*
* Copyright 2011- Per Wendel
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package spark;
import spark.exception.ExceptionHandlerImpl;
import spark.exception.ExceptionMapper;
import spark.route.HttpMethod;
import spark.utils.SparkUtils;
/**
* The main building block of a Spark application is a set of routes. A route is
* made up of three simple pieces:
* <ul>
* <li>A verb (get, post, put, delete, head, trace, connect, options)</li>
* <li>A path (/hello, /users/:name)</li>
* <li>A callback (request, response)</li>
* </ul>
* Example:
* get("/hello", (request, response) -> {
* return "Hello World!";
* });
*
* @author Per Wendel
*/
public final class Spark extends SparkBase {
// Hide constructor
private Spark() {
}
/**
* Map the route for HTTP GET requests
*
* @param path the path
* @param route The route
*/
public static synchronized void get(final String path, final Route route) {
addRoute(HttpMethod.get.name(), wrap(path, route));
}
/**
* Map the route for HTTP POST requests
*
* @param path the path
* @param route The route
*/
public static synchronized void post(String path, Route route) {
addRoute(HttpMethod.post.name(), wrap(path, route));
}
/**
* Map the route for HTTP PUT requests
*
* @param path the path
* @param route The route
*/
public static synchronized void put(String path, Route route) {
addRoute(HttpMethod.put.name(), wrap(path, route));
}
/**
* Map the route for HTTP PATCH requests
*
* @param path the path
* @param route The route
*/
public static synchronized void patch(String path, Route route) {
addRoute(HttpMethod.patch.name(), wrap(path, route));
}
/**
* Map the route for HTTP DELETE requests
*
* @param path the path
* @param route The route
*/
public static synchronized void delete(String path, Route route) {
addRoute(HttpMethod.delete.name(), wrap(path, route));
}
/**
* Map the route for HTTP HEAD requests
*
* @param path the path
* @param route The route
*/
public static synchronized void head(String path, Route route) {
addRoute(HttpMethod.head.name(), wrap(path, route));
}
/**
* Map the route for HTTP TRACE requests
*
* @param path the path
* @param route The route
*/
public static synchronized void trace(String path, Route route) {
addRoute(HttpMethod.trace.name(), wrap(path, route));
}
/**
* Map the route for HTTP CONNECT requests
*
* @param path the path
* @param route The route
*/
public static synchronized void connect(String path, Route route) {
addRoute(HttpMethod.connect.name(), wrap(path, route));
}
/**
* Map the route for HTTP OPTIONS requests
*
* @param path the path
* @param route The route
*/
public static synchronized void options(String path, Route route) {
addRoute(HttpMethod.options.name(), wrap(path, route));
}
/**
* Maps a filter to be executed before any matching routes
*
* @param path the path
* @param filter The filter
*/
public static synchronized void before(String path, Filter filter) {
addFilter(HttpMethod.before.name(), wrap(path, filter));
}
/**
* Maps a filter to be executed after any matching routes
*
* @param path the path
* @param filter The filter
*/
public static synchronized void after(String path, Filter filter) {
addFilter(HttpMethod.after.name(), wrap(path, filter));
}
//////////////////////////////////////////////////
// BEGIN route/filter mapping with accept type
//////////////////////////////////////////////////
/**
* Map the route for HTTP GET requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
*/
public static synchronized void get(String path, String acceptType, Route route) {
addRoute(HttpMethod.get.name(), wrap(path, acceptType, route));
}
/**
* Map the route for HTTP POST requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
*/
public static synchronized void post(String path, String acceptType, Route route) {
addRoute(HttpMethod.post.name(), wrap(path, acceptType, route));
}
/**
* Map the route for HTTP PUT requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
*/
public static synchronized void put(String path, String acceptType, Route route) {
addRoute(HttpMethod.put.name(), wrap(path, acceptType, route));
}
/**
* Map the route for HTTP PATCH requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
*/
public static synchronized void patch(String path, String acceptType, Route route) {
addRoute(HttpMethod.patch.name(), wrap(path, acceptType, route));
}
/**
* Map the route for HTTP DELETE requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
*/
public static synchronized void delete(String path, String acceptType, Route route) {
addRoute(HttpMethod.delete.name(), wrap(path, acceptType, route));
}
/**
* Map the route for HTTP HEAD requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
*/
public static synchronized void head(String path, String acceptType, Route route) {
addRoute(HttpMethod.head.name(), wrap(path, acceptType, route));
}
/**
* Map the route for HTTP TRACE requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
*/
public static synchronized void trace(String path, String acceptType, Route route) {
addRoute(HttpMethod.trace.name(), wrap(path, acceptType, route));
}
/**
* Map the route for HTTP CONNECT requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
*/
public static synchronized void connect(String path, String acceptType, Route route) {
addRoute(HttpMethod.connect.name(), wrap(path, acceptType, route));
}
/**
* Map the route for HTTP OPTIONS requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
*/
public static synchronized void options(String path, String acceptType, Route route) {
addRoute(HttpMethod.options.name(), wrap(path, acceptType, route));
}
/**
* Maps a filter to be executed before any matching routes
*
* @param filter The filter
*/
public static synchronized void before(Filter filter) {
addFilter(HttpMethod.before.name(), wrap(SparkUtils.ALL_PATHS, filter));
}
/**
* Maps a filter to be executed after any matching routes
*
* @param filter The filter
*/
public static synchronized void after(Filter filter) {
addFilter(HttpMethod.after.name(), wrap(SparkUtils.ALL_PATHS, filter));
}
/**
* Maps a filter to be executed before any matching routes
*
* @param path the path
* @param acceptType the accept type
* @param filter The filter
*/
public static synchronized void before(String path, String acceptType, Filter filter) {
addFilter(HttpMethod.before.name(), wrap(path, acceptType, filter));
}
/**
* Maps a filter to be executed after any matching routes
*
* @param path the path
* @param acceptType the accept type
* @param filter The filter
*/
public static synchronized void after(String path, String acceptType, Filter filter) {
addFilter(HttpMethod.after.name(), wrap(path, acceptType, filter));
}
//////////////////////////////////////////////////
// END route/filter mapping with accept type
//////////////////////////////////////////////////
//////////////////////////////////////////////////
// BEGIN Template View Routes
//////////////////////////////////////////////////
/**
* Map the route for HTTP GET requests
*
* @param path the path
* @param route The route
* @param engine the template engine
*/
public static synchronized void get(String path, TemplateViewRoute route, TemplateEngine engine) {
addRoute(HttpMethod.get.name(), TemplateViewRouteImpl.create(path, route, engine));
}
/**
* Map the route for HTTP GET requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param engine the template engine
*/
public static synchronized void get(String path,
String acceptType,
TemplateViewRoute route,
TemplateEngine engine) {
addRoute(HttpMethod.get.name(), TemplateViewRouteImpl.create(path, acceptType, route, engine));
}
/**
* Map the route for HTTP POST requests
*
* @param path the path
* @param route The route
* @param engine the template engine
*/
public static synchronized void post(String path, TemplateViewRoute route, TemplateEngine engine) {
addRoute(HttpMethod.post.name(), TemplateViewRouteImpl.create(path, route, engine));
}
/**
* Map the route for HTTP POST requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param engine the template engine
*/
public static synchronized void post(String path,
String acceptType,
TemplateViewRoute route,
TemplateEngine engine) {
addRoute(HttpMethod.post.name(), TemplateViewRouteImpl.create(path, acceptType, route, engine));
}
/**
* Map the route for HTTP PUT requests
*
* @param path the path
* @param route The route
* @param engine the template engine
*/
public static synchronized void put(String path, TemplateViewRoute route, TemplateEngine engine) {
addRoute(HttpMethod.put.name(), TemplateViewRouteImpl.create(path, route, engine));
}
/**
* Map the route for HTTP PUT requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param engine the template engine
*/
public static synchronized void put(String path,
String acceptType,
TemplateViewRoute route,
TemplateEngine engine) {
addRoute(HttpMethod.put.name(), TemplateViewRouteImpl.create(path, acceptType, route, engine));
}
/**
* Map the route for HTTP DELETE requests
*
* @param path the path
* @param route The route
* @param engine the template engine
*/
public static synchronized void delete(String path, TemplateViewRoute route, TemplateEngine engine) {
addRoute(HttpMethod.delete.name(), TemplateViewRouteImpl.create(path, route, engine));
}
/**
* Map the route for HTTP DELETE requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param engine the template engine
*/
public static synchronized void delete(String path,
String acceptType,
TemplateViewRoute route,
TemplateEngine engine) {
addRoute(HttpMethod.delete.name(), TemplateViewRouteImpl.create(path, acceptType, route, engine));
}
/**
* Map the route for HTTP PATCH requests
*
* @param path the path
* @param route The route
* @param engine the template engine
*/
public static synchronized void patch(String path, TemplateViewRoute route, TemplateEngine engine) {
addRoute(HttpMethod.patch.name(), TemplateViewRouteImpl.create(path, route, engine));
}
/**
* Map the route for HTTP PATCH requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param engine the template engine
*/
public static synchronized void patch(String path,
String acceptType,
TemplateViewRoute route,
TemplateEngine engine) {
addRoute(HttpMethod.patch.name(), TemplateViewRouteImpl.create(path, acceptType, route, engine));
}
/**
* Map the route for HTTP HEAD requests
*
* @param path the path
* @param route The route
* @param engine the template engine
*/
public static synchronized void head(String path, TemplateViewRoute route, TemplateEngine engine) {
addRoute(HttpMethod.head.name(), TemplateViewRouteImpl.create(path, route, engine));
}
/**
* Map the route for HTTP HEAD requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param engine the template engine
*/
public static synchronized void head(String path,
String acceptType,
TemplateViewRoute route,
TemplateEngine engine) {
addRoute(HttpMethod.head.name(), TemplateViewRouteImpl.create(path, acceptType, route, engine));
}
/**
* Map the route for HTTP TRACE requests
*
* @param path the path
* @param route The route
* @param engine the template engine
*/
public static synchronized void trace(String path, TemplateViewRoute route, TemplateEngine engine) {
addRoute(HttpMethod.trace.name(), TemplateViewRouteImpl.create(path, route, engine));
}
/**
* Map the route for HTTP TRACE requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param engine the template engine
*/
public static synchronized void trace(String path,
String acceptType,
TemplateViewRoute route,
TemplateEngine engine) {
addRoute(HttpMethod.trace.name(), TemplateViewRouteImpl.create(path, acceptType, route, engine));
}
/**
* Map the route for HTTP CONNECT requests
*
* @param path the path
* @param route The route
* @param engine the template engine
*/
public static synchronized void connect(String path, TemplateViewRoute route, TemplateEngine engine) {
addRoute(HttpMethod.connect.name(), TemplateViewRouteImpl.create(path, route, engine));
}
/**
* Map the route for HTTP CONNECT requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param engine the template engine
*/
public static synchronized void connect(String path,
String acceptType,
TemplateViewRoute route,
TemplateEngine engine) {
addRoute(HttpMethod.connect.name(), TemplateViewRouteImpl.create(path, acceptType, route, engine));
}
/**
* Map the route for HTTP OPTIONS requests
*
* @param path the path
* @param route The route
* @param engine the template engine
*/
public static synchronized void options(String path, TemplateViewRoute route, TemplateEngine engine) {
addRoute(HttpMethod.options.name(), TemplateViewRouteImpl.create(path, route, engine));
}
/**
* Map the route for HTTP OPTIONS requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param engine the template engine
*/
public static synchronized void options(String path,
String acceptType,
TemplateViewRoute route,
TemplateEngine engine) {
addRoute(HttpMethod.options.name(), TemplateViewRouteImpl.create(path, acceptType, route, engine));
}
//////////////////////////////////////////////////
// END Template View Routes
//////////////////////////////////////////////////
//////////////////////////////////////////////////
// BEGIN Response Transforming Routes
//////////////////////////////////////////////////
/**
* Map the route for HTTP GET requests
*
* @param path the path
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void get(String path, Route route, ResponseTransformer transformer) {
addRoute(HttpMethod.get.name(), ResponseTransformerRouteImpl.create(path, route, transformer));
}
/**
* Map the route for HTTP GET requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void get(String path, String acceptType, Route route, ResponseTransformer transformer) {
addRoute(HttpMethod.get.name(), ResponseTransformerRouteImpl.create(path, acceptType, route, transformer));
}
/**
* Map the route for HTTP POST requests
*
* @param path the path
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void post(String path, Route route, ResponseTransformer transformer) {
addRoute(HttpMethod.post.name(), ResponseTransformerRouteImpl.create(path, route, transformer));
}
/**
* Map the route for HTTP POST requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void post(String path, String acceptType, Route route, ResponseTransformer transformer) {
addRoute(HttpMethod.post.name(), ResponseTransformerRouteImpl.create(path, acceptType, route, transformer));
}
/**
* Map the route for HTTP PUT requests
*
* @param path the path
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void put(String path, Route route, ResponseTransformer transformer) {
addRoute(HttpMethod.put.name(), ResponseTransformerRouteImpl.create(path, route, transformer));
}
/**
* Map the route for HTTP PUT requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void put(String path, String acceptType, Route route, ResponseTransformer transformer) {
addRoute(HttpMethod.put.name(), ResponseTransformerRouteImpl.create(path, acceptType, route, transformer));
}
/**
* Map the route for HTTP DELETE requests
*
* @param path the path
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void delete(String path, Route route, ResponseTransformer transformer) {
addRoute(HttpMethod.delete.name(), ResponseTransformerRouteImpl.create(path, route, transformer));
}
/**
* Map the route for HTTP DELETE requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void delete(String path,
String acceptType,
Route route,
ResponseTransformer transformer) {
addRoute(HttpMethod.delete.name(), ResponseTransformerRouteImpl.create(path, acceptType, route, transformer));
}
/**
* Map the route for HTTP HEAD requests
*
* @param path the path
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void head(String path, Route route, ResponseTransformer transformer) {
addRoute(HttpMethod.head.name(), ResponseTransformerRouteImpl.create(path, route, transformer));
}
/**
* Map the route for HTTP HEAD requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void head(String path, String acceptType, Route route, ResponseTransformer transformer) {
addRoute(HttpMethod.head.name(), ResponseTransformerRouteImpl.create(path, acceptType, route, transformer));
}
/**
* Map the route for HTTP CONNECT requests
*
* @param path the path
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void connect(String path, Route route, ResponseTransformer transformer) {
addRoute(HttpMethod.connect.name(), ResponseTransformerRouteImpl.create(path, route, transformer));
}
/**
* Map the route for HTTP CONNECT requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void connect(String path,
String acceptType,
Route route,
ResponseTransformer transformer) {
addRoute(HttpMethod.connect.name(), ResponseTransformerRouteImpl.create(path, acceptType, route, transformer));
}
/**
* Map the route for HTTP TRACE requests
*
* @param path the path
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void trace(String path, Route route, ResponseTransformer transformer) {
addRoute(HttpMethod.trace.name(), ResponseTransformerRouteImpl.create(path, route, transformer));
}
/**
* Map the route for HTTP TRACE requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void trace(String path,
String acceptType,
Route route,
ResponseTransformer transformer) {
addRoute(HttpMethod.trace.name(), ResponseTransformerRouteImpl.create(path, acceptType, route, transformer));
}
/**
* Map the route for HTTP OPTIONS requests
*
* @param path the path
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void options(String path, Route route, ResponseTransformer transformer) {
addRoute(HttpMethod.options.name(), ResponseTransformerRouteImpl.create(path, route, transformer));
}
/**
* Map the route for HTTP OPTIONS requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void options(String path,
String acceptType,
Route route,
ResponseTransformer transformer) {
addRoute(HttpMethod.options.name(), ResponseTransformerRouteImpl.create(path, acceptType, route, transformer));
}
/**
* Map the route for HTTP PATCH requests
*
* @param path the path
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void patch(String path, Route route, ResponseTransformer transformer) {
addRoute(HttpMethod.patch.name(), ResponseTransformerRouteImpl.create(path, route, transformer));
}
/**
* Map the route for HTTP PATCH requests
*
* @param path the path
* @param acceptType the accept type
* @param route The route
* @param transformer the response transformer
*/
public static synchronized void patch(String path,
String acceptType,
Route route,
ResponseTransformer transformer) {
addRoute(HttpMethod.patch.name(), ResponseTransformerRouteImpl.create(path, acceptType, route, transformer));
}
//////////////////////////////////////////////////
// END Response Transforming Routes
//////////////////////////////////////////////////
//////////////////////////////////////////////////
// EXCEPTION mapper
//////////////////////////////////////////////////
/**
* Maps an exception handler to be executed when an exception occurs during routing
*
* @param exceptionClass the exception class
* @param handler The handler
*/
public static synchronized void exception(Class<? extends Exception> exceptionClass, ExceptionHandler handler) {
// wrap
ExceptionHandlerImpl wrapper = new ExceptionHandlerImpl(exceptionClass) {
@Override
public void handle(Exception exception, Request request, Response response) {
handler.handle(exception, request, response);
}
};
ExceptionMapper.getInstance().map(exceptionClass, wrapper);
}
//////////////////////////////////////////////////
// HALT methods
//////////////////////////////////////////////////
/**
* Immediately stops a request within a filter or route
* NOTE: When using this don't catch exceptions of type HaltException, or if catched, re-throw otherwise
* halt will not work
*/
public static void halt() {
throw new HaltException();
}
/**
* Immediately stops a request within a filter or route with specified status code
* NOTE: When using this don't catch exceptions of type HaltException, or if catched, re-throw otherwise
* halt will not work
*
* @param status the status code
*/
public static void halt(int status) {
throw new HaltException(status);
}
/**
* Immediately stops a request within a filter or route with specified body content
* NOTE: When using this don't catch exceptions of type HaltException, or if catched, re-throw otherwise
* halt will not work
*
* @param body The body content
*/
public static void halt(String body) {
throw new HaltException(body);
}
/**
* Immediately stops a request within a filter or route with specified status code and body content
* NOTE: When using this don't catch exceptions of type HaltException, or if catched, re-throw otherwise
* halt will not work
*
* @param status The status code
* @param body The body content
*/
public static void halt(int status, String body) {
throw new HaltException(status, body);
}
//////////////////////////////////////////////////
// model and view helper method
//////////////////////////////////////////////////
/**
* Constructs a ModelAndView with the provided model and view name
*
* @param model the model
* @param viewName the view name
* @return the model and view
*/
public static ModelAndView modelAndView(Object model, String viewName) {
return new ModelAndView(model, viewName);
}
}