Desenvolvendo uma Aplicação Web com Spring Boot e Spring MVC

O Spring Boot é uma ferramenta para o desenvolvimento de aplicações que utilizam o framework Spring sem que seja necessária praticamente nenhuma configuração.

O Spring Boot é capaz de identificar quais as principais características da aplicação que está sendo desenvolvida e fazer automaticamente as configurações necessárias como, por exemplo, o arquivo applicationContext.xml, o web.xml e os data sources. Com isso os programadores ganham muito em produtividade, focando apenas no desenvolvimento da aplicação e não na configuração das ferramentas e frameworks utilizados, que são repetidos em praticamente todos os projetos.

Curso Completo: Curso de Spring Boot

O Spring sempre foi conhecido por ser um framework robusto e completo, mas que necessita de diversas configurações. Porém, versão a versão a ferramenta vem melhorando essa característica. Inicialmente, toda a configuração do Spring era feita com arquivos XML, mas na versão 2.5 foram introduzidas as anotações para que a mesma fosse feita diretamente no código, eliminando boa parte dos arquivos XML, facilitando bastante a configuração das aplicações. Agora com o Spring Boot, a ideia é que praticamente nenhuma configuração seja necessária, nem mesmo com anotações no código.

Ele tem quatro componentes principais para realizar as funções descritas anteriormente:

1. Configuração Automática: O Spring Boot identifica automaticamente as configurações necessárias pelo tipo de aplicação, por exemplo, se é uma aplicação Web, com JPA ou uma API Rest;
2. Dependências Automáticas: O Spring Boot adiciona, pelo tipo de projeto, um conjunto de bibliotecas que já foram testadas juntas, diminuindo problemas de compatibilidade;
3. Interface de Linha de Comando: disponibiliza uma interface de linha de comando onde o programador pode, de maneira fácil, criar, executar e modificar uma aplicação;
4. Actuator: É uma ferramenta que permite ao programador verificar o que está acontecendo internamente em uma aplicação com o Spring Boot.

Nesse artigo será mostrado como configurar a aplicação utilizando as configurações e as dependências automáticas do Spring Boot para criar uma aplicação web de maneira rápida e fácil e com praticamente nenhuma configuração necessária. Tecnicamente, vamos construir uma aplicação com o framework Spring MVC, o Spring Data JPA para fazer a persistência dos dados, o banco de dados H2 que já vem na instalação padrão do Spring Boot e o Thymeleaf para definir as visões. Este último é um template engine que substituiu o JSP.

Curso Completo: Curso de Persistência com Spring-Data JPA

Desenvolvimento da Aplicação

Será desenvolvida uma aplicação bem simples, apenas para demonstrar a funcionalidade do Spring Boot e, por isso, ela terá uma lista de livros que será organizada pelo nome do autor. Existirá uma página para cada um destes onde será exibida a sua respectiva lista de livros e um formulário que permitirá o cadastro de novos livros para esse autor. A aplicação desse artigo foi desenvolvida utilizando a IDE Eclipse, porém qualquer IDE pode ser utilizada.

Para a configuração da aplicação foi utilizado o Apache Maven (o Spring Boot suporta também o Gradle), para isso foram adicionadas quatro dependências do mesmo:

• o spring-boot-starter-web, que adiciona as dependências do Spring MVC;
• o spring-boot-starter-data-jpa, que adiciona as dependências do Spring Data;
• o spring-boot-starter-thymeleaf, que adiciona as dependências do thymeleaf para o desenvolvimento da visão, e;
• o com.h2database, que é o banco de dados que será utilizado nessa aplicação.

A Listagem 1 mostra o código do arquivo pom.xml com as dependências adicionadas.

<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.devmedia.mvc</groupId>
      <artifactId>agenda</artifactId>
      <version>0.0.1-SNAPSHOT</version>
 
      <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.2.1.RELEASE</version>
      </parent>
 
      <dependencies>
            <dependency>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
            <dependency>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-starter-thymeleaf</artifactId>
            </dependency>
            <dependency>
                  <groupId>com.h2database</groupId>
                  <artifactId>h2</artifactId>
            </dependency>
            <dependency>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-starter-test</artifactId>
                  <scope>test</scope>
            </dependency>
      </dependencies>
 
      <build>
            <plugins>
                  <plugin>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-maven-plugin</artifactId>
                  </plugin>
            </plugins>
      </build>
 
</project>

A tag no arquivo indica qual a versão do Spring Boot será utilizada no projeto, e assim, todas as bibliotecas do Spring Boot também utilizam essa versão. Verifiquem que na tag das três bibliotecas do Spring Boot (spring-boot-starter-web, spring-boot-starter-data-jpa, spring-boot-starter-thymeleaf) não são adicionadas as versões porque todas elas utilizam a versão que foi definida na tag .

Com a aplicação configurada, o primeiro passo no desenvolvimento foi a implementação da classe que representa os objetos que serão persistidos no banco de dados, que é a classe Livro. Essa classe tem diversas anotações do JPA, como a @Entity para indicar que a classe é uma entidade do banco de dados, a @Id para indicar que o campo id é o identificador da entidade, a @GeneratedValue que indica que o valor será gerado banco de dados e a @Column para definir alguns parâmetros das colunas como o nome, se ela pode receber valores nulos ou se o valor da coluna é único. A Listagem 2 mostra o código da classe Livro com suas anotações.

package com.devmedia.mvc.entity;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
 
@Entity
public class Livro {
 
      @Id 
      @GeneratedValue(strategy=GenerationType.AUTO) 
      private Long id; 
      
      @Column(name="titulo", nullable=false)
       private String titulo; 
 
      @Column(name="isbn", nullable=false, unique=true)
      private String isbn; 
      
      @Column(name="autor", nullable=false)
      private String autor;
      
      @Column(name="description", nullable=true)
      private String description;
      
      public Long getId() {
            return id;
      }
      public void setId(Long id) {
            this.id = id;
      }
      public String getTitulo() {
            return titulo;
      }
      public void setTitulo(String titulo) {
            this.titulo = titulo;
      }
      public String getIsbn() {
            return isbn;
      }
      public void setIsbn(String isbn) {
            this.isbn = isbn;
      }
      public String getAutor() {
            return autor;
      }
      public void setAutor(String autor) {
            this.autor = autor;
      }
      public String getDescription() {
            return description;
      }
      public void setDescription(String description) {
            this.description = description;
      }
 
}

Utilizando o H2, o banco de dados será sempre criado quando a aplicação for executada, o que facilita o desenvolvimento, pois não é necessária nenhuma configuração inicial para usar a aplicação. Por simplicidade, nesse artigo usaremos o H2 mesmo, porém o Spring Boot funciona com qualquer banco de dados que tenha um Driver JDBC.

Utilizando o Spring Data JPA é possível criar um repositório para a classe Livro: este é uma interface que contém diversos métodos pré-implementados para a manipulação de dados de uma entidade como métodos para salvar, deletar, listar e recuperar pelo o ID da classe. Para criar essa interface basta estender a interface JpaRepository; os tipos passados são a classe da entidade usada (no caso a classe Livro) e o tipo do atributo que é o identificador dessa classe (que neste caso é um Long).

Além disso, o programador pode criar diversos métodos específicos de busca, para isso basta seguir o padrão de nomeação dos métodos como, por exemplo, findByNomeAtributo. A Listagem 3 mostra o código dessa interface.

package com.devmedia.mvc.repository;
 
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
 
import com.devmedia.mvc.entity.Livro;
 
public interface LivroRepository extends 
JpaRepository<Livro, Long> {
 
      /**
       * Encontra todos os livros de um mesmo autor.
       * 
       * @param autor
       * @return lista de livros
       */
      List<Livro> findByAutor(String autor);
      
      /**
  * Encontra um livro a partir do seu título. 
 * Retorna uma lista pois podem existir
       * mais de um livro com mesmo título.
       * 
       * @param titulo
       * @return lista de livros
       */
      List<Livro> findByTitulo(String titulo);
      
      /**
* Encontra um livro a partir de seu isbn, como o isbn é único, 
apenas um livro pode ser encontrado. 
       * 
       * @param isbn
       * @return livro
       */
      Livro findByIsbn(String isbn);
 
}

Verifiquem que foram adicionados três métodos novos para busca:

• um para buscar os livros pelo autor;
• um para encontrar os livros pelo título e;
• um para encontrar o livro pelo seu ISBN.

A classe Controller é bastante simples, primeiro é adicionada a anotação @Controller para indicar que a classe é um controlador, e a anotação @RequestMapping, que indica o caminho para acessar esse controlador. É adicionado um atributo do tipo LivroRepository, que é o repositório criado na Listagem 3, onde o próprio Spring fará a injeção dessa dependência. Além disso, existem dois métodos: um para listar os livros de um determinado autor e que será acessado quando a requisição para esse controlador for do tipo GET, e o método para adicionar um livro, que será acessado quando a requisição for do tipo POST. A Listagem 4 mostra o código dessa classe.

package com.devmedia.mvc.controller;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
 
import com.devmedia.mvc.entity.Livro;
import com.devmedia.mvc.repository.LivroRepository;
 
import java.util.List;
 
@Controller
@RequestMapping("/")
public class LivroController {
      
      private LivroRepository livroRepository;
 
      @Autowired
      public LivroController( LivroRepository livroRepository) {
            this.livroRepository = livroRepository;
      }
 
      @RequestMapping(value = "/{autor}", method = RequestMethod.GET)
      public String listaLivros(@PathVariable("autor") String autor, Model model) {
            List<Livro> listaLivros = livroRepository.findByAutor(autor);
            if (listaLivros != null) {
                  model.addAttribute("livros", listaLivros);
            }
            return "listaLivros";
      }
 
      @RequestMapping(value = "/{autor}", method = RequestMethod.POST)
      public String adicionaLivroAutor(@PathVariable("autor") String autor, Livro livro) {
            livro.setAutor(autor);
            livroRepository.save(livro);
            return "redirect:/{autor}";
      }
}

O método listaLivros é bastante simples, pois ele será acessado quando a requisição para esse controlador for do tipo GET e receberá como parâmetro o nome de um autor, por onde é feita uma busca no banco de dados para encontrar todos os livros desse autor. Caso sejam encontrados livros, essa lista é adicionada no model para que seja mostrada depois na tela da aplicação, o que será mostrado na próxima listagem.

O método adicionaLivroAutor é parecido com o anterior, pois ele será acessado quando a requisição para o controlador for do tipo POST e recebe também como parâmetro o nome de um autor. A diferença é que, além disso, ele também deve receber os dados de um livro, o que será feito por um formulário, que também será mostrado na próxima listagem. O livro enviado pela requisição será cadastrado no banco de dados utilizando a interface repositório. Por fim, esse método redireciona para o método listaLivros, e o livro que acabou de ser cadastrado já será exibido na tela.

Com todas as classes para acesso e inserção dos dados, basta criar a visão e para isso foi criado o arquivo listaLivros.html na pasta src/main/resources/templates. Essa tela tem duas partes, sendo a primeira uma lista dos livros do autor que foi recuperado a partir da URL de acesso, que deve ser feita no formato http://localhost:8080/nomeAutor. Se não existir nenhum livro cadastrado para o autor será mostrado o texto “Nenhum Livro Cadastrado para esse autor”, caso contrário será mostrada a lista de livro. A segunda parte da tela é um formulário de cadastro de livros com os dados Titulo, ISBN e descrição, e o autor é cadastrado com o nome do autor da página acessada. A Listagem 5 mostra o código dessa tela.

<html>
<head>
<title>Reading List</title>
</head>
<body>
  <h2>Lista de Livros por Autor</h2>
  <div th:unless="${#lists.isEmpty(livros)}">
    <dl th:each="livro : ${livros}">
      <dt class="bookHeadline">
        <span th:text="${livro.titulo}">Title</span> by <span
              th:text="${livro.autor}">Author</span> (ISBN: <span
              th:text="${livro.isbn}">ISBN</span>)

      </dt>
      <dd class="bookDescription">
        <span th:if="${livro.description}" th:text="${livro.description}"
        >Description</span>
        <span th:if="${livro.description eq null}"> Nenhuma descrição 
        foi adicionada para esse livro!</span>
      </dd>
    </dl>
  </div>
  <div th:if="${#lists.isEmpty(livros)}">
    <p>Nenhum Livro Cadastrado para esse autor</p>
  </div>
  <hr />
  <h3>Adicione um novo livro para o autor:</h3>
  <form method="POST">
    <label for="title">Title:</label> <input type="text" 
    name="titulo" size="50"></input><br />  
    <label for="isbn">ISBN:</label> <input type="text" 
    name="isbn" size="15"></input><br /> 
    <label      for="description">Description:</label><br />
    <textarea name="description" cols="80" rows="5"> </textarea>
    <br /> <input type="submit"></input>
  </form>
</body>
</html>

Por último, é necessário criar a classe que inicializa a aplicação com o Spring Boot e cria o banco de dados H2 e o Apache Tomcat. A única configuração necessária nesse arquivo é dizer onde estarão as entidades, os repositórios e os controladores (se tudo estiver no mesmo pacote isso não é necessário). A Listagem 6 mostra o código dessa classe.

package com.devmedia.mvc.application;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.orm.jpa.EntityScan;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
 
@SpringBootApplication
@EntityScan(basePackages = { "com.devmedia.mvc.entity" })
@EnableJpaRepositories(basePackages = { "com.devmedia.mvc.repository" })
@ComponentScan(basePackages = {"com.devmedia.mvc.controller"})
public class Application {
      public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
      }
}

Para rodar a aplicação no Eclipse basta executar a classe Application e esperar o Tomcat ser inicializado. Assim que isso acontecer, acesse de qualquer browser o endereço http://localhost:8080/nomeDeAutor. Com isso será mostrada a tela da aplicação desenvolvida. Inicialmente a lista de livros estará vazia, mas você pode cadastrar quantos livros quiser utilizando o formulário que está na parte de baixo da tela. A Figura 1 mostra como exemplo a aplicação sendo executada com o nome do autor Eduardo: vejam que existem dois livros cadastrados para esse autor e abaixo aparece o formulário, onde podem ser cadastrados mais livros para este. O endereço de acesso para essa página foi http://localhost:8080/Eduardo.

Caso a aplicação seja acessada com o nome de outro autor é exibida a lista correspondente a este, como mostra a Figura 2, onde a página foi acessada passando o nome Luiz como nome do autor. A aplicação diferencia o autor que está sendo acessado pela URL que foi acessada: nesse caso o autor é o Luiz, pois o endereço usado na requisição foi http://localhost:8080/Luiz.

Esse artigo mostrou como desenvolver uma aplicação simples com o Spring Boot utilizando os frameworks Spring Data e Spring MVC. Nessa aplicação não foi necessária praticamente nenhuma configuração, nem de banco de dados, nem de arquivos XML e praticamente nenhuma anotação de configuração. Esse é o grande objetivo do Spring Boot, que permite ao o programador focar apenas no desenvolvimento dos requisitos funcionais da aplicação, evitando o trabalho repetitivo que são necessários em todos os projetos.