Loading ...

O Blog de Tecnologia da Geofusion

Conheçendo o Spring Boot!

Conheçendo o Spring Boot!

 

Opa pessoal.

Nesse artigo vou contar um pouco da minha experiência com Spring Boot e como ele facilitou minha vida =]

Ao longo do artigo vamos desenvolvendo uma aplicação Rest simples, para mostrar os benefícios e velocidade que o Spring Boot nos traz!

 

O que é Spring Boot

Se você programa em JAVA provavelmente já usou ou ouviu falar sobre o Spring Framework. Atualmente na versão 4.x é uma ferramenta poderosa, madura e com uma comunidade gigantesca por trás. Mas e o Spring Boot ? Bom, já vou chegar lá.

Conforme o Spring foi evoluindo, suas configurações necessárias foram crescendo, o que antes era um simples XML começou a parecer a jornada de Frodo(Senhor dos Anéis) para ser configurado. Outro problema comum era a quantidade de dependências que era preciso gerenciar, aquele arquivo pom.xml cada vez maior não era nada legal.

A própria equipe do Spring junto com feedbacks da comunidade perceberam a necessidade de tornar o seu poderoso framework mais ágil, e então surgiu o Spring Boot!

Em versões  anteriores do Spring Framework, mesmo sem o “Boot” já era possível criar suas Beans e até mesmo sua aplicação inteira sem a a necessidade de XML’s. Tudo poderia ser feito por anotações e código Java.

O que o Spring Boot fez foi juntar todas essa facilidades que encontraram ao longo de sua evolução em um só lugar. Podemos dizer que o Spring juntou suas próprias tecnologias de forma a reaproveita-la e tornar a sua vida mais produtiva na hora de desenvolver.

 

Rápido e Leve

Me lembro que à alguns anos atrás, mesmo desenvolvendo com Spring MVC, algo que muito me incomodava era a hora da subir meu serviço para testar(mesmo localmente). Jboss, Glassfish, Weblogic e tantos outros Server’s JAVA EE. Muitas vezes era aquela tortura para configurar, cada um com seu “jeito” de configuração, XML’s gigantescos, e etc… Bom, esses tempos acabaram depois que conheci o Spring Boot! Um dos princípais pontos que gosto do Spring Boot é o fato dele ser “Embedded”, ou seja, o nosso server application está dentro da nossa aplicação, e não se assuste, esse server pode ser um Tomcat embedded ou até mesmo um Jetty. Sendo assim fica tão leve e rápido como uma Robbit!

Não tenho nada contra Server’s JAVA EE, mas a complexidade desses server’s pode acabar atrapalhando a agilidade de desenvolvimento, e o seu uso pode não ser necessário dependendo da arquitetura que iremos trabalhar(será que sempre vou precisar de um server EE ? Acho que não rsrs).

Talvez você se pergunte, “mas meu Jboss eu configuro do jeito que eu quero!”, “No Weblogic eu parametrizo o que eu quiser” e muitas outras justificativas. Agora, será que precisa configura tudo isso pra começar a desenvolver? Será que o único modo de escalar bem seus serviços é usando Servers EE? Tantas configurações ajudam ou atrapalham? É de se penssar…

Claro que existe uma curva de aprendizado para utilizar o Spring Boot, e o que quero mostrar aqui é que essa curva não é tão curva assim rsrs, vai valer apena acredite! E alias, essas configurações que fazemos em outros servers também conseguimos fazer no Jetty ou Tomcat(lembra que são embedded, então não é magica, existe um server rodando ali). A diferença é que essas configurações são muito mais enxutas e sem tantas complexidades.

Outro ponto bem legal, como podemos usar nosso server embedded, basta dar um start em nosso JAR e sua aplicação estará de pé. Sim, JAR e não WAR, podemos gerar um WAR e colocar ele dentro de um server qualquer se quisermos, mas porque faríamos isso se podemos simplesmente dar o comando java -jar gandalf.jar e tudo funciona, pois nosso server está junto com nossa aplicação.

 

E se eu precisar usar outras bibliotecas, acessar dados, exportar relatórios e etc ?

É legal frisar que por traz do Spring Boot existe uma comunidade chamada “SPRING” e esses caras são poderosos. Existem inúmeros projetos da Spring.io e todos se conversam muito bem entre sí, seria super tranquilo fazer uma aplicação com Spring Boot usando o Spring Data para acessar um MongoDB por exemplo( O Alexandre Queiroz escreveu sobre Spring Data e MongoDB aqui no blog recentemente, vale conferir). Não gosta do Spring Data ? Sem problemas, você pode usar as bibliotecas que quiser dentro do seu projeto, alias, muitas vezes você vai precisar.

 

Mão na Massa

Agora que já falei bastante sobre Spring Boot, que tal construirmos algo? (E sem XML, a não ser nosso pom é claro)

Vamos montar uma calculadora Rest, teremos os serviços para somar, subtrair, multiplicar e dividir. A logica é bem simples não é? Agora, se precisasse configurar seu container, gerar seu arquivo WAR para fazer deploy, configurar seus XML’s, properties e tudo mais… Acredito que toda essa configuração levaria muito mais tempo do que implementar a própria calculadora. Então vamos ver como fica com Spring Boot.

Vou usar o eclipse para construir o projeto, mas podem usar a IDE que melhor preferirem.

Vamos começar criando um projeto Maven simples, e então vamos mexer no arquivo pom.xml

 

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.lucas.spring.calculadora</groupId>
  <artifactId>CalcRest</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  <properties>
      <java.version>1.8</java.version>
  </properties>
  
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.1.RELEASE</version>
  </parent>
 
  <dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
  </dependencies>
  
  <build>
      <plugins>
          <plugin>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-maven-plugin</artifactId>
          </plugin>
      </plugins>
  </build>
</project>

vejam que adicionei o parent para o spring Boot:


  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.1.RELEASE</version>
  </parent>

 

E a dependência spring-boot-starter-web do Spring Boot


    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

Essa é a dependência que contem tudo o que precisamos para iniciar nosso projeto Web.

OBS: Coloquei a versão 8 do Java para nosso projeto e a tag build com o plugin do Spring Boot para o maven.

Vamos criar 2 pacotes em nosso projeto, um para conter noss Main Application e outro para conter nosso Controller onde iremos mapear os serviços da nossa calculadora. No meu caso criei o pacote com.lucas.spring.calculadora e com.lucas.spring.calculadora.controller

Dentro do pacote com.lucas.spring.calculadora vamos criar a classe Application

 

package com.lucas.spring.calculadora;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class Application {

	public static void main(String[] args) {
        ApplicationContext ctx = SpringApplication.run(Application.class, args);

	}

}

Repare que é uma simples classe main Java, e não precisamos mais do que isso para disponibilizar nossa aplicação.

A anotação @SpringBootApplication configura algumas coisas defaults do Spring para nós, ela inclui automaticamente as anotações:

@Configuration – classifica a classe como uma bean de configurações para a aplicação.

@EnableAutoConfiguration – habilita a auto configuração do Spring baseado em suas convenções.

@ComponentScan – Busca componentes, serviços, configurações que estão em nosso pacote(ou sub-pacote em nosso caso)

@EnableWebMvc – seta nossa aplicação como uma Web Application para o Spring

 

Por fim com uma única linha de código damos um “RUN” em nossa própria classe. Basta rodar nossa classe Main como uma aplicação JAVA comum, e por default o spring Boot vai iniciar o Tomcat Embedded na porta 8080 (é muito rápido, acredite!).

No pacote com.lucas.spring.calculadora.controller vamos criar a classe CalcController

 

package com.lucas.spring.calculadora.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/calculadora")
public class CalcController {

	@RequestMapping(value ="/soma", method = RequestMethod.GET)
	public Double soma(@RequestParam("valA") Double valA, @RequestParam("valB") Double valB) {

		return valA + valB;
	}

	@RequestMapping(value ="/subtrai", method = RequestMethod.GET)
	public Double subtrai(@RequestParam("valA") Double valA, @RequestParam("valB") Double valB) {

		return valA - valB;
	}

	@RequestMapping(value ="/multiplica", method = RequestMethod.GET)
	public Double multiplica(@RequestParam("valA") Double valA, @RequestParam("valB") Double valB) {

		return valA * valB;
	}

	@RequestMapping(value ="/divide", method = RequestMethod.GET)
	public Double divide(@RequestParam("valA") Double valA, @RequestParam("valB") Double valB) {

		return valA / valB;
	}

}

Aqui implementamos a logica da nossa calculadora e mapeamos as requisições, poderiamos dividir entre regras de negócio e mapeamento do nosso resource mas não é nosso foco.

A anotação @RestController habilita minha classe como controller e faz com que cada método seja anotado como @ResponseBody (Podemos falar melhor dessas anotações em outro artigo mais detalhado, por enquanto o importante é saber que essa anotação é responsável por habilitar o mapeamento de nossos métodos).

 

A anotação @RequestMapping mapeia literalmente nosso método, passamos o nome com que ele sera chamado e qual método de request ele é (GET, POST…), no nosso caso mapeei todos os métodos como GET.

Por fim a anotação @RequestParam apenas mapeia os parâmetros que quero receber na requisição(valor A e valor B) para efetuar minhas operações(Podemos detalhar melhor essa anotação em outro artigo também).

 

Pronto, Calculadora construída! Vamos subir e testar ?

Para testar vamos executar por linha de comando(no meu caso estou usando linux). Para isso, precisamos estar com o JAVA 8 e o Maven instalado.

Na pasta onde se encontra o projeto vamos executar o comando: mvn clean install

Se tudo ocorrer com sucesso será gerado o arquivo CalcRest-0.0.1-SNAPSHOT.jar na pasta target, é esse jar que iremos usar. Ainda na pasta do seu projeto entre com o comando java -jar target/CalcRest-0.0.1-SNAPSHOT.jar

O Spring Boot vai iniciar nossa aplicação com o Tomcat Embedded na porta 8080, feito isso teremos nossos calculadora mapeada, basta acessar pelo browser mesmo e nossas operações serão executadas, exemplo:

 
 

 
 

Ai está nossa calculadora com Spring Boot!

Nosso foco foi mostrar a produtividade que o Spring Boot nos trás para facilitar a vida de nós desenvolvedores, mesmo a aplicação que construímos sendo simples levaríamos mais tempo para configurar um server e preparar nossa aplicação para subir. Com Spring Boot isso fica realmente mais fácil, imagina em uma aplicação maior.

Qualquer dúvida, crítica ou sugestão podem mandar nos comentários pessoal.

Abraço,

Lucas .M Ramos

Geofusion.tech

2016 todos os direitos reservados.

www.geofusion.com.br