Um pouco sobre o microframework Spark

Spark Logo

O intuito deste tutorial não é aprofundar em todos os recursos do framework e sim apresentá-lo para a comunidade que ainda não conhece, outros exemplos e informações podem ser adquiridos na página oficial ou no github do projeto.

O que é e por que utilizar o framework Spark ?

Spark é um microframework baseado em Java para a criação de aplicações web, ele foi inspirado no framework Sinatra que é escrito em Ruby. Segundo seu site oficial, a intenção do Spark não é competir com o Sinatra, e sim ser utilizado por desenvolvedores que querem utilizar Java. Seu foco é ser o mais direto possível, sem a necessidade de pesadas configurações XML, habilitando assim o desenvolvimento super rápido de aplicações com o mínimo de esforço possível (Um paradigma totalmente diferente quando comparamos com o uso excessivo de anotações para a realização de coisas triviais como é no JAX-RS). A partir da versão 2.0.0 ele foi reescrito para o Java 8 e com isso passou a utilizar alguns de seus novos recursos, tais como as expressões Lambdas.

Pré-requisitos:

1 - Baixe e instale o JDK8

2 - Eclipse IDE com suporte ao Java 8 e plugin do Maven instalado.

Primeiro Passo: Criando o projeto Maven

1 - Com o eclipse aberto vá para a tela de criação de um novo projeto Maven (File > New > Maven Project).

2 - Clique em [Next] e escolha o archetype "maven-archetype-quickstart".

Escolha do Archetype

3 - Após a escolha do archetype clique em [Next] novamente, coloque as informações do projeto e clique em [Finish].

Criação do Projeto

4 - Com o projeto criado, delete o diretório src/test/java (para o nosso projeto não iremos realizar a criação de testes unitários).

Segundo Passo: Adicionando as dependências do Maven

1 - Abra o arquivo pom.xml e remova todas as dependências que são adicionadas por padrão

2 - Adicione as configurações para que o projeto funcione com a versão 8 do Java

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
    <maven.compiler.source>1.8</maven.compiler.source>    
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

3 - Adicione a dependência do Spark

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

Agora seu arquivo pom.xml está configurado e pronto para rodar.

Terceiro Passo: Download das dependências

Com o pom.xml totalmente configurado, precisaremos agora baixar as dependências do Spark, para isso, clique com o botão direito do mouse sobre o projeto e vá em [Run As > Maven install]. Aguarde o termino dos downloads e a tela final deverá estar parecida com a seguinte:

Download das dependências

Quarto Passo: Criando a primeira rota e executando o Spark

1 - Abra a classe App.java que foi gerada pelo Maven

2 - Adicione o import para o Spark:

import static spark.Spark.*;

3 - Edite o método main adicionando o seguinte código:

    public static void main(String[] args) {
    // Descomente a linha abaixo caso queira que o spark utilize uma porta diferente da padrão (4567).
    // setPort(8080);

    // Exemplo de GET simples
    get("/olamundo", (request, response) -> {
        return "Olá Mundo GET!";
    });

    // Exemplo de POST simples exibindo o corpo da requisição
    post("/olamundo", (request, response) -> {
        return "Olá Mundo POST! Corpo: " + request.body();
    });

    // Exemplo com parâmetro
    get("/usuario/:nome", (request, response) -> {
        return "Nome Informado: " + request.params(":nome");
    });

    // Exemplo redirecionando para uma rota
    get("/redirecionar", (request, response) -> {
        response.redirect("/olamundo");
        return null;
    });

    // Define o código de status para 401 Unauthorized (Não Autorizado)
    get("/paginaprivada", (request, response) -> {
        response.status(401);
        return "Vocẽ não tem acesso a página solicitada!";
    });

    // Exemplo de halt (para imediatamente a requisição de rota ou filtro) com retorno de status 403 Forbidden (Proibido)
    get("/paginaprotegida", (request, response) -> {
        halt(403, "Acesso proibido! :(");
        return null;
    });
}

Como você pode notar no código acima, a utilização dos verbos HTTP para as requisições é feita de uma maneira bem simples com o Spark.

4 - Rode a aplicação (Run As > Java Application)

5 - As seguintes rotas foram criadas, basta acessar qualquer uma delas e verificar seu funcionamento:

http://localhost:4567/olamundo
http://localhost:4567/olamundo (Utilizando POST)
http://localhost:4567/usuario/adriano
http://localhost:4567/redirecionar
http://localhost:4567/paginaprivada
http://localhost:4567/paginaprotegida

O Spark roda em um servidor standalone embutido chamado Jetty
Por padrão, ele é iniciado na porta 4567, para utilizar em uma porta diferente basta adicionar o seguinte linha do código (lembrando que ela deverá sempre ser incluída antes das rotas e dos filtros)

setPort(8080); // Sua aplicação estará funcionando na porta 8080

Conclusão

Com o Spark é possível criar aplicações web simples de maneira rápida sem a necessidade de toneladas de código de configuração.

Código Fonte

Clique aqui para baixar o projeto base desenvolvido.

Fonte

Spark Web Site

Github do Projeto