Do zero ao REST em 5 minutos com SpringBoot

Este post visa explicar de forma simples como criar um “hello world” RESTFul web service com Spring Boot.

Fique ligado no blog, por que, como já foi dito, nos próximos 2 posts entraremos em maiores detalhes sobre a sopa de letrinhas dos verbos REST, POST, PUT, GET e DELETE na prática e depois documentaremos a nossa API com o framewrok Swagger. E abordagem nesses posts será totalmente mão na massa. É isso aí bons estudos.

• Cerca de 5 minutos
• Qualquer IDE de preferência o Eclipse
• JDK 1.8 ou superior
• Maven 3.33+

Onde baixar os códigos do projeto

Você pode baixar o código aqui e descompactar o arquivo zip e importar não sua IDE de preferencia ou clonar usando Git:

git clone https://github.com/leandrocgsi/simple-rest-example.git

Para mais detalhes e para evoluir este projeto acesse a página de guias de inicialização da fundação Spring. Além disso serão feitos mais 2 posts fechando uma série sobre Spring Boot e RESTful abordando os 4 principais verbos REST e como documentar API’s com o framework Swagger. O código dos próximos posts já está implementado e você pode acessar o de verbos aqui e o com Swagger aqui.

E a teoria como fica?

Se você está lendo este post eu acredito que você conheça o mínimo de teoria sobre REST e Web-Services mas se não conhece temos 3 posts que abordam esses temas de forma teórica sendo um sobre Web Services, outro sobre RESTful Web Services e outro sobre os HTTP Status Codes em Serviços REST mais comuns.

Hora de codar

Então chega de conversa e vamos botar a mão na massa ou melhor no código. Com o Eclipse aberto clique em novo escolha a opção Maven Project como na imagem abaixo.

Na próxima janela selecione a opção “Create a simple project(skyp archetype selection)”. Isso “diz” ao Maven que você irá construir seu projeto do zero com uma estrutura padrão Maven mas sem usar nenhum Archetype pronto.

Na próxima tela defina o Goup Id do seu projeto, no nosso caso “br.com.erudio”. Defina também o Artifact Id (nome) do seu projeto e a versão. Feito isto clique em next.

Se tudo tiver corrido bem você terá um projeto com uma estrutura similar à imagem abaixo. Abra o arquivo “pom.xml” e vamos fazer algumas alterações nele.

A estrutura original do pom deve ser algo similar a esta:

<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>br.com.erudio</groupid>
    <artifactid>simple-rest-example</artifactid>
    <version>0.0.1-SNAPSHOT</version>

</project>

Primeiro informamos o “parentesco” do nosso projeto em relação ao Spring boot. Logo abaixo adicionamos a dependência do Spring Boot Starter Web que como o próprio nome diz é o responsável por inicializar nossa aplicação. Definimos também a versão do Java no nosso caso 1.8. Depois precisamos configurar o processo de build que é extremamente simples. E por fim adicionamos os repositórios de onde o Maven irá baixar as dependências e plug-ins necessários ao projeto. Feito isso nos já temos a estrutura básica de um projeto Spring Boot.

<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>br.com.erudio</groupid>
    <artifactid>simple-rest-example</artifactid>
    <version>0.0.1-SNAPSHOT</version>

    <!-- Adicionando o Spring Boot ao projeto -->
    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>1.3.3.RELEASE</version>
    </parent>

    <!-- Adicionando a dependencia do Spring Boot Starter Web -->
    <dependencies>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>
    </dependencies>

    <!-- Configurando a versão do Java -->
    <properties>
        <java.version>1.8</java.version>
    </properties>

    <!-- Configurando o processo de build da aplicação -->
    <build>
        <plugins>
            <plugin>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-maven-plugin</artifactid>
            </plugin>
        </plugins>
    </build>

    <!-- Adicionando o repositório do Spring de onde o Maven irá baixar as dependências -->
    <repositories>
        <repository>
            <id>spring-releases</id>
            <url>https://repo.spring.io/libs-release</url>
        </repository>
    </repositories>

    <!-- Adicionando o repositório do Spring de onde o Maven irá baixar os plugins -->
    <pluginrepositories>
        <pluginrepository>
            <id>spring-releases</id>
            <url>https://repo.spring.io/libs-release</url>
        </pluginrepository>
    </pluginrepositories>

</project>

Como se pode ver o nosso projeto está com um marker de erro e a versão do Java está como 1.5 e não 1.8 como definimos no pom.xml.

Clique com o direito sobre o projeto escola a opção Build Path >> Configure Build Path

Na aba libraries selecione sua JRE System Library e clique em editar.

Na proxima janela selecione o radio Alternate JRE e escolha sua versão do Java e clique em Finish.

Como se pode ver agora a versão esta correta, então clique em OK.

Além disso temos um Mavem problem etratanto isso é apenas um bug do Eclipse e apesar do warning o projeto executa normalmente. Para remover basta escolher a opção quick fix.

Na janela a seguir escolha a opção Update project configuration clique em Finish e adeus warning.

Agora que eliminamos todos os warnings o ambiente está pronto. Selecione o source folder src/main/java.

Clique com o direito New >> Package

Na próxima janela defina o nome do pacote no nosso caso “br.com.erudio”.

Feito isso abra o souce folder e clicando sobre o pacote com o botão direito New >> Class

Na próxima janela defina o nome Greeting(Saudação em inglês já que é um Hello World) e insira o código abaixo. Como você pode perceber é um simples POJO que representa o objeto que será retornado aos clientes de nossa API.

package br.com.erudio;

public class Greeting {

    private final long id;
    private final String content;

    public Greeting(long id, String content) {
        this.id = id;
        this.content = content;
    }

    public long getId() {
        return id;
    }

    public String getContent() {
        return content;
    }
}

Agora crie uma nova classe com o nome GreetingController que é o nosso endpoit que receberá as requisições REST. Como se pode ver as requisições para a url {{contexto}}/greeting invocarão o método greeting que recebe um @RequestParam com um nome. Quando esse valor não é informado o valor padrão é “World”. As requisições para esse endpoint retornam uma saudação com um id automático simulando um acesso a um banco de dados e uma string com a saudação.

package br.com.erudio;

import java.util.concurrent.atomic.AtomicLong;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

    private static final String template = "Hello, %s!";
    private final AtomicLong counter = new AtomicLong();

    @RequestMapping("/greeting")
    public Greeting greeting(@RequestParam(value="name", defaultValue="World") String name) {
        return new Greeting(counter.incrementAndGet(), String.format(template, name));
    }
}

Agora vamos definir a classe de inicialização de nossa aplicação chamada Application. Acredite ou não com apenas o trecho de código abaixo você tem sua aplicação pronta sem necessidade de container ou server. Sim o Spring Boot te liberta de Tomcat, Jetty ou os “obesos” JBoss e GlassFish e seus EJB’s.

package br.com.erudio;

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

@SpringBootApplication
public class Application {

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

Com a aplicação pronta clique com o direito dobre a classe Application Run As >> Java Application. Caso você esteja usando a Spring Source Tool Suite (ferramenta baseada no Eclipse com foco em desenvolvimento Spring) como é o meu caso pode excolher a opção Spring Boot App.

Se você tiver feito tudo corretamente terá um console parecido com a imagem abaixo observe que o endpoint /greeting foi mapeado e que nossa aplicação iniciou em apenas 4 segundos.

Vá no browser de sua preferencia e acesse localhost:8080/greeting e terá uma resposta parecida com a imagem abaixo.

Agora adicione um parametro a mais a nossa url localhost:8080/greeting?name=Olá Semeru Blog ou outro parametro de sua preferência e terá uma resposta similar à imagem abaixo.

Fique ligado no blog, por que, como já foi dito, nos próximos 2 posts entraremos em maiores detalhes sobre a sopa de letrinhas dos verbos REST, POST, PUT, GET e DELETE na prática e depois documentaremos a nossa API com o framewrok Swagger. E abordagem nesses posts será totalmente mão na massa. É isso aí bons estudos.

Treinamentos relacionados com este post