Primeiros passos com o Spring Framework

Primeiros passos com o Spring Framework

Fomos solicitados a implementar um sistema Web de controle de produtos em uma loja de eletrônicos. Inicialmente, discutimos com o cliente quais operações ele esperava realizar nesse sistema.

Segundo ele, era necessário adicionar, visualizar, alterar e remover produtos, ou seja, precisaríamos implementar um CRUD (Create, Read, Update e Delete).

Começamos desenvolvendo o código para adicionar um produto:

public void adicionarProduto(HttpServletRequest request) {
    try {
        String nome = request.getParameter("nome");
        int quantidade = Integer.parseInt(request.getParameter("quantidade"));
        Produto produto = new Produto();
        produto.setNome(nome);
        produto.setQuantidade(quantidade);
        String sql = "insert into produtos (nome, quantidade) values (?, ?)";
        PreparedStatement stmt = connection.prepareStatement(sql);
        stmt.setString(1, produto.getNome());
        stmt.setInteger(2, produto.getQuantidade());
        stmt.execute();
        stmt.close();
    } catch (SQLException e) {
        throw new RuntimeException(e);
    }
}

No entanto, percebemos que o código estava ficando muito extenso e não tínhamos implementado metade das funcionalidades solicitadas. Apenas conseguimos lidar com a inserção de produtos, mas ainda faltavam as funcionalidades de visualização, atualização e remoção.

Se continuássemos nesse caminho, o código ficaria imenso e dificultaria a legibilidade e manutenção.

Como poderíamos resolver esse problema?

Utilizando Spring Framework

A solução mais elegante para lidar com essa situação é utilizar algum framework, como o Spring Framework.

O Spring é um framework que simplifica bastante o desenvolvimento, oferecendo maior legibilidade de código, implementações mais concisas e facilidade na manutenção. Isso resulta em uma entrega mais rápida.

Para começar a utilizá-lo, precisamos criar um projeto.

Banner promocional da Alura, com um design futurista em tons de azul, apresentando dois blocos de texto, no qual o bloco esquerdo tem os dizeres:

Criando o projeto

Podemos criar o projeto acessando o site do Spring Initializr e selecionando as dependências necessárias. Quais dependências precisamos?

Para nossa aplicação web, precisamos da dependência "Web", que permite o acesso dinâmico por meio de qualquer dispositivo.

Como toda aplicação web, precisamos de um banco de dados para armazenar os dados. Vamos utilizar o banco de dados MySQL, pois precisamos salvar e manipular os dados. Além disso, precisamos do JPA para persistir nossas classes no banco de dados e fazer o mapeamento automático.

Parte “Dependencies” do site spring initializer com as respectivas dependências: “Spring Web WEB - Build web, including RESTful, applications using Spring MVC. Uses Apache Tomcat as the default embedded container”, “MySQL Driver - MySQL JDBC driver” e “Spring Data JPA - Persist data in SQL stores with Java Persistence API using Spring Data and Hibernate”.

Agora, nas configurações do projeto que ficam no lado esquerdo do site, vamos nomear o group como br.com.sistema e definir o artifact como loja. Ficando da seguinte maneira:

Parte “Project Metadata” do site spring initializer com um formulário e os respectivos campos e preenchimento: Group: br.com.sistema; Artifact: usuarios; Name: usuarios; Description: Primeiros passos com o Spring Framework; Packeage name: br.com.sistema.usuarios; Packaging: Jar; Java: 17.

Após isso, podemos gerar o projeto clicando em "Generate Project". Isso vai gerar um arquivo zip contendo o projeto que criamos. Devemos extrair o conteúdo do arquivo e importá-lo para nossa IDE.

Configurando o projeto

Com o projeto importado, precisamos configurar o DataSource. Essa configuração é feita no arquivo "application.properties", onde definimos as propriedades da aplicação.

Por exemplo, ao utilizar o banco de dados MySQL, devemos especificar a URL de conexão, o nome do banco de dados, o nome de usuário e a senha.

Além disso, podemos definir a propriedade "ddl-auto" como "update" para que o banco de dados seja atualizado automaticamente com as mudanças nas entidades JPA.

spring.datasource.url=jdbc:mysql://localhost/loja?createDatabaseIfNotExist=true
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update

Mas, o que são essas entidades?

Entidades

As entidades representam os modelos das tabelas em nosso banco de dados. No Java, podemos usar a anotação @Entity para indicar que uma classe é uma entidade.

Além disso, devemos mapear o ID da classe usando a anotação @Id e especificar a estratégia de geração do ID usando a anotação @GeneratedValue.

Por exemplo, podemos ter a classe "Produto" como uma entidade:

@Entity
public class Produto {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String nome;
    private Integer quantidade;

    // getters e setters omitidos
}

Agora criamos esses atributos no banco de dados, mas ainda não inserimos, pesquisamos ou alteramos nada até o momento. E como isso pode ser feito? Será que dá para fazer direto na Entidade?

Repositório

Para lidar com as operações de inserção, pesquisa, atualização e remoção dos dados, podemos usar os repositórios. O Spring Data fornece a interface CrudRepository que nos permite realizar essas operações sem escrever muito código.

Podemos criar um repositório para a entidade "Produto" estendendo a interface "CrudRepository<Produto, Long>". Por exemplo:

public interface ProdutoRepository extends CrudRepository<Produto, Long> {}

Porém, como vamos controlar a aplicação para saber o que vamos fazer?

Controller

Os controladores são responsáveis pela comunicação entre a aplicação e o banco de dados. Eles controlam o fluxo da aplicação de acordo com os métodos HTTP, como GET e POST.

Podemos utilizar as anotações @RestController e @RequestMapping para mapear os controladores. Por exemplo:

@RestController
@RequestMapping("/api/produtos")
public class ProdutosController {

    @GetMapping
    public List<Produto> listarProdutos() {
        return produtoRepository.findAll();
    }

    @PostMapping
    public ResponseEntity adicionarProduto(@RequestBody Produto produto) {
        produtoRepository.save(produto);
        return ResponseEntity.status(201).build();
    }
}

Nesse exemplo, temos um método GET mapeado para a URL "/api/produtos", que retorna uma lista de produtos obtida pelo método findAll() do repositório.

Também temos um método POST mapeado para a mesma URL, que recebe um produto no corpo da requisição e o salva no banco de dados usando o método save() do repositório.

Conclusão

Ao utilizar o Spring Framework, podemos lidar de forma mais eficiente com códigos longos e de difícil leitura, como os códigos que utilizam Servlets e JDBC. O Spring nos oferece recursos que simplificam o desenvolvimento, permitindo a implementação rápida de operações CRUD.

Com o uso de anotações, mapeamos as entidades, os repositórios e os controladores, facilitando a comunicação entre a aplicação e o banco de dados. Isso nos permite criar uma aplicação mais legível e simples de manter.


Artigo atualizado por:

Veja outros artigos sobre Programação