Primeiros passos com o Spring Framework
5 minutos de leitura
Autor(a)
Elias Ribeiro
Inscreva-se em nossa Newsletter
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
5 minutos de leitura
Autor(a)
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
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.
Guia rápido de migração EJB2 para EJB3
Ler maisBrincando com Generics: o BizarreGenericDao
Ler mais
Screencast: sua App no Cloud com OpenShift
Ler mais
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?
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.
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.
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:
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.
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?
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?
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?
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.
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.
Avalie este artigo