Criando um CRUD de Usuário com Spring Boot: Guia Passo a Passo

—

por

admin
em

Neste tutorial, vamos ensinar como criar um aplicativo Spring Boot que permite realizar as operações básicas de CRUD (Create, Read, Update, Delete) para gerenciar informações de um usuário. Usaremos Spring Data JPA para manipulação do banco de dados e o Spring Boot para simplificar o desenvolvimento. Esse post é ideal para desenvolvedores que estão começando com Spring Boot ou aqueles que desejam aprimorar suas habilidades em back-end com Java.

Preparando o Ambiente

Requisitos

Antes de começarmos a codificar, é importante garantir que temos o ambiente adequado configurado:

  • Java: Instale o JDK 11 ou superior.
  • IDE: Recomendamos o Spring Tool Suite (STS), mas você pode usar qualquer IDE Java, como IntelliJ ou Eclipse.
  • Maven: Embora o Spring Boot já venha com Maven embutido, se você preferir, pode instalá-lo separadamente.
  • Banco de Dados: Instale o MySQL ou qualquer outro banco de dados relacional de sua escolha.

Criando um Novo Projeto Spring Boot

  1. Vá para o Spring Initializr.
  2. Escolha as opções:
    • Project: Maven Project
    • Language: Java
    • Spring Boot Version: 2.x ou superior
    • Packaging: Jar
    • Java Version: 11 ou superior
  3. Adicione as dependências:
    • Spring Web
    • Spring Data JPA
    • MySQL Driver
  4. Clique em Generate e baixe o arquivo ZIP do seu projeto.

Descompacte o arquivo e abra o projeto na sua IDE.

Estrutura do Projeto

O projeto será organizado da seguinte forma:

  • src/main/java/com/exemplo/crudusuario: Código-fonte da aplicação.
    • Controller: Onde as rotas serão definidas.
    • Service: Lógica de negócios e operações com o banco de dados.
    • Model: Definição da entidade Usuario.
    • Repository: Interface de persistência de dados com Spring Data JPA.

Configuração do Banco de Dados

Abra o arquivo src/main/resources/application.properties e adicione a configuração para o banco de dados MySQL:

propertiesCopiarEditarspring.datasource.url=jdbc:mysql://localhost:3306/usuarios_db
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update
spring.jpa.database-platform=org.hibernate.dialect.MySQL5Dialect

Criando a Entidade Usuário

Agora, vamos criar a classe Usuario que será a nossa entidade.

Classe Usuario

package com.exemplo.crudusuario.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Usuario {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String nome;
    private String email;
    private String senha;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getSenha() {
        return senha;
    }

    public void setSenha(String senha) {
        this.senha = senha;
    }
}

Criando o Repositório com Spring Data JPA

Agora vamos criar o repositório que permitirá interagir com o banco de dados. A interface UsuarioRepository estende JpaRepository, o que já fornece os métodos básicos de CRUD.

package com.exemplo.crudusuario.repository;

import com.exemplo.crudusuario.model.Usuario;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UsuarioRepository extends JpaRepository<Usuario, Long> {
}

Criando o Serviço de Usuário

A classe UsuarioService é responsável pela lógica de negócios, como salvar, listar e excluir usuários.

package com.exemplo.crudusuario.service;

import com.exemplo.crudusuario.model.Usuario;
import com.exemplo.crudusuario.repository.UsuarioRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UsuarioService {

    @Autowired
    private UsuarioRepository usuarioRepository;

    public Usuario salvarUsuario(Usuario usuario) {
        return usuarioRepository.save(usuario);
    }

    public List<Usuario> listarUsuarios() {
        return usuarioRepository.findAll();
    }

    public Usuario obterUsuarioPorId(Long id) {
        return usuarioRepository.findById(id).orElse(null);
    }

    public void excluirUsuario(Long id) {
        usuarioRepository.deleteById(id);
    }
}

Criando o Controlador de Usuário

Agora vamos criar o controlador que irá expor as rotas para interagir com o CRUD. Usaremos as anotações do Spring MVC como @RestController e @RequestMapping para definir as APIs.

package com.exemplo.crudusuario.controller;

import com.exemplo.crudusuario.model.Usuario;
import com.exemplo.crudusuario.service.UsuarioService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/usuarios")
public class UsuarioController {

    @Autowired
    private UsuarioService usuarioService;

    @PostMapping
    public ResponseEntity<Usuario> criarUsuario(@RequestBody Usuario usuario) {
        Usuario savedUsuario = usuarioService.salvarUsuario(usuario);
        return ResponseEntity.status(HttpStatus.CREATED).body(savedUsuario);
    }

    @GetMapping
    public List<Usuario> listarUsuarios() {
        return usuarioService.listarUsuarios();
    }

    @GetMapping("/{id}")
    public ResponseEntity<Usuario> obterUsuario(@PathVariable Long id) {
        Usuario usuario = usuarioService.obterUsuarioPorId(id);
        return usuario != null ? ResponseEntity.ok(usuario) : ResponseEntity.notFound().build();
    }

    @PutMapping("/{id}")
    public ResponseEntity<Usuario> atualizarUsuario(@PathVariable Long id, @RequestBody Usuario usuario) {
        usuario.setId(id);
        Usuario updatedUsuario = usuarioService.salvarUsuario(usuario);
        return ResponseEntity.ok(updatedUsuario);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> excluirUsuario(@PathVariable Long id) {
        usuarioService.excluirUsuario(id);
        return ResponseEntity.noContent().build();
    }
}

Testando o CRUD de Usuário

Para testar o CRUD, use ferramentas como Postman ou Insomnia para enviar requisições HTTP para o seu aplicativo. Aqui estão alguns exemplos de como as requisições podem ser feitas:

POST – Criar um Usuário:

  • URL: http://localhost:8080/usuarios
  • Corpo:
  • { "nome": "João Silva", "email": "joao@exemplo.com", "senha": "senha123" }

GET – Listar Todos os Usuários:

  • URL: http://localhost:8080/usuarios

GET – Obter um Usuário por ID:

  • URL: http://localhost:8080/usuarios/1

PUT – Atualizar um Usuário:

  • URL: http://localhost:8080/usuarios/1
  • Corpo:
  • { "nome": "João Silva Atualizado", "email": "joao@exemplo.com", "senha": "novaSenha123" }

DELETE – Excluir um Usuário:

  • URL: http://localhost:8080/usuarios/1

Conclusão

Neste tutorial, aprendemos como criar um aplicativo Spring Boot que permite realizar as operações básicas de CRUD para gerenciar usuários. Utilizamos Spring Data JPA para facilitar a manipulação dos dados no banco e construímos um controlador REST para expor as APIs.

Agora você pode expandir esse CRUD adicionando funcionalidades como autenticação, validação de entrada de dados, ou até mesmo uma interface de usuário em front-end.

Comentários

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *