/ Frameworks

Um pouco sobre o microframework Spark

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

Um pouco sobre o microframework Spark
Share this