IzaTec Play
Jpa

CRUD

Create (Criar), Read (Ler), Update (Atualizar) e Delete (Excluir)
Pré-requisitos: Noções Básicas de SQL e um projeto Spring Boot com Spring Data JPA conectando em um banco de dados relacional.

C.R.U.D

O que é CRUD?

CRUD é um acrônimo para Create (Criar), Read (Ler), Update (Atualizar) e Delete (Excluir). Essas quatro operações básicas são usadas para gerenciar dados em sistemas de banco de dados, aplicativos e outros tipos de armazenamento.

Operações

  1. Create:
    Criação de novos registros no banco de dados. Exemplo: Inserir um novo usuário em um sistema.
  • SQL: INSERT INTO tabela (campo1, campo2) VALUES (valor1, valor2);
  1. Read:
    Leitura ou recuperação de dados do banco de dados. Exemplo: Buscar informações sobre um usuário.
  • SQL: SELECT * FROM tabela WHERE condição;
  1. Update:
    Atualização de registros existentes no banco de dados. Exemplo: Alterar o endereço de um usuário.
  • SQL: UPDATE tabela SET campo1 = valor1 WHERE condição;
  1. Delete:
    Exclusão de registros do banco de dados. Exemplo: Remover um usuário do sistema.
  • SQL: DELETE FROM tabela WHERE condição;

Características

  • Simplicidade: CRUD é uma abordagem simples e eficiente para gerenciar dados.
  • Versatilidade: Pode ser utilizado em diversas tecnologias (SQL, MongoDB, Firebase, etc.).
  • Base de Desenvolvimento: CRUD forma a base de muitos aplicativos web e móveis.

Contexto

Aqui está uma estrutura simples de uma entidade Cliente utilizando JPA, contendo os atributos id, nome, aniversario, renda e cidade para podermos praticar as diferentes abordagens para a realização de consulta de dados com JPA.

Cliente.java
import jakarta.persistence.*;
import lombok.Data;
import java.time.LocalDate;
@Entity
@Table(name = "tab_cliente")
@Data
public class Cliente {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id_cliente")
    private Integer id;
    @Column(name = "nome_completo")
    private String nome;
    @Column(name = "dt_aniversario")
    private LocalDate aniversario;
    @Column(name = "renda_media")
    private Double renda;
    @Column(name = "nome_cidade")
    private String cidade;
    @Override
    public String toString() {
        return "Cliente{" +
                "id=" + id +
                ", nome='" + nome + '\'' +
                ", aniversario=" + aniversario +
                ", renda=" + renda +
                ", cidade='" + cidade + '\'' +
                '}';
    }
}
Estamos customizando todas as características de nossa entidade Cliente em relação a tabela no banco de dados para facilitar a compreensão entre SQL e JPQL.
  1. Entidade Cliente:
  • A entidade Cliente deve conter os seguintes atributos:
    • id_cliente (Identificador único, chave primária)
    • nome_completo (Nome do cliente)
    • dt_aniversario (Data de aniversário)
    • renda_media (Renda mensal média)
    • nome_cidade (Cidade de residência)
  1. Operações de Inserção:
  • Inserir 5 registros com os seguintes dados:
    • João: data de aniversário (15/05/1990), renda (2500.00), cidade ("São Paulo")
    • Lucas: data de aniversário (22/03/1985), renda (3000.00), cidade ("Rio de Janeiro")
    • Ana: data de aniversário (10/07/1992), renda (3500.00), cidade ("Belo Horizonte")
    • Letícia: data de aniversário (10/07/1992), renda (3200.00), cidade ("Porto Alegre")
    • Marcos: data de aniversário (30/11/1988), renda (2000.00), cidade ("Curitiba")
  1. Alterações nos Dados:
  • Alterar a cidade de João para "Recife".
  • Alterar a renda de Lucas para 3500.00.
  1. Exclusão de Registro:
  • Excluir o registro de Marcos.

SQL

  1. INSERT
-- Inserindo os registros
INSERT INTO tab_cliente (nome_completo, dt_aniversario, renda_media, nome_cidade) 
VALUES
('Joao', '1990-05-15', 2500.00, 'São Paulo'),
('Lucas', '1985-03-22', 3000.00, 'Rio de Janeiro'),
('Ana', '1992-07-10', 3500.00, 'Belo Horizonte'),
('Leticia', '1992-07-10', 3200.00, 'Porto Alegre'),
('Marcos', '1988-11-30', 2000.00, 'Curitiba');
  1. UPDATE
UPDATE tab_cliente
SET nome_cidade = 'Recife'
WHERE nome_completo = 'Joao';

UPDATE tab_cliente
SET renda_media = 3500.00
WHERE nome_completo = 'Lucas';
  1. DELETE
DELETE FROM tab_cliente
WHERE nome_completo = 'Marcos';

Spring Data

O Spring Data JPA Repository possui um arsenal de métodos já disponíveis na especificação, mas iremos ilustrar outra forma de localizar um registro no banco de dados.

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;

public interface ClienteRepository extends JpaRepository<Cliente, Integer> {
    // Método customizado para buscar cliente pelo nome
    Optional<Cliente> findByNome(String nome);
}

Agora vamos criar um Service que métodos de exemplo de CRUD.

Esta abordagem apresentada no Service é uma ilustração, recomendamos não utilizar em prjetos reais.
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDate;
import java.util.Optional;

@Service
public class ClienteService {

    @Autowired
    private ClienteRepository clienteRepository;

    // Criar clientes
    public void criarClientes() {
        Cliente joao = new Cliente();
        joao.setNome("Joao");
        joao.setAniversario(LocalDate.of(1990, 5, 15));
        joao.setRenda(2500.00);
        joao.setCidade("São Paulo");

        Cliente lucas = new Cliente();
        lucas.setNome("Lucas");
        lucas.setAniversario(LocalDate.of(1985, 3, 22));
        lucas.setRenda(3000.00);
        lucas.setCidade("Rio de Janeiro");

        Cliente ana = new Cliente();
        ana.setNome("Ana");
        ana.setAniversario(LocalDate.of(1992, 7, 10));
        ana.setRenda(3500.00);
        ana.setCidade("Belo Horizonte");

        Cliente leticia = new Cliente();
        leticia.setNome("Leticia");
        leticia.setAniversario(LocalDate.of(1992, 7, 10));
        leticia.setRenda(3200.00);
        leticia.setCidade("Porto Alegre");

        Cliente marcos = new Cliente();
        marcos.setNome("Marcos");
        marcos.setAniversario(LocalDate.of(1988, 11, 30));
        marcos.setRenda(2000.00);
        marcos.setCidade("Curitiba");

        clienteRepository.save(joao);
        clienteRepository.save(lucas);
        clienteRepository.save(ana);
        clienteRepository.save(leticia);
        clienteRepository.save(marcos);
    }

    // Buscar cliente por ID
    public Cliente buscarPorId(Integer id) {
        return clienteRepository.findById(id).orElseThrow(() -> new RuntimeException("Cliente não encontrado"));
    }

    // Buscar cliente por nome
    public Cliente buscarPorNome(String nome) {
        return clienteRepository.findByNome(nome).orElseThrow(() -> new RuntimeException("Cliente não encontrado"));
    }

    // Alterar a cidade de João
    @Transactional
    public void alterarCidadeDeJoao() {
        Cliente joao = buscarPorNome("Joao");
        joao.setCidade("Recife");
        clienteRepository.save(joao);
    }

    // Alterar a renda de Lucas
    @Transactional
    public void alterarRendaDeLucas() {
        Cliente lucas = buscarPorNome("Lucas");
        lucas.setRenda(3500.00);
        clienteRepository.save(lucas);
    }

    // Excluir Marcos
    @Transactional
    public void excluirMarcos() {
        Cliente marcos = buscarPorNome("Marcos");
        clienteRepository.delete(marcos);
    }
}

READ?

Agora que você dominou as operações principais de persistência de dados, que tal explorar as alternativas de consultas SQL em nossa plataforma? Acesse o link JPA - Consultas

Hierárquicas

Conhecendo as anotações hierárquicas do JPA

Introdução

Introdução às Consultas no JPA