Spark Tutorial de introducción

Spark es un Framework Java diseñado para agilizar el proceso de creación de aplicaciones web, no requerimos inundar nuestro proyecto con anotaciones o con archivos de configuración XML, Spark hace uso del servidor embebido Jetty para alojar las aplicaciones por los que podemos iniciar fácilmente nuestras aplicaciones, veamos un pequeño ejemplo de inicio.

Lo primero que requerimos es crear un proyecto Maven y agregar las siguientes dependencias:

<dependencies>
    <dependency>
        <groupId>com.sparkjava</groupId>
        <artifactId>spark-core</artifactId>
        <version>2.5</version>
    </dependency>
</dependencies>

Como cualquier aplicación Java creamos una clase con su correspondiente método main(...), para crear el primer ejemplo hacemos los siguiente:

import static spark.Spark.get;
import static spark.Spark.port;

public class SparkApplication {

    public static void main(String[] args) {
        port(8088);
        get("/hello", (request, response) -> "Hello Spark Framework");
    }
}

Con unas cuantas líneas de código hemos logrado crear una aplicación web capaz de responder a las peticiones HTTP GET, la respuesta, de momento es un mensaje estático, pero podemos agregar contenido dinámico generado usando tecnologías como Velocity, por ejemplo.

El método port(####) configura el número de puerto en el que deseamos trabajar, si no lo indicamos se usa el puerto 4567 por defecto.

El método get(...) nos permite responder a una petición de tipo HTTP GET en la URL indicada, para nuestro ejemplo "/hello", el segundo parámetro corresponde a una expresión lambda la cual recibe los parámetros request y response, el primero contiene información de la petición y el segundo de la respuesta, esta expresión lamba devuelve la respuesta que en nuestro caso es el mensaje de saludo.

Como podemos observar Spark está construido para aprovechar las características del lenguaje Java 8, entre ellas  las expresiones lambdas, por ello es recomendable tener conocimientos sobre la tecnología Java 8 antes de empezar a utilizar este framework.

Sencillo verdad, veamos algo un poco más interesante.

Integrar Plantilla Thymeleaf a Spark

Thymeleaf es un motor de plantillas que nos permite procesar documentos HTML, esto nos servirá para generar el documento de respuesta a una determinada petición, si no conoces Thymeleaf deberías ver el tutorial de introducción, en este ejemplo usaremos la misma plantilla utilizada en dicho tutorial, los que mostraremos aquí será como se integran ambas tecnologías.

Primero agregamos las dependencias:

<dependency>
    <groupId>org.thymeleaf</groupId>
    <artifactId>thymeleaf</artifactId>
    <version>3.0.2.RELEASE</version>
</dependency>

Luego vamos a crear una clase en donde configuramos el TemplateResolver y el TemplateEngine, el primero es usado para ubicar las plantillas y el segundo para procesarlas.

public class ThymeleafUtil {

    private static TemplateEngine templateEngine;

    public static void init() {

        ClassLoaderTemplateResolver templateResolver = new ClassLoaderTemplateResolver();
        templateResolver.setTemplateMode(TemplateMode.HTML);
        templateResolver.setPrefix("templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setCacheable(false);
        
        templateEngine = new TemplateEngine();
        templateEngine.setTemplateResolver(templateResolver);
    }

    public static TemplateEngine getTemplateEngine() {       
        if(templateEngine == null) { init(); }    
        return templateEngine;
    }
    
    public static String process(String template, IContext context) {
        return getTemplateEngine().process(template, context);
    }
}

Una explicación más detallada de estas clases puedes encontrarla en el enlace mencionado previamente.

Ahora modificaremos el método get(...) de Spark para que responda con el documento procesado por Thymeleaf, las variables requeridas por la plantilla HTML son pasadas usando la interface Map.

public class SparkApplication {

    public static void main(String[] args) {

        port(8088);
        
        get("/hello", (req, res) -> {
            
            Map<String, Object> variables = new HashMap<>();
            variables.put("today", new Date());

            IContext context = new Context(req.raw().getLocale(), variables);
            String out = ThymeleafUtil.getTemplateEngine().process("home", context);

            return out;
        });
    }
}

La plantilla requiere una variable llamada today que indica la fecha actual, para ello usamos este fragmento de código:

Map<String, Object> variables = new HashMap<>();
variables.put("today", new Date());

Lo siguiente que hacemos es crear el IContext, luego obtenemos el TemplateEngine y procesamos la plantilla indicada.

IContext context = new Context(req.raw().getLocale(), variables);
String out = ThymeleafUtil.getTemplateEngine().process("home", context);

La plantilla de la que tanto hablamos es la siguiente:

src/main/resources/templates/home.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
    <head>
        <title>Servlet Thymeleaf Tutorial</title>
        <meta charset="UTF-8">
    </head>
    <body>
        <p th:text="#{home.welcome}">Mensaje de bienvenida</p>
        <p>Hoy es: <span th:text="${today}">01 Enero 2017</span></p>
    </body>
</html>

La integración con Thymeleaf la hemos hecho nosotros, aunque existe un paquete designado para ello, en los siguientes tutoriales Spark aprenderemos a utilizara.

Es todo por ahora, más adelante veremos ejemplos más avanzados con esta tecnología.

Descargar proyecto: spark-thymeleaf.zip